coordinate-system 5.2.2__cp313-cp313-win_amd64.whl → 6.0.0__cp313-cp313-win_amd64.whl

coordinate_system/qframes.py

@@ -1,675 +1,792 @@
 """
-量子复标架代数 - 基于非对易几何的完整实现
-=======================================
-
-实现了完整的复标架场理论，包括：
-1. 连续谱复标架 (|x⟩, |p⟩) 满足 ⟨x|x'⟩ = δ(x-x')
-2. 非对易代数 [x̂, p̂] = iħ
-3. 量子联络与曲率
-4. 外尔关系与量子二项式展开
-
-核心创新：
-- 连续标架场的离散逼近保持几何结构
-- 算符代数与态矢代数分离
-- 非对易性的几何实现
-- 量子傅立叶变换作为标架旋转
-
-作者: DeepSeek
-日期: 2025-12-02
+复数量子化标架场 (Complex Quantum Frame Field)
+==============================================
+
+统一傅里叶变换与路径积分的几何框架。
+
+核心思想：
+- 傅里叶变换 = 复标架场的相位旋转 (QFrame * e^{iθ})
+- 共形变换 = 复标架场的缩放 (QFrame * λ, λ∈ℝ⁺)
+- 路径积分 = 标架场上的测度积分
+
+数学框架：
+- 复标度因子 Q ∈ ℂ 编码几何与谱空间的关系
+- 标架乘法实现变换复合
+- 行列式给出积分测度
+
+Author: Quantum Frame Theory
+Date: 2025-12-03
 """
 
 import numpy as np
-from typing import List, Tuple, Union, Optional, Callable
-import sympy as sp
+from typing import List, Tuple, Dict, Optional, Union, Any
 from dataclasses import dataclass
-from scipy import integrate, linalg
-from scipy.special import hermite
-import matplotlib.pyplot as plt
 
-# 物理常数
-HBAR = 1.0  # 简化普朗克常数
-
-# ========== 基础数学结构 ==========
+# 导入坐标系统
+try:
+    from .coordinate_system import coord3, vec3, quat
+except ImportError:
+    try:
+        from coordinate_system import coord3, vec3, quat
+    except ImportError:
+        # 延迟导入，允许独立使用
+        coord3 = None
+        vec3 = None
+        quat = None
 
-@dataclass
-class DiracVector:
-    """狄拉克符号中的态矢基元"""
-    value: float          # 本征值 (x 或 p)
-    basis: str           # 'position' 或 'momentum'
-    
-    def __repr__(self):
-        symbol = 'x' if self.basis == 'position' else 'p'
-        return f"|{symbol}={self.value:.2f}⟩"
+# 物理常数
+HBAR = 1.0  # 约化普朗克常数（自然单位）
 
-class Bra:
-    """左矢 ⟨ψ|"""
-    def __init__(self, state: 'QState'):
-        self.state = state
-    
-    def __or__(self, other: 'Ket') -> complex:
-        """内积 ⟨ψ|φ⟩"""
-        return self.state.inner_product(other.state)
+# GPU 可用性检查
+try:
+    import cupy as cp
+    import cupyx.scipy.fft as cufft
+    GPU_AVAILABLE = True
+except ImportError:
+    GPU_AVAILABLE = False
+    cp = None
+    cufft = None
 
-class Ket:
-    """右矢 |φ⟩"""
-    def __init__(self, state: 'QState'):
-        self.state = state
-    
-    def __matmul__(self, other: 'Bra') -> 'Operator':
-        """外积 |φ⟩⟨ψ|"""
-        return OuterProduct(self, other)
 
-# ========== 复标架场实现 ==========
+# ============================================================
+# 核心复标架代数
+# ============================================================
 
 class QFrame:
     """
-    复标架场 - 连续正交归一基的数学实现
-    
-    数学定义：
-    位置标架场: ℱₓ = {|x⟩: x∈ℝ}, ⟨x|x'⟩ = δ(x-x')
-    动量标架场: ℱₚ = {|p⟩: p∈ℝ}, ⟨p|p'⟩ = δ(p-p')
-    
-    变换关系：⟨x|p⟩ = (1/√(2πħ)) e^{ipx/ħ}
+    量子标架 - 统一傅里叶变换与路径积分的几何框架
+
+    核心属性：
+    - base_coord: 基础坐标系 (coord3 对象)
+    - Q: 复标度因子 Q ∈ ℂ，编码相位与缩放
+
+    关键变换：
+    - QFrame * e^{iθ} = 傅里叶变换 (θ=π/2 为标准变换)
+    - QFrame * λ = 共形变换 (λ∈ℝ⁺)
+    - QFrame * QFrame = 标架复合 (对应路径积分中的复合)
     """
-    
-    def __init__(self, basis_type: str, hbar: float = HBAR):
-        self.basis_type = basis_type
-        self.hbar = hbar
-        self._symbol = 'x' if basis_type == 'position' else 'p'
-        
-    def ket(self, value: float) -> Ket:
-        """生成标架基矢 |x⟩ 或 |p⟩"""
-        return Ket(QState([(value, 1.0)], self.basis_type))
-    
-    def bra(self, value: float) -> Bra:
-        """生成对偶标架 ⟨x| 或 ⟨p|"""
-        return Bra(QState([(value, 1.0)], self.basis_type))
-    
-    def delta_function(self, x1: float, x2: float, epsilon: float = 1e-3) -> float:
+
+    def __init__(self, base_coord=None, q_factor=1.0+0j):
+        """
+        初始化量子标架
+
+        Args:
+            base_coord: 基础坐标系 (coord3 对象)，None 时使用单位标架
+            q_factor: 复标度因子 Q ∈ ℂ
+        """
+        if base_coord is None:
+            if coord3 is not None:
+                self.base = coord3.identity()
+            else:
+                self.base = None
+        else:
+            self.base = base_coord
+
+        self.Q = complex(q_factor)  # 确保是复数
+        self.dim = 3
+
+    # -------------------- 复标架属性 --------------------
+
+    @property
+    def o(self):
+        """复位置向量"""
+        if self.base is None:
+            return None
+        o_base = self.base.o
+        # 复扩展：实部为原位置，虚部编码相位信息
+        return vec3(
+            o_base.x * self.Q.real + 1j * o_base.x * self.Q.imag,
+            o_base.y * self.Q.real + 1j * o_base.y * self.Q.imag,
+            o_base.z * self.Q.real + 1j * o_base.z * self.Q.imag
+        ) if vec3 else None
+
+    @property
+    def s(self):
+        """复缩放向量: s_Q = s_base · Q"""
+        if self.base is None:
+            return None
+        s_base = self.base.s
+        return vec3(
+            s_base.x * self.Q.real + 1j * s_base.x * self.Q.imag,
+            s_base.y * self.Q.real + 1j * s_base.y * self.Q.imag,
+            s_base.z * self.Q.real + 1j * s_base.z * self.Q.imag
+        ) if vec3 else None
+
+    @property
+    def phase(self):
+        """相位 arg(Q)"""
+        return np.angle(self.Q)
+
+    @property
+    def magnitude(self):
+        """模 |Q|"""
+        return np.abs(self.Q)
+
+    @property
+    def det(self):
         """
-        狄拉克δ函数的离散近似
-        δ(x1-x2) ≈ (1/√(2πϵ)) exp(-(x1-x2)²/(2ϵ))
+        行列式: Det(QFrame)
+
+        用于路径积分测度 ∫ Dφ · Det[QFrame] · exp(iS/ħ)
         """
