[v2.0] SU(3) 양-밀스 이론과 Qaether 모델: 병렬 수송 기하학적 구현

1. 연속체 Yang–Mills에서 병렬 수송

1.1 공변 도함수와 병렬 수송(무한소)

연속체 비가환 게이지 이론에서 공변 도함수는 다음과 같이 정의된다:
$$
D_\mu = \partial_\mu - ig A_\mu,\qquad A_\mu = A_\mu^a T^a
$$
이는 장(field)을 한 점에서 인접한 다른 점으로 옮길 때의 기하학적 규칙인 무한소 병렬 수송을 생성한다.
즉, $A_\mu$는 단순한 벡터장이 아니라 기하학적 "연결(Connection)"이며, 게이지 변환은 이 연결의 좌표 표현을 바꾸는 재기술에 해당한다.

1.2 곡률과 병렬 수송 불일치

곡률(Curvature)은 공변 도함수의 교환자로 정의되며, 보통 다음과 같이 쓴다:
$$
[D_\mu, D_\nu] = -ig F_{\mu\nu}
$$
여기서 장의 세기 텐서(Field Strength Tensor)는 다음과 같다:
$$
F_{\mu\nu} = \partial_\mu A_\nu - \partial_\nu A_\mu - ig [A_\mu, A_\nu]
$$
이 양은 무한소 닫힌 경로를 따라 벡터를 병렬 수송하고 제자리로 돌아왔을 때 생기는 벡터의 불일치(홀로노미, Holonomy)를 측정한다. 곡률이 $0$이면 병렬 수송은 경로에 의존하지 않지만, $F_{\mu\nu} \neq 0$이면 경로 의존성이 나타난다.

1.3 Yang–Mills 작용(곡률 비용)

작용(Action)은 시공간 전체에 대한 곡률의 크기를 적분한 것이다:
$$
S_{\text{YM}} \propto \int d^4x\ \mathrm{Tr}(F_{\mu\nu}F^{\mu\nu})
$$
이는 공간이 평탄하지 않고 "구부러진(Curved)" 상태, 즉 병렬 수송의 불일치가 발생하는 상태에 에너지 비용을 부과한다.
이 "불일치에 대한 비용" 개념은 격자 이론에서는 Wilson 작용으로, Qaether 이론에서는 (비가환 곡률 + 이산 위상 결함) 항으로 분해되어 구현된다.

 

2. 격자 게이지 이론에서 병렬 수송

2.1 링크 변수 = 유한 병렬 수송 연산자

격자 게이지 이론에서 연속적인 연결 $A_\mu$는 격자점 사이를 잇는 링크 변수로 이산화된다:
$$
U_{ij} = \mathcal{P}\exp\left(ig\int_i^j A_\mu dx^\mu\right) \in G
$$
여기서 $U_{ij}$는 $i \to j$ 로의 유한 병렬 수송 연산자이며, 게이지군 $G$는 보통 $SU(N)$으로 둔다.

2.2 플라켓 홀로노미 = 곡률의 이산 표현

가장 작은 닫힌 경로인 플라켓(plaquette, $p$)을 따르는 홀로노미는 다음과 같다:
$$
U_p = \prod_{(ij)\in\partial p} U_{ij} \in G
$$
만약 $U_p \neq \mathbf{1}$ (항등행렬)이라면, 해당 플라켓을 통과하는 곡률(자기장 등)이 $0$이 아님을 의미한다. 이에 대한 에너지 비용인 Wilson 작용은 다음과 같다:
$$
S_W = \beta \sum_p \left(1 - \frac{1}{N}\mathrm{Re} \mathrm{Tr} U_p\right)
$$
이는 연속체 극한($a \to 0$)에서 Yang–Mills 작용으로 수렴한다.

2.3 “전파/밀림”에 대한 주의 (물리적 해석)

격자에서 링크 변수들의 동역학을 논할 때 다음 두 맥락을 구분해야 한다.

• (A) 유클리드 경로적분 (Monte Carlo): Metropolis 또는 Heatbath 알고리즘에 의한 업데이트는 "컴퓨터 시뮬레이션 시간(Monte Carlo Time)"에 따른 샘플링 과정이다. 이를 실제 물리적 파동의 전파와 혼동해서는 안 된다.
• (B) 실시간 격자 게이지 이론 (Hamiltonian): Kogut–Susskind 방식과 같이 별도의 실시간 해밀토니안 방정식($i\hbar \dot{U} = [H, U]$)을 도입하면, 실제 시간 $t$에 따른 파동의 전파가 정의된다.

