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

coordinate_system/qframes.py

@@ -0,0 +1,675 @@
+"""
+量子复标架代数 - 基于非对易几何的完整实现
+=======================================
+
+实现了完整的复标架场理论，包括：
+1. 连续谱复标架 (|x⟩, |p⟩) 满足 ⟨x|x'⟩ = δ(x-x')
+2. 非对易代数 [x̂, p̂] = iħ
+3. 量子联络与曲率
+4. 外尔关系与量子二项式展开
+
+核心创新：
+- 连续标架场的离散逼近保持几何结构
+- 算符代数与态矢代数分离
+- 非对易性的几何实现
+- 量子傅立叶变换作为标架旋转
+
+作者: DeepSeek
+日期: 2025-12-02
+"""
+
+import numpy as np
+from typing import List, Tuple, Union, Optional, Callable
+import sympy as sp
+from dataclasses import dataclass
+from scipy import integrate, linalg
+from scipy.special import hermite
+import matplotlib.pyplot as plt
+
+# 物理常数
+HBAR = 1.0  # 简化普朗克常数
+
+# ========== 基础数学结构 ==========
+
+@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}⟩"
+
+class Bra:
+    """左矢 ⟨ψ|"""
+    def __init__(self, state: 'QState'):
+        self.state = state
+    
+    def __or__(self, other: 'Ket') -> complex:
+        """内积 ⟨ψ|φ⟩"""
+        return self.state.inner_product(other.state)
+
+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/ħ}
+    """
+    
+    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:
+        """
+        狄拉克δ函数的离散近似
+        δ(x1-x2) ≈ (1/√(2πϵ)) exp(-(x1-x2)²/(2ϵ))
+        """
+        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:
+        """
+        完备性关系的离散实现：∫|x⟩⟨x|dx ≈ I
+        
+        返回投影算符在离散基下的矩阵表示
+        """
+        n = len(grid)
+        identity = np.eye(n, dtype=complex)
+        
+        # 对于连续基，离散化需要权重
+        dx = grid[1] - grid[0] if len(grid) > 1 else 1.0
+        return identity * dx  # 近似
+        
+    def __repr__(self):
+        return f"QFrame({self.basis_type}, ħ={self.hbar})"
+
+# ========== 量子态实现 ==========
+
+class QState:
+    """
+    量子态 |ψ⟩ = ∫ ψ(ξ) |ξ⟩ dξ
+    
+    其中 ξ 是 x 或 p，ψ(ξ) 是概率幅
+    """
+    
+    def __init__(self, 
+                 components: List[Tuple[float, complex]],  # [(ξ_i, amplitude_i)]
+                 basis: str = 'position',
+                 hbar: float = HBAR):
+        self.components = components  # 离散表示
+        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':
+        """右数乘"""
+        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 __repr__(self):
+        return f"QOperator({self.name}, shape={self.matrix.shape})"
+
+# ========== 外尔关系与量子二项式 ==========
+
+class WeylRelation:
+    """
+    外尔关系：T(a)U(b) = e^{-iab/ħ} U(b)T(a)
+    
+    其中：
+    T(a) = exp(-iap̂/ħ)  - 动量平移
+    U(b) = exp(-ibx̂/ħ)  - 位置平移
+    """
+    
+    def __init__(self, hbar: float = HBAR):
+        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:
+        """
+        量子二项式系数 (n choose k)_q
+        
+        用于展开 (A+B)^n，其中 BA = q AB
+        """
+        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:
+        """
+        联络1-形式 A_μ
+        
+        μ ∈ {'x', 'p'} 表示沿哪个方向变化
+        """
+        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:
+        """
+        量子曲率 R = [A_x, A_p] - 非对易性的几何度量
+        """
+        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:
+        """
+        Berry相位：γ = ∮ A_μ dx^μ
+        
+        path: 路径上的点序列 [(x1, p1), (x2, p2), ...]
+        """
+        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:
+    """
+    相干态（最小不确定态） - 高斯波包
+    
+    ψ(x) = (1/(πσ²))^{1/4} exp(-(x-x₀)²/(2σ²)) exp(i p₀ x/ħ)
+    """
+    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:
+    """
+    计算不确定关系：Δx Δp ≥ ħ/2
+    """
+    # 位置空间的期望值和方差
+    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()
+
+# ========== 主程序 ==========
+
+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 的几何解释")