-        return np.exp(-(x1 - x2)**2 / (2 * epsilon)) / np.sqrt(2 * np.pi * epsilon)
-    
-    def fourier_kernel(self, x: float, p: float) -> complex:
-        """傅立叶核 ⟨x|p⟩ = (1/√(2πħ)) e^{ipx/ħ}"""
-        return np.exp(1j * p * x / self.hbar) / np.sqrt(2 * np.pi * self.hbar)
-    
-    def completeness_relation(self, grid: np.ndarray) -> np.ndarray:
+        if self.base is None:
+            return self.Q ** 3  # 3维标架
+        s = self.base.s
+        det_s = s.x * s.y * s.z
+        return det_s * (self.Q ** 3)
+
+    # -------------------- 标架运算 --------------------
+
+    def __mul__(self, other):
         """
-        完备性关系的离散实现：∫|x⟩⟨x|dx ≈ I
-        
-        返回投影算符在离散基下的矩阵表示
+        标架乘法 - 核心变换操作
+
+        支持：
+        - QFrame * complex: 相位旋转/缩放 (傅里叶变换)
+        - QFrame * QFrame: 标架复合 (路径积分复合)
+        - QFrame * vec3: 向量变换
         """
-        n = len(grid)
-        identity = np.eye(n, dtype=complex)
-        
-        # 对于连续基，离散化需要权重
-        dx = grid[1] - grid[0] if len(grid) > 1 else 1.0
-        return identity * dx  # 近似
-        
+        if isinstance(other, (int, float, complex)):
+            # 标量乘法实现傅里叶变换
+            new_Q = self.Q * other
+            return QFrame(self.base, new_Q)
+
+        elif isinstance(other, QFrame):
+            # 标架复合
+            if self.base is not None and other.base is not None:
+                new_base = self.base * other.base
+            else:
+                new_base = self.base or other.base
+            new_Q = self.Q * other.Q
+            return QFrame(new_base, new_Q)
+
+        elif vec3 is not None and isinstance(other, vec3):
+            # 向量变换
+            return vec3(
+                other.x * self.Q.real,
+                other.y * self.Q.real,
+                other.z * self.Q.real
+            )
+
+        return NotImplemented
+
+    def __rmul__(self, other):
+        """右乘法"""
+        return self.__mul__(other)
+
+    def __truediv__(self, other):
+        """标架除法 - 逆变换"""
+        if isinstance(other, (int, float, complex)):
+            return QFrame(self.base, self.Q / other)
+        elif isinstance(other, QFrame):
+            if self.base is not None and other.base is not None:
+                new_base = self.base / other.base
+            else:
+                new_base = self.base
+            return QFrame(new_base, self.Q / other.Q)
+        return NotImplemented
+
+    def __pow__(self, n):
+        """幂运算: 对应多次变换"""
+        if isinstance(n, (int, float, complex)):
+            return QFrame(self.base, self.Q ** n)
+        return NotImplemented
+
+    def __eq__(self, other):
+        """相等比较"""
+        if not isinstance(other, QFrame):
+            return False
+        return np.isclose(self.Q, other.Q)
+
     def __repr__(self):