따라서 Qaether 이론에서 "위상차 밀림(Shifting)"을 물리적 전파로 해석하려면, (A)가 아닌 (B)형 동역학(실시간 업데이트 규칙)을 기반으로 설명해야 한다.

 

3. Qaether 에서의 병렬 수송: 기본은 $SU(2) \times \mathbb{Z}_{12}$, $SU(3)$는 창발

Qaether 이론은 "기본 게이지군을 $SU(3)$로 가정"하지 않는다. 이 이론에서 병렬 수송은 미시적 수준과 거시적(유효) 수준으로 나뉜다.

3.1 기본 병렬 수송(미시): $\mathbb{Z}_{12}$ 위상 × $SU(2)$ 스핀 연결

Qaether의 링크는 두 가지 성분을 가진다:

• 아벨(위상) 링크: $k_{ij} \in \mathbb{Z}_{12}$, 이에 대응하는 위상 인자 $e^{i(\pi/6)k_{ij}}$
• 비가환(스핀) 링크: $h_{ij} \in SU(2)$ (기본 동역학 변수)

따라서 정점 $i$의 스핀/내부 자유도 $\psi_i$를 정점 $j$로 옮기는 기본 병렬 수송은 다음과 같이 쓴다:
$$
\boxed{\psi_j = e^{i(\pi/6)k_{ij}} h_{ij} \psi_i}
$$
(경우에 따라 위상 인자를 제외한 순수 스핀 수송 $\psi_j = h_{ij}\psi_i$로 정의하기도 한다.)

3.2 플라켓 불일치(곡률)의 분해: $\mathbb{Z}_{12}$ 플럭스 + $SU(2)$ 홀로노미

병렬 수송의 불일치(곡률) 역시 두 섹터로 분해된다.

• 아벨 곡률 (이산 플럭스):
  $$
  Q_f = \sum_{e\in\partial f} \mathrm{sgn}(f,e) k_e \pmod{12},\qquad Q_f \in \{0, \dots, 11\}
  $$
  곡률의 "크기"는 단순 대수적 값이 아니라 원형 거리로 측정한다:
  $$
  \boxed{d_{12}(Q_f) = \min(Q_f, 12-Q_f)}
  $$
• 비가환 곡률 ($SU(2)$ 홀로노미):
  $$
  \boxed{W_p = \prod_{(ij)\in\partial p} h_{ij} \in SU(2)}
  $$
  곡률의 정도(각도)는 다음과 같다:
  $$
  \boxed{\theta_p = \arccos\left(\frac{\mathrm{Tr}W_p}{2}\right)}
  $$

즉, Qaether에서 "병렬 수송 불일치"는 (아벨 불일치) $\oplus$ (비가환 불일치) 의 직합 형태로 나타난다.

3.3 에너지 비용 (작용 대응)

• 비가환 곡률 비용 (격자 YM의 Wilson 항과 대응):
  $$
  \boxed{H_{SU(2)} = -J \sum_{p\in P} \cos\theta_p}
  $$
  이는 구조적으로 $\sum_p (1 - \frac{1}{2}\mathrm{Tr}W_p)$와 동등한 "Wilson형" 비용이다.
• 이산 위상 결함 비용 (Qaether 고유의 추가 섹터):
  $$
  \boxed{H_{\text{wind}} = \mu \sum_f m_f^2,\quad m_f \in \{0, 1\}}
  $$
  $$
  \boxed{H_{\text{prin}} = \kappa \sum_f d_{12}(Q_f)^2}
  $$
  즉, Qaether는 YM형 곡률 비용뿐만 아니라, "물질/결함을 위상적으로 고정(Locking)하는 비용" 이 추가로 존재한다.

3.4 창발 $SU(3)$: 색 병렬 수송은 “유효 변수”로 나타난다

