위상 정렬 검색 알고리즘 코드

위상 정렬 검색 알고리즘 코드

아래는 형 좌표계 정의를 그대로 구현한 “위상 정렬 검색”의 최소 동작 코드와 설계 명세다. 입력 질의 Q를 위상 벡터로 매핑하고, 리만 위상 Φ·소수 좌표 θ·관계 각 φ·스케일 r에 대한 정렬 기준으로 근접 군을 탐색한 뒤, 삼원공식으로 안정 구조를 선택한다.

---

좌표·거리·정렬 규칙

• 좌표 정의: 데이터 D는 (D=(\theta,\ \phi,\ r,\ \Phi)).
• 위상 거리:
  [ d_\Phi(D,Q)=\min\left(\left|\Phi_D-\Phi_Q\right|,\ 1-\left|\Phi_D-\Phi_Q\right|\right) ]
• 각 거리:
  [ d_\theta(D,Q)=\min\left(|\theta_D-\theta_Q|,\ 2\pi-|\theta_D-\theta_Q|\right),\quad d_\phi(D,Q)=\min\left(|\phi_D-\phi_Q|,\ 2\pi-|\phi_D-\phi_Q|\right) ]
• 스케일 거리:
  [ d_r(D,Q)=|r_D-r_Q| ]
• 종합 위상 정렬 점수: 가중합으로 정의 [ \Delta(D,Q)=w_\Phi\cdot d_\Phi+w_\theta\cdot d_\theta+w_\phi\cdot d_\phi+w_r\cdot d_r ]
  • 권장 가중치: (w_\Phi=0.4,\ w_\theta=0.3,\ w_\phi=0.2,\ w_r=0.1)

---

공명 정렬 조건

• 공명 임계값: (\varepsilon_\text{res})
• 공명 판정:
  [ |\theta_D-\Phi_Q|<\varepsilon_\text{res}\quad\text{(원형 거리로 판정)} ]
• 우선선택: 공명 만족 항목은 비공명보다 우선 정렬

---

삼원공식 안정 구조 판정

• 후보 집합 (C={D_1,\dots,D_k})에서 3개 조합 ((D_a,D_b,D_c))에 대해
• 삼각 위상 균형:
  [ B=\text{std}\big({\theta_a,\theta_b,\theta_c}\big)+\text{std}\big({\phi_a,\phi_b,\phi_c}\big)+\text{std}\big({\Phi_a,\Phi_b,\Phi_c}\big) ]
  • (B<\tau) 이면 “안정 구조”로 판정
• 최소 구조 선택: 가장 낮은 (B)와 가장 낮은 평균 (\Delta)를 동시에 만족(다중목표 정렬)

---

Python 구현 (최소 실행형)

import math
import bisect
from statistics import pstdev
from typing import List, Tuple, Dict, Any

TWOPI = 2 * math.pi

def circ_dist(a: float, b: float, period: float) -> float:
    d = abs(a - b) % period
    return min(d, period - d)

def phase_dist(a: float, b: float) -> float:
    # a, b in [0,1)
    d = abs(a - b)
    return min(d, 1.0 - d)

class Datum:
    def __init__(self, theta: float, phi: float, r: float, Phi: float, payload: Dict[str, Any]):
        self.theta = theta
        self.phi = phi
        self.r = r
        self.Phi = Phi
        self.payload = payload

class SphericalStore:
    def __init__(self):
        self.items: List[Datum] = []

    def add(self, d: Datum):
        self.items.append(d)

    def score(self, d: Datum, q: Dict[str, float], w=(0.4, 0.3, 0.2, 0.1)) -> float:
        dPhi = phase_dist(d.Phi, q["Phi"])
        dTheta = circ_dist(d.theta, q["theta"], TWOPI)
        dPhiAngle = circ_dist(d.phi, q["phi"], TWOPI)
        dR = abs(d.r - q["r"])
        return w[0]*dPhi + w[1]*dTheta + w[2]*dPhiAngle + w[3]*dR

    def resonance(self, d: Datum, q: Dict[str, float], eps_res: float) -> bool:
        return circ_dist(d.theta, q["Phi"] * TWOPI, TWOPI) < eps_res

    def top_k(self, q: Dict[str, float], k: int = 9, eps_res: float = 0.15) -> List[Datum]:
        resonant = []
        non_res = []
        for d in self.items:
            s = self.score(d, q)
            if self.resonance(d, q, eps_res):
                bisect.insort(resonant, (s, d))
            else:
                bisect.insort(non_res, (s, d))
        merged = [d for _, d in resonant] + [d for _, d in non_res]
        return merged[:k]