-        return f"QFrame({self.basis_type}, ħ={self.hbar})"
+        if self.base is not None:
+            return f"QFrame(Q={self.Q:.4f}, o={self.base.o})"
+        return f"QFrame(Q={self.Q:.4f})"
+
+    # -------------------- 傅里叶变换 --------------------
+
+    def fourier_transform(self, theta: float = np.pi/2) -> 'QFrame':
+        """
+        傅里叶变换: F_θ[QFrame] = QFrame · e^{iθ}
+
+        Args:
+            theta: 旋转角度，π/2 为标准傅里叶变换
+
+        Returns:
+            变换后的 QFrame
+
+        性质：
+        - F^4 = I (四次变换回到自身)
+        - F^2 = P (宇称变换)
+        """
+        ft_factor = np.exp(1j * theta)
+        return self * ft_factor
+
+    def inverse_fourier_transform(self, theta: float = np.pi/2) -> 'QFrame':
+        """逆傅里叶变换: F^{-1} = F_{-θ}"""
+        return self.fourier_transform(-theta)
+
+    def conformal_transform(self, lambda_factor: float) -> 'QFrame':
+        """
+        共形变换: C → C · λ, λ ∈ ℝ⁺
+
+        实现缩放变换，保持角度不变
+        """
+        return self * lambda_factor
+
+    # -------------------- 谱变换 (整合自 fourier_spectral) --------------------
+
+    @staticmethod
+    def spectral_transform_2d(field: np.ndarray, hbar: float = HBAR) -> np.ndarray:
+        """
+        二维谱变换：位置空间 → 动量空间
+
+        数学形式：
+        ψ̃(k) = ∫ e^{ikx/ħ} ψ(x) dx / √(2πħ)
+
+        Args:
+            field: 输入场，形状 [ny, nx, ...] 或 [ny, nx]
+            hbar: 约化普朗克常数
+
+        Returns:
+            动量空间谱
+        """
+        # 确定 FFT 的轴
+        if field.ndim >= 2:
+            axes = (0, 1)
+        else:
+            axes = None
+
+        spectrum = np.fft.fft2(field, axes=axes)
+
+        # 量子力学归一化
+        normalization = 1.0 / np.sqrt(2 * np.pi * hbar)
+        return spectrum * normalization
+
+    @staticmethod
+    def inverse_spectral_transform_2d(spectrum: np.ndarray, hbar: float = HBAR) -> np.ndarray:
+        """
+        二维逆谱变换：动量空间 → 位置空间
+
+        Args:
+            spectrum: 动量空间谱
+            hbar: 约化普朗克常数
+
+        Returns:
+            位置空间场
+        """
+        if spectrum.ndim >= 2:
+            axes = (0, 1)
+        else:
+            axes = None
+
+        denormalization = np.sqrt(2 * np.pi * hbar)
+        return np.fft.ifft2(spectrum * denormalization, axes=axes).real
+
+    @staticmethod
+    def spectral_transform_2d_gpu(field: np.ndarray, hbar: float = HBAR) -> np.ndarray:
+        """GPU 加速的二维谱变换"""
+        if not GPU_AVAILABLE:
+            raise RuntimeError("CuPy 不可用，无法使用 GPU 加速")
+
+        field_gpu = cp.asarray(field)
+        spectrum_gpu = cufft.fft2(field_gpu, axes=(0, 1))
+        normalization = 1.0 / np.sqrt(2 * np.pi * hbar)
+        spectrum_gpu *= normalization
+        return cp.asnumpy(spectrum_gpu)
+
+    @classmethod
+    def from_coord_field(cls, coord_field: List[List], hbar: float = HBAR) -> 'QFrameSpectrum':
+        """
+        从坐标场创建谱表示
+
+        将坐标场的各分量进行谱变换
+
+        Args:
+            coord_field: 二维坐标场列表 [[coord3, ...], ...]
+            hbar: 约化普朗克常数
 
-# ========== 量子态实现 ==========
+        Returns:
+            QFrameSpectrum 对象
+        """
+        ny = len(coord_field)
+        nx = len(coord_field[0]) if ny > 0 else 0
+
+        # 提取场分量
+        tensor_field = np.zeros((ny, nx, 12), dtype=np.float64)
+        for i in range(ny):
+            for j in range(nx):
+                coord = coord_field[i][j]
+                tensor_field[i, j, 0:3] = [coord.o.x, coord.o.y, coord.o.z]
+                tensor_field[i, j, 3:6] = [coord.ux.x, coord.ux.y, coord.ux.z]
+                tensor_field[i, j, 6:9] = [coord.uy.x, coord.uy.y, coord.uy.z]
+                tensor_field[i, j, 9:12] = [coord.uz.x, coord.uz.y, coord.uz.z]
+
+        # 谱变换各分量
+        origin_spectrum = cls.spectral_transform_2d(tensor_field[..., 0:3], hbar)
+        ux_spectrum = cls.spectral_transform_2d(tensor_field[..., 3:6], hbar)
+        uy_spectrum = cls.spectral_transform_2d(tensor_field[..., 6:9], hbar)
+        uz_spectrum = cls.spectral_transform_2d(tensor_field[..., 9:12], hbar)
+
+        # 动量网格
+        kx = 2 * np.pi * np.fft.fftfreq(nx) / hbar
+        ky = 2 * np.pi * np.fft.fftfreq(ny) / hbar
+
+        return QFrameSpectrum(
+            ux_spectrum=ux_spectrum,
+            uy_spectrum=uy_spectrum,
+            uz_spectrum=uz_spectrum,
+            origin_spectrum=origin_spectrum,
+            momentum_grid=(kx, ky),
+            hbar=hbar
+        )
+
+    # -------------------- 路径积分 --------------------
+
+    def path_integral_measure(self, field_values: List) -> complex:
+        """
+        路径积分测度: Det[QFrame] · exp(iS/ħ)
+
+        Args:
+            field_values: 场构型列表
+
+        Returns:
+            积分权重
+        """
+        det_frame = self.det
+        action = self._compute_action(field_values)
+        return det_frame * np.exp(1j * action)
+
+    def _compute_action(self, field_values: List) -> float:
+        """计算作用量 S[φ, QFrame]"""
+        if not field_values:
+            return 0.0
+
+        # 简化的标量场作用量
+        kinetic = 0.0
+        mass_term = 0.0
 
-class QState:
+        for i, phi in enumerate(field_values):
+            if i < len(field_values) - 1:
+                phi_next = field_values[i + 1]
+                grad = (phi_next - phi) * self.Q
+                kinetic += np.abs(grad) ** 2
+            mass_term += np.abs(phi) ** 2
+
+        return 0.5 * (kinetic + mass_term)
+
+    # -------------------- 狄拉克符号导出 --------------------
+
+    def to_dirac_notation(self, basis: str = 'position') -> str:
+        """
+        转换为狄拉克符号表示（导出用）
+
+        Args:
+            basis: 'position' | 'momentum'
+
+        Returns:
+            狄拉克符号字符串
+        """
+        symbol = 'x' if basis == 'position' else 'p'
+        return f"⟨{symbol}|Q⟩ = {self.Q:.4f}|{symbol}⟩"
+
+
+# ============================================================
+# 量子态表示
+# ============================================================
+
+class QuantumState:
     """
-    量子态 |ψ⟩ = ∫ ψ(ξ) |ξ⟩ dξ
-    
-    其中 ξ 是 x 或 p，ψ(ξ) 是概率幅
+    量子态在 QFrame 下的表示
+
+    |ψ⟩ = amplitude · |basis⟩ ⊗ QFrame
     """
-    
-    def __init__(self, 
-                 components: List[Tuple[float, complex]],  # [(ξ_i, amplitude_i)]
-                 basis: str = 'position',
-                 hbar: float = HBAR):
-        self.components = components  # 离散表示
+
+    def __init__(self, amplitude: complex = 1.0+0j,
+                 frame: QFrame = None,
+                 basis: str = 'position'):
+        self.amplitude = complex(amplitude)
+        self.frame = frame or QFrame()
         self.basis = basis