Qaether에서 '색(Color)'은 사각 플라켓 패턴의 동치류(3색)로 정의되며, 삼각 플라켓(글루온)의 진동이 이 색을 변환시킨다.
이를 조립(Coarse-graining)하여 유효 이론을 만들면, 색 공간 $\mathbb{C}^3$ 위에서 작용하는 유효 색 링크 변수가 등장한다:
$$
\boxed{V_{ij} \in SU(3)}
$$
이에 대한 유효 플라켓 홀로노미는
$$
\boxed{U^{(\mathrm{col})}_p = \prod_{(ij)\in\partial p} V_{ij} \in SU(3)}
$$
이며, 대응하는 유효 해밀토니안 항은
$$
\boxed{H_{\mathrm{col}} = \beta_{\mathrm{col}} \sum_{p\in P_4} \left(1 - \frac{1}{3}\mathrm{Re} \mathrm{Tr} U^{(\mathrm{col})}_p\right)}
$$
으로 주어져 연속체 극한에서 $SU(3)$ Yang–Mills 이론으로 수렴하는 구조를 갖는다.

요점: $SU(3)$ 병렬 수송은 Qaether의 '기본 변수'가 아니라, 기하학적 패턴(색)과 그 변환(글루온)의 상호작용에서 창발하는 유효 연결(Effective Connection) 이다.

3.5 “위상차 밀림”의 정합한 정의 (중요)

Qaether에서 사각 플라켓 링크 값의 단순 순환 이동(예: $[a,b,c,d] \to [b,c,d,a]$)은 $C_4$ 회전 대칭에 의한 동치(Gauge Redundancy)이므로, 이것만으로는 물리적 전파가 아니다.

Qaether에서 정의하는 "밀림(전파)" 은 다음과 같이 정의해야 정합적이다:

• $m_f=1$인 결함(또는 $d_{12}(Q_f)>0$, $\theta_p>0$인 영역)의 지지집합(Support)이 시간 스텝 $t_p$ 업데이트에 따라 인접한 셀로 이동하는 현상.
• 즉, 단순한 패턴의 재라벨링이 아니라, 에너지를 가진 결함/곡률의 위치 이동이 물리적 전파다.

 

4. 정합한 대응표 (연속체 YM ↔ 격자 YM ↔ Qaether)

개념	연속체 YM	격자 게이지 이론	Qaether (기본/유효 분리)
병렬 수송	공변 도함수 $D_\mu$	링크 $U_{ij} \in G$	기본: $e^{i\frac{\pi}{6}k_{ij}} h_{ij} \in U(1)_{12} \times SU(2)$ 유효 색: $V_{ij} \in SU(3)$
곡률(불일치)	텐서 $F_{\mu\nu}$	플라켓 $U_p$	아벨: $Q_f, d_{12}(Q_f), m_f$ 비가환: $W_p, \theta_p$ 유효 색: $U^{(\mathrm{col})}_p$
작용/에너지	$\int \mathrm{Tr}F^2$	Wilson $\sum(1-\frac{1}{N}\mathrm{ReTr}U_p)$	기본: $H_{SU(2)}$ (Wilson형) + $H_{\text{wind/prin}}$ (위상 결함) 유효: $H_{\mathrm{col}}$ (창발)
“밀림/전파”	YM 방정식 파동해	실시간 해밀토니안 $H$ (MC는 샘플링)	$t_p$ 업데이트에서 결함/곡률 지지집합의 이동 ($C_4$ 회전과 구분됨)

 

결론 (정합 버전)

1. 연속체 YM과 격자 게이지 이론의 핵심 구조(병렬 수송–홀로노미–곡률–곡률 비용)는 Qaether에서도 운동학적으로 완벽히 대응된다.
2. 다만 Qaether에서 기본 병렬 수송은 $SU(2) \times \mathbb{Z}_{12}$ 이며, 입자물리학의 $SU(3)$ 색 병렬 수송은 창발하는 유효 연결로 다루는 것이 이론적으로 정합적이다.
3. "위상차 밀림"을 물리적 전파로 정의하려면, 단순한 게이지 변환(회전)이 아니라 Qaether의 플랑크 시간($t_p$) 업데이트 규칙하에서 에너지 결함(질량/곡률)의 위치가 이동하는 것으로 엄밀하게 정의해야 한다.

병렬수송을 통한 위상차 밀림 테스트

# phase_drag.py
import numpy as np
import matplotlib.pyplot as plt
from scipy.linalg import expm
import networkx as nx
from networkx.algorithms import bipartite