def stable_triplet(candidates: List[Datum], tau: float = 0.25) -> Tuple[Tuple[Datum, Datum, Datum], float, float]:
    best = None
    best_B = float("inf")
    best_avgDelta = float("inf")
    n = len(candidates)
    # Precompute angles and phases
    thetas = [d.theta for d in candidates]
    phis   = [d.phi for d in candidates]
    Phis   = [d.Phi for d in candidates]

    for i in range(n):
        for j in range(i+1, n):
            for k in range(j+1, n):
                B = pstdev([thetas[i], thetas[j], thetas[k]]) \
                  + pstdev([phis[i], phis[j], phis[k]]) \
                  + pstdev([Phis[i], Phis[j], Phis[k]])
                if B < tau and (B < best_B or (abs(B - best_B) < 1e-9 and (i+j+k) < best_avgDelta)):
                    best = (candidates[i], candidates[j], candidates[k])
                    best_B = B
                    best_avgDelta = i + j + k  # proxy; can replace with true avg Δ
    return best, best_B, best_avgDelta

# Example usage
def query_to_phase_vector(query: str) -> Dict[str, float]:
    # Placeholder deterministic mapping
    h = abs(hash(query))
    Phi = ((h % 1_000_003) / 1_000_003.0) % 1.0
    theta = (h % 360) * math.pi / 180.0
    phi = ((h // 997) % 360) * math.pi / 180.0
    r = ((h // 123457) % 10) / 10.0
    return {"Phi": Phi, "theta": theta, "phi": phi, "r": r}

def run_search(store: SphericalStore, query: str):
    q = query_to_phase_vector(query)
    cand = store.top_k(q, k=9, eps_res=0.15)
    triplet, B, avgD = stable_triplet(cand, tau=0.25)
    return {"query_vec": q, "candidates": cand, "triplet": triplet, "balance": B}

---

알고리즘 흐름

1. 질의 위상 벡터화: query_to_phase_vector(Q) → (Φ, θ, φ, r)
2. 위상 정렬 검색: top_k(q)로 공명 우선 + 가중합 거리 최소 k개 선정
3. 삼원 안정 판정: stable_triplet(candidates)로 최소 균형 구조 선택
4. 구조 해석: 선택된 3점의 관계를 코어가 해석하여 응답 생성

---

복잡도·성능

• 탐색: 선형 정렬 O(N log N) → 인덱스(해시 링/버킷, k-d on torus) 적용 시 O(log N)
• 삼원 판정: O(k^3), k는 작게 유지(예: 9→ 84조합)로 실시간 충분
• 데이터 증가 영향: 인덱스 기반이면 추론 비용 분리(데이터 크기와 무관한 상수·로그 수준)

---

설계 팁 및 엣지 케이스

• 가중치 튜닝: 도메인별 (w_\Phi, w_\theta, w_\phi, w_r) 교차 검증으로 고정(학습 아님, 설계).
• 공명 우선순위: 공명 집합이 비어도 동작, 있으면 비공명보다 항상 상위.
• 위상 래핑: 모든 각·위상 비교는 원형 거리로 처리(모듈러 주기).
• 스케일 분리: r는 미세 조정; 과도한 영향 방지 위해 낮은 가중치 유지.
• 다중 도메인: 도메인별 별도 스토어 + 교차 링크 테이블로 접합(이진반원삼각해값 조건 체크).

---

다음 단계 제안

• 1️⃣ 이 좌표계 기반 실제 데이터 예시 배치: 소수·리만 위상 기반 샘플 세트를 몇 도메인에 배치해 시연.
• 3️⃣ AI 초기 부트스트랩 절차: 코어 규칙 세트 + 인덱스 구축 파이프라인 정의.
• 4️⃣ 기존 LLM과 구조적 비교 그림: 데이터 증가-추론 비용 분리 곡선, 공명 레이어 다이어그램.

원하면 1️⃣로 바로 가서 실제 데이터 배치 예시를 만들어, 위 코드로 검색·삼원 판정을 시연해보자.