-        self.hbar = hbar
-        self._normalize()
-        
-    def _normalize(self):
-        """归一化：∫ |ψ(ξ)|² dξ = 1"""
-        total = sum(abs(amp)**2 for _, amp in self.components)
-        if total > 0:
-            norm = 1.0 / np.sqrt(total)
-            self.components = [(xi, amp * norm) for xi, amp in self.components]
-    
-    def wavefunction(self, grid: np.ndarray) -> np.ndarray:
-        """在网格上计算波函数 ψ(ξ)"""
-        psi = np.zeros(len(grid), dtype=complex)
-        for xi, amp in self.components:
-            # 用高斯函数近似δ函数
-            psi += amp * np.exp(-(grid - xi)**2 / (2 * 0.1))
-        return psi / np.sqrt(np.sum(np.abs(psi)**2))
-    
-    def inner_product(self, other: 'QState') -> complex:
-        """内积 ⟨ψ|φ⟩ = ∫ ψ*(ξ)φ(ξ) dξ"""
-        if self.basis != other.basis:
-            raise ValueError("States must be in same basis for inner product")
-        
-        # 离散近似
-        total = 0j
-        for xi, amp_self in self.components:
-            for xj, amp_other in other.components:
-                # 近似δ函数内积
-                if abs(xi - xj) < 1e-6:
-                    total += np.conj(amp_self) * amp_other
-        return total
-    
-    def transform_to(self, target_basis: str, grid: np.ndarray) -> 'QState':
-        """傅立叶变换到另一标架"""
-        if self.basis == target_basis:
-            return self
-        
-        frame = QFrame(self.basis, self.hbar)
-        target_frame = QFrame(target_basis, self.hbar)
-        
-        # 离散傅立叶变换
-        amplitudes = []
-        for x in grid:
-            total_amp = 0j
-            for xi, amp in self.components:
-                if self.basis == 'position' and target_basis == 'momentum':
-                    kernel = target_frame.fourier_kernel(xi, x)  # ⟨p|x⟩
-                else:
-                    kernel = np.conj(target_frame.fourier_kernel(x, xi))  # ⟨x|p⟩*
-                total_amp += np.conj(kernel) * amp
-            amplitudes.append((x, total_amp))
-        
-        return QState(amplitudes, target_basis, self.hbar)
-    
-    def __repr__(self):
-        main_comps = []
-        for xi, amp in self.components[:3]:  # 只显示前3个主要分量
-            if abs(amp) > 0.05:
-                symbol = 'x' if self.basis == 'position' else 'p'
-                main_comps.append(f"{amp:.2f}|{symbol}={xi:.1f}⟩")
-        
-        if len(self.components) > 3:
-            return " + ".join(main_comps) + " + ..."
-        return " + ".join(main_comps) if main_comps else "|0⟩"
-
-# ========== 量子算符代数 ==========
-
-class QOperator:
-    """
-    量子算符代数：实现非对易结构
-    
-    核心：[x̂, p̂] = iħ
-    """
-    
-    def __init__(self, name: str, matrix_rep: np.ndarray = None):
-        self.name = name
-        self.matrix = matrix_rep
-        
-    @classmethod
-    def position_operator(cls, grid: np.ndarray, hbar: float = HBAR) -> 'QOperator':
-        """位置算符 x̂ 在离散基下的矩阵表示"""
-        n = len(grid)
-        X = np.diag(grid)
-        return cls("x̂", X)
-    
-    @classmethod
-    def momentum_operator(cls, grid: np.ndarray, hbar: float = HBAR) -> 'QOperator':
-        """动量算符 p̂ = -iħ ∂/∂x 在离散基下的矩阵表示"""
-        n = len(grid)
-        dx = grid[1] - grid[0]
-        
-        # 使用中心差分近似导数
-        P = np.zeros((n, n), dtype=complex)
-        for i in range(1, n-1):
-            P[i, i+1] = -1j * hbar / (2 * dx)
-            P[i, i-1] = 1j * hbar / (2 * dx)
-        
-        # 边界条件
-        P[0, 1] = -1j * hbar / dx
-        P[n-1, n-2] = 1j * hbar / dx
-        
-        return cls("p̂", P)
-    
-    def __add__(self, other: 'QOperator') -> 'QOperator':
-        """算符加法"""
-        if self.matrix.shape != other.matrix.shape:
-            raise ValueError("Operators must have same dimension")
-        return QOperator(f"({self.name}+{other.name})", self.matrix + other.matrix)
-    
-    def __sub__(self, other: 'QOperator') -> 'QOperator':
-        """算符减法"""
-        if self.matrix.shape != other.matrix.shape:
-            raise ValueError("Operators must have same dimension")
-        return QOperator(f"({self.name}-{other.name})", self.matrix - other.matrix)
-    
-    def __mul__(self, other: Union['QOperator', complex, float]) -> 'QOperator':
-        """算符乘法或数乘"""
-        if isinstance(other, (int, float, complex)):
-            return QOperator(f"{other}*{self.name}", other * self.matrix)
-        elif isinstance(other, QOperator):
-            return QOperator(f"{self.name}{other.name}", self.matrix @ other.matrix)
-        raise TypeError(f"Unsupported type: {type(other)}")
-    
-    def __rmul__(self, other: Union[complex, float]) -> 'QOperator':
-        """右数乘"""
+
+    def __mul__(self, other):
+        """量子态变换: |ψ⟩ → QFrame · |ψ⟩"""
+        if isinstance(other, QFrame):
+            new_amplitude = self.amplitude * other.Q
+            new_frame = self.frame * other
+            return QuantumState(new_amplitude, new_frame, self.basis)
+        return NotImplemented
+
+    def __rmul__(self, other):
         return self.__mul__(other)
-    
-    def commutator(self, other: 'QOperator') -> 'QOperator':
-        """对易子 [A,B] = AB - BA"""
-        comm = self.matrix @ other.matrix - other.matrix @ self.matrix
-        return QOperator(f"[{self.name},{other.name}]", comm)
-    
-    def trace(self) -> complex:
-        """迹 tr(A)"""
-        return np.trace(self.matrix)
-    
-    def act_on_state(self, state: QState, grid: np.ndarray) -> QState:
-        """算符作用于态：A|ψ⟩"""
-        # 将态投影到离散基
-        psi = state.wavefunction(grid)
-        psi_new = self.matrix @ psi
-        
-        # 转换回QState表示
-        amplitudes = [(grid[i], psi_new[i]) for i in range(len(grid))]
-        return QState(amplitudes, state.basis, state.hbar)
-    
+
+    def fourier_transform(self) -> 'QuantumState':
+        """傅里叶变换量子态"""
+        ft_frame = QFrame(q_factor=1j)  # 乘以 i
+        new_basis = 'momentum' if self.basis == 'position' else 'position'
+        result = self * ft_frame
+        result.basis = new_basis
+        return result
+
+    def expectation_value(self) -> float:
+        """期望值: ⟨ψ|Q|ψ⟩"""
+        return (np.conj(self.amplitude) * self.amplitude * self.frame.det).real
+
+    def norm(self) -> float:
+        """范数: ||ψ||"""
+        return np.abs(self.amplitude)
+
+    def normalize(self) -> 'QuantumState':
+        """归一化"""
+        n = self.norm()
+        if n > 0:
+            return QuantumState(self.amplitude / n, self.frame, self.basis)
+        return self
+
     def __repr__(self):
-        return f"QOperator({self.name}, shape={self.matrix.shape})"
+        basis_symbol = 'x' if self.basis == 'position' else 'p'
+        return f"{self.amplitude:.4f}|{basis_symbol}⟩ ⊗ {self.frame}"
+
 
-# ========== 外尔关系与量子二项式 ==========
+# ============================================================
+# 路径积分
+# ============================================================
 
-class WeylRelation:
+class PathIntegral:
     """
-    外尔关系：T(a)U(b) = e^{-iab/ħ} U(b)T(a)
-    
-    其中：
-    T(a) = exp(-iap̂/ħ)  - 动量平移
-    U(b) = exp(-ibx̂/ħ)  - 位置平移
+    路径积分计算器
+
+    Z = ∫ Dφ · Det[QFrame] · exp(iS/ħ)
     """
-    
-    def __init__(self, hbar: float = HBAR):
+
+    def __init__(self, frame: QFrame = None, hbar: float = HBAR):
+        self.frame = frame or QFrame()
         self.hbar = hbar