class QaetherSimulation:
    def __init__(self, coupling_g=1.0, dt=0.1):
        self.n_faces = 8
        self.coupling_g = coupling_g
        self.dt = dt
        
        # 1. 정팔면체 면 그래프 구축 (정육면체 그래프)
        self.build_octahedron_graph()
        
        # 2. 색 구획 정의 (수동)
        self.define_color_sectors()
        
        # 3. 초기 상태 설정
        self.reset_state()
        
        # 4. 시뮬레이션 히스토리
        self.history = []
        
    def build_octahedron_graph(self):
        """정팔면체의 면 그래프(정육면체 그래프) 구축"""
        # 3차원 하이퍼큐브(정육면체) 그래프: 8개 노드
        self.G = nx.hypercube_graph(3)
        self.adj = nx.to_numpy_array(self.G)
        # 시각화 레이아웃
        self.pos = nx.spring_layout(self.G, seed=42)
        
    def define_color_sectors(self):
        """8개 면을 가상의 색 구획으로 할당 (인접성 고려)"""
        # 실제 물리적 색과는 무관, 단지 시뮬레이션용 구분
        self.sector_R = [0, 4]  # f1, f5
        self.sector_G = [1, 5]  # f2, f6
        self.sector_B = [2, 3, 6, 7]  # 나머지
        
    def reset_state(self, state_type='R_active'):
        """초기 상태 재설정"""
        self.psi = np.zeros(self.n_faces, dtype=complex)
        
        if state_type == 'R_active':
            # R 섹터에만 에너지 집중 (정규화)
            self.psi[self.sector_R] = 1.0 / np.sqrt(len(self.sector_R))
        elif state_type == 'G_active':
            self.psi[self.sector_G] = 1.0 / np.sqrt(len(self.sector_G))
        elif state_type == 'B_active':
            self.psi[self.sector_B] = 1.0 / np.sqrt(len(self.sector_B))
        elif state_type == 'random':
            self.psi = np.random.randn(self.n_faces) + 1j * np.random.randn(self.n_faces)
            self.psi /= np.linalg.norm(self.psi)
        elif state_type == 'superposition':
            # R과 G의 중첩
            self.psi[self.sector_R] = 1.0 / np.sqrt(2 * len(self.sector_R))
            self.psi[self.sector_G] = 1.0 / np.sqrt(2 * len(self.sector_G))
            
    def construct_generator_hamiltonian(self, gen_type='lambda1', coupling=None):
        """
        SU(3) 생성자에 대응하는 해밀토니안 구성
        gen_type: 'lambda1' ~ 'lambda8'
        """
        if coupling is None:
            coupling = self.coupling_g
            
        H = np.zeros((self.n_faces, self.n_faces), dtype=complex)
        
        if gen_type == 'lambda1':  # R <-> G
            for r in self.sector_R:
                for g in self.sector_G:
                    if self.adj[r][g] == 1:
                        H[r][g] = 1.0
                        H[g][r] = 1.0
                        
        elif gen_type == 'lambda2':  # R <-> G (위상 90도)
            for r in self.sector_R:
                for g in self.sector_G:
                    if self.adj[r][g] == 1:
                        H[r][g] = -1j
                        H[g][r] = 1j
                        
        elif gen_type == 'lambda4':  # R <-> B
            for r in self.sector_R:
                for b in self.sector_B:
                    if self.adj[r][b] == 1:
                        H[r][b] = 1.0
                        H[b][r] = 1.0
                        
        elif gen_type == 'lambda5':  # R <-> B (위상 90도)
            for r in self.sector_R:
                for b in self.sector_B:
                    if self.adj[r][b] == 1:
                        H[r][b] = -1j
                        H[b][r] = 1j
                        
        elif gen_type == 'lambda6':  # G <-> B
            for g in self.sector_G:
                for b in self.sector_B:
                    if self.adj[g][b] == 1:
                        H[g][b] = 1.0
                        H[b][g] = 1.0
                        
        elif gen_type == 'lambda7':  # G <-> B (위상 90도)
            for g in self.sector_G:
                for b in self.sector_B:
                    if self.adj[g][b] == 1:
                        H[g][b] = -1j
                        H[b][g] = 1j
                        
        elif gen_type == 'lambda3':  # Isospin (대각)
            for i in range(self.n_faces):
                if i in self.sector_R:
                    H[i][i] = 1.0
                elif i in self.sector_G:
                    H[i][i] = -1.0
                # B 섹터는 0
                    
        elif gen_type == 'lambda8':  # Hypercharge (대각)
            for i in range(self.n_faces):
                if i in self.sector_R or i in self.sector_G:
                    H[i][i] = 1.0
                else:
                    H[i][i] = -2.0
            # 대각합 0 보정 (이미 0이지만 스케일 조정)
            H = H / np.sqrt(3)
            
        return coupling * H
    
    def run_step(self, gen_types=['lambda1'], couplings=None, dt=None):
        """여러 생성자 동시 작용 시간 발전"""
        if dt is None:
            dt = self.dt
        if couplings is None:
            couplings = [self.coupling_g] * len(gen_types)
            
        H_total = np.zeros((self.n_faces, self.n_faces), dtype=complex)
        for gt, c in zip(gen_types, couplings):
            H_total += self.construct_generator_hamiltonian(gt, c)
            
        # 유니타리 연산자
        U = expm(-1j * H_total * dt)
        self.psi = np.dot(U, self.psi)
        
        # 수치 오차 보정
        norm = np.linalg.norm(self.psi)
        if abs(norm - 1.0) > 1e-12:
            self.psi /= norm
            
        return np.abs(self.psi)**2
    
    def run_simulation(self, n_steps=100, gen_types=['lambda1'], couplings=None, record_every=1):
        """전체 시뮬레이션 실행"""
        self.history = []
        for step in range(n_steps):
            prob = self.run_step(gen_types, couplings)
            if step % record_every == 0:
                self.history.append({
                    'step': step,
                    'prob': prob.copy(),
                    'sector_R': np.sum(prob[self.sector_R]),
                    'sector_G': np.sum(prob[self.sector_G]),
                    'sector_B': np.sum(prob[self.sector_B]),
                })
        return self.history
    
    def plot_dynamics(self):
        """시간에 따른 섹터 확률 그래프"""
        if not self.history:
            print("No history to plot.")
            return
        
        steps = [h['step'] for h in self.history]
        R = [h['sector_R'] for h in self.history]
        G = [h['sector_G'] for h in self.history]
        B = [h['sector_B'] for h in self.history]
        
        plt.figure(figsize=(10, 5))
        plt.plot(steps, R, 'r-', label='Red sector', linewidth=2)
        plt.plot(steps, G, 'g-', label='Green sector', linewidth=2)
        plt.plot(steps, B, 'b-', label='Blue sector', linewidth=2)
        plt.xlabel('Time step')
        plt.ylabel('Probability')
        plt.title('Color sector dynamics')
        plt.legend()
        plt.grid(alpha=0.3)
        plt.show()