-    
-    def translation_operators(self, grid: np.ndarray, a: float, b: float):
-        """生成平移算符 T(a) 和 U(b)"""
-        X = QOperator.position_operator(grid, self.hbar).matrix
-        P = QOperator.momentum_operator(grid, self.hbar).matrix
-        
-        # T(a) = exp(-i*a*P/ħ)
-        T_a = linalg.expm(-1j * a * P / self.hbar)
-        
-        # U(b) = exp(-i*b*X/ħ)
-        U_b = linalg.expm(-1j * b * X / self.hbar)
-        
-        return T_a, U_b
-    
-    def verify(self, grid: np.ndarray, a: float = 1.0, b: float = 1.0, tol: float = 1e-6):
-        """验证外尔关系"""
-        T_a, U_b = self.translation_operators(grid, a, b)
-        
-        # 计算 T(a)U(b)
-        TU = T_a @ U_b
-        
-        # 计算 e^{-iab/ħ} U(b)T(a)
-        phase = np.exp(-1j * a * b / self.hbar)
-        UT = phase * (U_b @ T_a)
-        
-        # 比较
-        diff = np.max(np.abs(TU - UT))
-        is_valid = diff < tol
-        
-        return {
-            'valid': is_valid,
-            'max_difference': diff,
-            'expected_phase': phase,
-            'actual_phase': np.trace(TU @ linalg.inv(UT)) / len(grid) if len(grid) > 0 else 0
-        }
-    
-    def quantum_binomial_coefficient(self, n: int, k: int, q: complex) -> complex:
+        self.field_configs = []
+
+    def add_configuration(self, field_value):
+        """添加场构型"""
+        self.field_configs.append(field_value)
+
+    def add_configurations(self, field_values: List):
+        """批量添加场构型"""
+        self.field_configs.extend(field_values)
+
+    def clear(self):
+        """清除所有构型"""
+        self.field_configs.clear()
+
+    def compute(self) -> complex:
         """
-        量子二项式系数 (n choose k)_q
-        
-        用于展开 (A+B)^n，其中 BA = q AB
+        计算路径积分
+
+        Returns:
+            配分函数 Z
         """
-        def q_number(m: int, q: complex) -> complex:
-            """q-数 [m]_q = (1-q^m)/(1-q)"""
-            if abs(q - 1) < 1e-10:
-                return m
-            return (1 - q**m) / (1 - q)
-        
-        def q_factorial(m: int, q: complex) -> complex:
-            """q-阶乘 [m]_q! = [1]_q [2]_q ... [m]_q"""
-            result = 1 + 0j
-            for i in range(1, m+1):
-                result *= q_number(i, q)
-            return result
-        
-        if k < 0 or k > n:
-            return 0
-        
-        num = q_factorial(n, q)
-        den = q_factorial(k, q) * q_factorial(n - k, q)
-        
-        return num / den
-
-# ========== 量子联络与曲率 ==========
-
-class QConnection:
-    """
-    量子联络：描述标架场的平行输运
-    
-    定义：A_μ = ∂_μ|ℂ⟩⟨ℂ|  - 标架场的梯度
-    """
-    
-    def __init__(self, frame_field: QFrame):
-        self.frame = frame_field
-        
-    def connection_form(self, grid: np.ndarray, mu: str) -> QOperator:
+        if not self.field_configs:
+            return 0.0 + 0j
+
+        total = 0.0 + 0j
+        for phi in self.field_configs:
+            weight = self.frame.path_integral_measure([phi])
+            total += weight
+
+        return total / len(self.field_configs)
+
+    def classical_limit(self) -> Tuple[Any, float]:
         """
-        联络1-形式 A_μ
-        
-        μ ∈ {'x', 'p'} 表示沿哪个方向变化
+        经典极限: δS/δφ = 0 的解
+
+        Returns:
+            (最优构型, 最小作用量)
         """
-        n = len(grid)
-        dx = grid[1] - grid[0]
-        
-        if mu == 'x':
-            # 沿位置方向的联络
-            A = np.zeros((n, n), dtype=complex)
-            for i in range(n):
-                for j in range(n):
-                    if i == j:
-                        # 对角元为零（规范选择）
-                        A[i, j] = 0
-                    elif abs(i - j) == 1:
-                        # 最近邻耦合
-                        A[i, j] = -1j * (grid[j] - grid[i]) / (2 * dx * self.frame.hbar)
-        else:  # mu == 'p'
-            # 沿动量方向的联络
-            A = np.zeros((n, n), dtype=complex)
-            # 在动量空间中，联络与位置算符有关
-            for i in range(n):
-                for j in range(n):
-                    if abs(i - j) == 1:
-                        A[i, j] = 1j * dx * grid[i] / (2 * self.frame.hbar)
-        
-        return QOperator(f"A_{mu}", A)
-    
-    def curvature(self, grid: np.ndarray) -> QOperator:
+        best_config = None
+        min_action = float('inf')
+
+        for phi in self.field_configs:
+            action = self.frame._compute_action([phi])
+            if action < min_action:
+                min_action = action
+                best_config = phi
+
+        return best_config, min_action
+
+    def __repr__(self):
+        return f"PathIntegral(n_configs={len(self.field_configs)}, frame={self.frame})"
+
+
+# ============================================================
+# 谱数据结构
+# ============================================================
+
+@dataclass
+class QFrameSpectrum:
+    """
+    QFrame 谱表示 - 坐标场在动量空间的表示
+
+    存储坐标场各分量的傅里叶谱
+    """
+    ux_spectrum: np.ndarray       # x轴基矢量谱
+    uy_spectrum: np.ndarray       # y轴基矢量谱
+    uz_spectrum: np.ndarray       # z轴基矢量谱
+    origin_spectrum: np.ndarray   # 原点位置谱
+    momentum_grid: Tuple[np.ndarray, np.ndarray]  # (kx, ky)
+    hbar: float = HBAR
+
+    def __post_init__(self):
+        """验证维度一致性"""
+        shapes = [
+            self.ux_spectrum.shape,
+            self.uy_spectrum.shape,
+            self.uz_spectrum.shape,
+            self.origin_spectrum.shape
+        ]
+        if not all(s == shapes[0] for s in shapes):
+            raise ValueError("所有谱分量必须具有相同维度")
+
+    @property
+    def shape(self) -> Tuple[int, int]:
+        """谱的空间形状"""
+        return self.ux_spectrum.shape[:2]
+
+    def total_energy(self) -> float:
+        """总能量 E = ∫ |ψ̃(k)|² dk"""
+        return float(
+            np.sum(np.abs(self.ux_spectrum)**2) +
+            np.sum(np.abs(self.uy_spectrum)**2) +
+            np.sum(np.abs(self.uz_spectrum)**2) +
+            np.sum(np.abs(self.origin_spectrum)**2)
+        )
+
+    def spectral_density(self) -> np.ndarray:
+        """谱密度 ρ(k) = Σ_μ |ψ̃_μ(k)|²"""
+        density = (
+            np.abs(self.ux_spectrum)**2 +
+            np.abs(self.uy_spectrum)**2 +
+            np.abs(self.uz_spectrum)**2 +
+            np.abs(self.origin_spectrum)**2
+        )
+        return np.mean(density, axis=-1) if density.ndim > 2 else density
+
+    def radial_average(self) -> Tuple[np.ndarray, np.ndarray]:
         """
-        量子曲率 R = [A_x, A_p] - 非对易性的几何度量
+        径向平均谱 (ShapeDNA)
+
+        Returns:
+            (k_bins, radial_spectrum)
         """