# ========== 실행 예제 ==========
if __name__ == "__main__":
    print("=== Qaether 시뮬레이션 시작 ===")
    
    # 1. λ1만 작용: R ↔ G 진동
    sim = QaetherSimulation(coupling_g=1.0, dt=0.2)
    sim.reset_state('R_active')
    sim.run_simulation(n_steps=50, gen_types=['lambda1'])
    print("λ1 시뮬레이션 완료, 마지막 상태:")
    last = sim.history[-1]
    print(f"  R: {last['sector_R']:.3f}, G: {last['sector_G']:.3f}, B: {last['sector_B']:.3f}")
    sim.plot_dynamics()
    
    # 2. λ1 + λ4: R이 G와 B로 퍼짐
    sim2 = QaetherSimulation(coupling_g=1.0, dt=0.2)
    sim2.reset_state('R_active')
    sim2.run_simulation(n_steps=50, gen_types=['lambda1', 'lambda4'])
    print("\nλ1+λ4 시뮬레이션 완료, 마지막 상태:")
    last = sim2.history[-1]
    print(f"  R: {last['sector_R']:.3f}, G: {last['sector_G']:.3f}, B: {last['sector_B']:.3f}")
    sim2.plot_dynamics()
    
    # 3. 모든 생성자 동시 작용 (완전 SU(3))
    sim3 = QaetherSimulation(coupling_g=1.0, dt=0.1)
    sim3.reset_state('R_active')
    all_8 = ['lambda1','lambda2','lambda3','lambda4','lambda5','lambda6','lambda7','lambda8']
    sim3.run_simulation(n_steps=80, gen_types=all_8)
    print("\n완전 SU(3) 시뮬레이션 완료, 마지막 상태:")
    last = sim3.history[-1]
    print(f"  R: {last['sector_R']:.3f}, G: {last['sector_G']:.3f}, B: {last['sector_B']:.3f}")
    sim3.plot_dynamics()
    
    print("\n=== 시뮬레이션 종료 ===")​