-        A_x = self.connection_form(grid, 'x')
-        A_p = self.connection_form(grid, 'p')
-        
-        # 曲率 = 联络的对易子
-        R = A_x.commutator(A_p)
-        R.name = "R"
-        
-        return R
-    
-    def berry_phase(self, grid: np.ndarray, path: np.ndarray) -> complex:
+        kx, ky = self.momentum_grid
+        k_mag = np.sqrt(kx[:, None]**2 + ky[None, :]**2)
+
+        density = self.spectral_density()
+
+        k_max = np.max(k_mag)
+        k_bins = np.linspace(0, k_max, 50)
+        radial_avg = np.zeros(len(k_bins))
+
+        for i in range(len(k_bins) - 1):
+            mask = (k_mag >= k_bins[i]) & (k_mag < k_bins[i + 1])
+            if np.any(mask):
+                radial_avg[i] = np.mean(density[mask])
+
+        return k_bins, radial_avg
+
+    def to_coord_field(self) -> List[List]:
         """
-        Berry相位：γ = ∮ A_μ dx^μ
-        
-        path: 路径上的点序列 [(x1, p1), (x2, p2), ...]
+        逆变换：谱 → 坐标场
+
+        Returns:
+            二维坐标场列表
         """
-        gamma = 0j
-        n_points = len(path)
-        
-        for i in range(n_points):
-            x, p = path[i]
-            x_next, p_next = path[(i+1) % n_points]
-            
-            # 离散近似
-            dx = x_next - x
-            dp = p_next - p
-            
-            # 计算联络在这段路径上的贡献
-            A_x = self.connection_form(np.array([x, x_next]), 'x')
-            A_p = self.connection_form(np.array([p, p_next]), 'p')
-            
-            # 近似积分
-            gamma += np.trace(A_x.matrix)[0] * dx + np.trace(A_p.matrix)[0] * dp
-        
-        return gamma
-
-# ========== 高斯波包与不确定关系 ==========
-
-def coherent_state(center_x: float = 0.0, center_p: float = 0.0, 
-                  sigma: float = 1.0, grid: np.ndarray = None,
-                  hbar: float = HBAR) -> QState:
+        ny, nx = self.shape
+
+        origin_field = QFrame.inverse_spectral_transform_2d(self.origin_spectrum, self.hbar)
+        ux_field = QFrame.inverse_spectral_transform_2d(self.ux_spectrum, self.hbar)
+        uy_field = QFrame.inverse_spectral_transform_2d(self.uy_spectrum, self.hbar)
+        uz_field = QFrame.inverse_spectral_transform_2d(self.uz_spectrum, self.hbar)
+
+        coord_field = []
+        for i in range(ny):
+            row = []
+            for j in range(nx):
+                o = vec3(origin_field[i, j, 0], origin_field[i, j, 1], origin_field[i, j, 2])
+                ux = vec3(ux_field[i, j, 0], ux_field[i, j, 1], ux_field[i, j, 2])
+                uy = vec3(uy_field[i, j, 0], uy_field[i, j, 1], uy_field[i, j, 2])
+                uz = vec3(uz_field[i, j, 0], uz_field[i, j, 1], uz_field[i, j, 2])
+
+                c = coord3(o, quat(1, 0, 0, 0), vec3(1, 1, 1))
+                c.ux, c.uy, c.uz = ux, uy, uz
+                row.append(c)
+            coord_field.append(row)
+
+        return coord_field
+
+
+# ============================================================
+# 狄拉克符号（可选导出）
+# ============================================================
+
+class DiracBra:
+    """左矢 ⟨ψ| - 狄拉克符号导出"""
+
+    def __init__(self, state: QuantumState):
+        self.state = state
+
+    def __or__(self, other: 'DiracKet') -> complex:
+        """内积 ⟨ψ|φ⟩"""
+        return np.conj(self.state.amplitude) * other.state.amplitude
+
+
+class DiracKet:
+    """右矢 |φ⟩ - 狄拉克符号导出"""
+
+    def __init__(self, state: QuantumState):
+        self.state = state
+
+
+def bra(state: QuantumState) -> DiracBra:
+    """创建左矢"""
+    return DiracBra(state)
+
+
+def ket(state: QuantumState) -> DiracKet:
+    """创建右矢"""
+    return DiracKet(state)
+
+
+# ============================================================
+# 便利函数
+# ============================================================
+
+def spectral_transform(coord_field: List[List],
+                       hbar: float = HBAR,
+                       use_gpu: bool = False) -> QFrameSpectrum:
     """
-    相干态（最小不确定态） - 高斯波包
-    
-    ψ(x) = (1/(πσ²))^{1/4} exp(-(x-x₀)²/(2σ²)) exp(i p₀ x/ħ)
+    坐标场谱变换
+
+    Args:
+        coord_field: 二维坐标场
+        hbar: 约化普朗克常数
+        use_gpu: 是否使用 GPU 加速
+
+    Returns:
+        QFrameSpectrum 对象
     """
-    if grid is None:
-        grid = np.linspace(-5, 5, 100)
-    
-    # 高斯波函数
-    normalization = (1.0 / (np.pi * sigma**2))**0.25
-    psi = normalization * np.exp(-(grid - center_x)**2 / (2 * sigma**2))
-    psi *= np.exp(1j * center_p * grid / hbar)
-    
-    # 归一化
-    norm = np.sqrt(np.sum(np.abs(psi)**2) * (grid[1] - grid[0]))
-    psi /= norm
-    
-    # 转换为QState
-    amplitudes = [(grid[i], psi[i]) for i in range(len(grid))]
-    return QState(amplitudes, 'position', hbar)
-
-def uncertainty_product(state: QState, grid: np.ndarray) -> dict:
+    return QFrame.from_coord_field(coord_field, hbar)
+
+
+def inverse_spectral_transform(spectrum: QFrameSpectrum) -> List[List]:
     """
-    计算不确定关系：Δx Δp ≥ ħ/2
+    逆谱变换
+
+    Args:
+        spectrum: QFrameSpectrum 对象
+
+    Returns:
+        重建的坐标场
     """
-    # 位置空间的期望值和方差
-    psi_x = state.wavefunction(grid)
-    dx = grid[1] - grid[0]
-    
-    # ⟨x⟩
-    x_exp = np.sum(grid * np.abs(psi_x)**2) * dx
-    
-    # ⟨x²⟩
-    x2_exp = np.sum(grid**2 * np.abs(psi_x)**2) * dx
-    
-    # Δx² = ⟨x²⟩ - ⟨x⟩²
-    delta_x2 = x2_exp - x_exp**2
-    delta_x = np.sqrt(delta_x2)
-    
-    # 变换到动量空间
-    psi_p = np.fft.fftshift(np.fft.fft(psi_x))
-    p_grid = np.fft.fftshift(np.fft.fftfreq(len(grid), d=dx)) * (2 * np.pi * state.hbar)
-    dp = p_grid[1] - p_grid[0]
-    
-    # ⟨p⟩
-    p_exp = np.sum(p_grid * np.abs(psi_p)**2) * dp
-    
-    # ⟨p²⟩
-    p2_exp = np.sum(p_grid**2 * np.abs(psi_p)**2) * dp
-    
-    # Δp² = ⟨p²⟩ - ⟨p⟩²
-    delta_p2 = p2_exp - p_exp**2
-    delta_p = np.sqrt(delta_p2)
-    
-    # 不确定积
-    product = delta_x * delta_p
-    uncertainty_limit = state.hbar / 2
-    
-    return {
-        'delta_x': delta_x,
-        'delta_p': delta_p,
-        'product': product,
-        'uncertainty_limit': uncertainty_limit,
-        'saturated': abs(product - uncertainty_limit) < 1e-6,
-        'expectation_x': x_exp,
-        'expectation_p': p_exp
-    }
-
-# ========== 演示与测试 ==========
-
-def demonstrate_frame_field():
-    """演示复标架场的基本功能"""
-    print("="*60)
-    print("量子复标架代数演示")
-    print("="*60)
-    
-    # 1. 创建复标架场
-    position_frame = QFrame('position')
-    momentum_frame = QFrame('momentum')
-    
-    print("1. 复标架场创建:")
-    print(f"   位置标架场: {position_frame}")
-    print(f"   动量标架场: {momentum_frame}")
-    print()
-    
-    # 2. 验证傅立叶核
-    print("2. 傅立叶核验证:")
-    x, p = 1.0, 2.0
-    kernel = position_frame.fourier_kernel(x, p)
-    print(f"   ⟨x={x}|p={p}⟩ = {kernel:.4f}")
-    print(f"   模长: {abs(kernel):.4f}")
-    print()
-    
-    # 3. 创建相干态
-    print("3. 相干态（最小不确定态）:")
-    grid = np.linspace(-3, 3, 50)
-    coherent = coherent_state(center_x=0.0, center_p=1.0, sigma=0.5, grid=grid)
-    print(f"   态: {coherent}")
-    print()
-    
-    # 4. 计算不确定关系
-    print("4. 海森堡不确定关系:")
-    uncertainties = uncertainty_product(coherent, grid)
-    print(f"   Δx = {uncertainties['delta_x']:.4f}")
-    print(f"   Δp = {uncertainties['delta_p']:.4f}")
-    print(f"   ΔxΔp = {uncertainties['product']:.4f}")
-    print(f"   下限 ħ/2 = {uncertainties['uncertainty_limit']:.4f}")
-    print(f"   是否饱和: {uncertainties['saturated']}")
-    print()
-    
-    # 5. 算符代数
-    print("5. 非对易代数验证:")
-    X = QOperator.position_operator(grid[:10])  # 使用小网格演示
-    P = QOperator.momentum_operator(grid[:10])
-    
-    comm = X.commutator(P)
-    trace_comm = comm.trace()
-    
-    print(f"   [x̂, p̂] 的迹: {trace_comm:.6f}")
-    print(f"   期望值 iħ = {1j * HBAR:.6f}")
-    print(f"   误差: {abs(trace_comm - 1j*HBAR):.6f}")
-    print()
-    
-    # 6. 外尔关系验证
-    print("6. 外尔关系验证:")
-    weyl = WeylRelation()
-    result = weyl.verify(grid[:10], a=0.5, b=0.5)
-    print(f"   关系是否成立: {result['valid']}")
-    print(f"   最大差异: {result['max_difference']:.6f}")
-    print(f"   预期相位: {result['expected_phase']:.4f}")
-    print()
-    
-    # 7. 量子联络与曲率
-    print("7. 量子几何（联络与曲率）:")
-    connection = QConnection(position_frame)
-    R = connection.curvature(grid[:5])
-    print(f"   曲率算符: {R}")
-    print(f"   曲率迹: {R.trace():.6f}")
-    print()
-    
-    # 8. 量子二项式系数演示
-    print("8. 量子二项式系数演示:")
-    q = np.exp(1j * np.pi / 3)  # q = e^{iπ/3}
-    for n in [2, 3, 4]:
-        print(f"   n={n}: ", end="")
-        coeffs = []
-        for k in range(n+1):
-            coeff = weyl.quantum_binomial_coefficient(n, k, q)
-            coeffs.append(f"({k})_q={coeff.real:.3f}")
-        print("[" + ", ".join(coeffs) + "]")
-    
-    print("\n" + "="*60)
-
-def plot_gaussian_transformation():
-    """绘制高斯波包的傅立叶变换"""
-    # 创建高斯波包
-    grid_x = np.linspace(-5, 5, 200)
-    coherent = coherent_state(center_x=0.0, center_p=2.0, sigma=0.8, grid=grid_x)
-    
-    # 傅立叶变换到动量空间
-    psi_x = coherent.wavefunction(grid_x)
-    psi_p = np.fft.fftshift(np.fft.fft(psi_x))
-    p_grid = np.fft.fftshift(np.fft.fftfreq(len(grid_x), d=grid_x[1]-grid_x[0])) * (2*np.pi*HBAR)
-    
-    # 绘制
-    fig, axes = plt.subplots(2, 2, figsize=(12, 8))
-    
-    # 位置空间波函数
-    axes[0, 0].plot(grid_x, np.abs(psi_x)**2, 'b-', linewidth=2, label='|ψ(x)|²')
-    axes[0, 0].plot(grid_x, np.real(psi_x), 'r--', alpha=0.7, label='Re ψ(x)')
-    axes[0, 0].plot(grid_x, np.imag(psi_x), 'g--', alpha=0.7, label='Im ψ(x)')
-    axes[0, 0].set_xlabel('位置 x')
-    axes[0, 0].set_ylabel('波函数')
-    axes[0, 0].set_title('位置空间表示')
-    axes[0, 0].legend()
-    axes[0, 0].grid(True, alpha=0.3)
-    
-    # 动量空间波函数
-    axes[0, 1].plot(p_grid, np.abs(psi_p)**2, 'b-', linewidth=2, label='|ψ(p)|²')
-    axes[0, 1].plot(p_grid, np.real(psi_p), 'r--', alpha=0.7, label='Re ψ(p)')
-    axes[0, 1].plot(p_grid, np.imag(psi_p), 'g--', alpha=0.7, label='Im ψ(p)')
-    axes[0, 1].set_xlabel('动量 p')
-    axes[0, 1].set_ylabel('波函数')
-    axes[0, 1].set_title('动量空间表示')
-    axes[0, 1].legend()
-    axes[0, 1].grid(True, alpha=0.3)
-    
-    # 相空间表示（Wigner函数近似）
-    axes[1, 0].scatter(grid_x, p_grid[:len(grid_x)], 
-                      c=np.outer(np.abs(psi_x), np.abs(psi_p[:len(grid_x)])).flatten(),
-                      cmap='viridis', alpha=0.6)
-    axes[1, 0].set_xlabel('位置 x')
-    axes[1, 0].set_ylabel('动量 p')
-    axes[1, 0].set_title('相空间表示')
-    axes[1, 0].grid(True, alpha=0.3)
-    
-    # 不确定关系示意图
-    uncertainties = uncertainty_product(coherent, grid_x)
-    angles = np.linspace(0, 2*np.pi, 100)
-    x_circle = uncertainties['delta_x'] * np.cos(angles)
-    p_circle = uncertainties['delta_p'] * np.sin(angles)
-    
-    axes[1, 1].plot(x_circle, p_circle, 'b-', label='不确定区域')
-    axes[1, 1].axhline(y=0, color='k', linestyle='-', alpha=0.3)
-    axes[1, 1].axvline(x=0, color='k', linestyle='-', alpha=0.3)
-    axes[1, 1].fill_between(x_circle, p_circle, alpha=0.3)
-    axes[1, 1].set_xlabel('Δx')
-    axes[1, 1].set_ylabel('Δp')
-    axes[1, 1].set_title(f'不确定关系: ΔxΔp = {uncertainties["product"]:.3f} ≥ ħ/2 = {HBAR/2:.3f}')
-    axes[1, 1].legend()
-    axes[1, 1].grid(True, alpha=0.3)
-    axes[1, 1].axis('equal')
-    
-    plt.tight_layout()
-    plt.savefig('quantum_frame_demo.png', dpi=150)
-    plt.show()
-
-# ========== 主程序 ==========
+    return spectrum.to_coord_field()
+
+
+# ============================================================
+# 演示
+# ============================================================
+
+def demonstrate():
+    """演示复标架代数"""
+    print("=" * 60)
+    print("复数量子化标架场 (QFrame) 演示")
+    print("=" * 60)
+
+    # 1. 创建基础 QFrame
+    if coord3 is not None:
+        base_frame = coord3.from_position(vec3(1, 0, 0))
+        qf = QFrame(base_frame, q_factor=1.0+0.5j)
+    else:
+        qf = QFrame(q_factor=1.0+0.5j)
+
+    print(f"\n1. 基础 QFrame: {qf}")
+    print(f"   相位: {qf.phase:.4f} rad")
+    print(f"   模: {qf.magnitude:.4f}")
+    print(f"   行列式: {qf.det:.4f}")
+
+    # 2. 傅里叶变换
+    print(f"\n2. 傅里叶变换:")
+    ft = qf.fourier_transform()
+    print(f"   F[QFrame] = {ft}")
+    print(f"   F^4[QFrame] ≈ QFrame: {qf.fourier_transform(2*np.pi)}")
+
+    # 3. 共形变换
+    print(f"\n3. 共形变换:")
+    conf = qf.conformal_transform(2.0)
+    print(f"   λ=2: {conf}")
+
+    # 4. 标架复合
+    print(f"\n4. 标架复合:")
+    qf2 = QFrame(q_factor=0.5+0.5j)
+    composed = qf * qf2
+    print(f"   QFrame1 * QFrame2 = {composed}")
+
+    # 5. 量子态
+    print(f"\n5. 量子态:")
+    psi = QuantumState(amplitude=1.0+0j, frame=qf)
+    print(f"   初始: {psi}")
+    psi_ft = psi.fourier_transform()
+    print(f"   变换: {psi_ft}")
+    print(f"   期望值: {psi.expectation_value():.4f}")
+
+    # 6. 路径积分
+    print(f"\n6. 路径积分:")
+    pi = PathIntegral(frame=qf)
+    for x in np.linspace(-1, 1, 5):
+        pi.add_configuration(x + 0j)
+
+    Z = pi.compute()
+    print(f"   配分函数 Z = {Z:.4f}")
+
+    config, action = pi.classical_limit()
+    print(f"   经典解: φ_cl = {config:.4f}, S = {action:.4f}")
+
+    # 7. 狄拉克符号导出
+    print(f"\n7. 狄拉克符号导出:")
+    print(f"   {qf.to_dirac_notation('position')}")
+    print(f"   {qf.to_dirac_notation('momentum')}")
+
+    print("\n" + "=" * 60)
+    print("核心特性总结:")
+    print("  • QFrame * e^{iθ} = 傅里叶变换")
+    print("  • QFrame * λ = 共形变换")
+    print("  • QFrame * QFrame = 标架复合")
+    print("  • QFrame.det = 路径积分测度")
+    print("=" * 60)
+
+
+# ============================================================
+# 导出
+# ============================================================
+
+__all__ = [
+    # 核心类
+    'QFrame',
+    'QuantumState',
+    'PathIntegral',
+    'QFrameSpectrum',
+
+    # 狄拉克符号导出
+    'DiracBra',
+    'DiracKet',
+    'bra',
+    'ket',
+
+    # 便利函数
+    'spectral_transform',
+    'inverse_spectral_transform',
+
+    # 常数
+    'HBAR',
+    'GPU_AVAILABLE',
+]
+
 
 if __name__ == "__main__":
-    # 运行演示
-    demonstrate_frame_field()
-    
-    # 可选：绘制图形演示
-    if input("\n绘制图形演示？(y/n): ").lower() == 'y':
-        plot_gaussian_transformation()
-    
-    print("\n量子复标架代数实现完成！")
-    print("核心特性：")
-    print("1. 复标架场: 连续正交归一基的数学实现")
-    print("2. 非对易代数: [x̂, p̂] = iħ 的严格实现")
-    print("3. 外尔关系: T(a)U(b) = e^{-iab/ħ} U(b)T(a)")
-    print("4. 量子联络与曲率: 非对易性的几何描述")
-    print("5. 不确定关系: ΔxΔp ≥ ħ/2 的几何解释")
+    demonstrate()