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

coordinate_system/fourier_spectral.py

@@ -1,18 +1,71 @@
-# coordinate_system/fourier_spectral.py
+"""
+Quantum Frame Spectral Analysis - 量子标架谱分析
+==============================================
+
+基于量子复标架理论的坐标场谱分析系统。
+将傅里叶谱分析升级为量子几何框架。
+
+核心概念转换：
+- 传统傅里叶谱 → 量子标架场谱
+- FFT/IFFT → 标架旋转算符
+- 频域分析 → 动量标架表示
+- 谱密度 → 量子几何能量密度
+- 坐标场变换 → 复标架场旋转
+
+量子几何特性：
+- 非对易代数 [x̂, p̂] = iħ
+- 标架旋转 = 傅里叶变换
+- 量子联络与曲率
+- Berry 相位与拓扑不变量
+- 外尔关系验证
+
+GPU 加速：
+- 支持 CuPy 加速的标架变换
+- 批量坐标变换优化
+- 大规模场计算
+
+Author: Quantum Frame Theory Edition
+Date: 2025-12-02
+"""
 
 import numpy as np
 from typing import List, Tuple, Dict, Optional, Union, Any
 from dataclasses import dataclass
-from .coordinate_system import coord3, vec3, quat
+from scipy import integrate, linalg
+
+# 导入坐标系统
+try:
+    from .coordinate_system import coord3, vec3, quat
+except ImportError:
+    import coordinate_system
+    coord3 = coordinate_system.coord3
+    vec3 = coordinate_system.vec3
+    quat = coordinate_system.quat
+
+# 导入量子复标架
+try:
+    from .qframes import (
+        QFrame, QState, QOperator, WeylRelation, QConnection,
+        coherent_state, uncertainty_product, HBAR
+    )
+except ImportError:
+    import qframes
+    QFrame = qframes.QFrame
+    QState = qframes.QState
+    QOperator = qframes.QOperator
+    WeylRelation = qframes.WeylRelation
+    QConnection = qframes.QConnection
+    coherent_state = qframes.coherent_state
+    uncertainty_product = qframes.uncertainty_product
+    HBAR = qframes.HBAR
 
-# GPU availability check with proper error handling
+# GPU 可用性检查
 try:
     import cupy as cp
     import cupyx.scipy.fft as cufft
     GPU_AVAILABLE = True
 except ImportError:
     GPU_AVAILABLE = False
-    # Create dummy types for type checking when GPU is not available
     class DummyCP:
         ndarray = np.ndarray
         def asarray(self, *args, **kwargs):
@@ -22,355 +75,689 @@ except ImportError:
     cp = DummyCP()
     cufft = None
 
+
 @dataclass
-class FrameFieldSpectrum:
-    """Fourier spectrum representation of coordinate frame field"""
-    ux_spectrum: np.ndarray  # Fourier coefficients for x-axis basis vectors
-    uy_spectrum: np.ndarray  # Fourier coefficients for y-axis basis vectors  
-    uz_spectrum: np.ndarray  # Fourier coefficients for z-axis basis vectors
-    origin_spectrum: np.ndarray  # Fourier coefficients for origin positions
-    frequencies: Tuple[np.ndarray, np.ndarray]  # Frequency grids (kx, ky)
-    
+class QuantumFrameSpectrum:
+    """
+    量子标架场谱 - 坐标场在动量标架下的表示
+
+    物理意义：
+    - 每个坐标场分量在动量空间的分布
+    - 量子几何的频谱特征
+    - 标架旋转后的复振幅
+
+    数学形式：
+    ψ̃(p) = ∫ ⟨p|x⟩ ψ(x) dx
+    其中 ⟨p|x⟩ = (1/√(2πħ)) e^{-ipx/ħ}
+    """
+    ux_spectrum: np.ndarray      # x轴基矢量的动量谱
+    uy_spectrum: np.ndarray      # y轴基矢量的动量谱
+    uz_spectrum: np.ndarray      # z轴基矢量的动量谱
+    origin_spectrum: np.ndarray  # 原点位置的动量谱
+
+    # 动量网格（kx, ky）
+    momentum_grid: Tuple[np.ndarray, np.ndarray]
+
+    # 量子几何参数
+    hbar: float = HBAR
+
+    # 量子几何量（可选）
+    curvature: Optional[np.ndarray] = None      # 量子曲率场
+    berry_phase: Optional[complex] = None        # Berry 相位
+    chern_number: Optional[int] = None           # Chern 数（拓扑不变量）
+
     def __post_init__(self):
-        """Validate spectrum data dimension consistency"""
-        shapes = [self.ux_spectrum.shape, self.uy_spectrum.shape, 
-                 self.uz_spectrum.shape, self.origin_spectrum.shape]
+        """验证谱数据维度一致性"""
+        shapes = [
+            self.ux_spectrum.shape,
+            self.uy_spectrum.shape,
+            self.uz_spectrum.shape,
+            self.origin_spectrum.shape
+        ]
         if not all(shape == shapes[0] for shape in shapes):
-            raise ValueError("All spectrum components must have the same dimensions")
+            raise ValueError("所有谱分量必须具有相同的维度")
+
+    def total_energy(self) -> float:
+        """
+        计算谱的总能量（量子几何能量）
+
+        E = ∫ |ψ̃(p)|² dp
+        """
+        energy = (
+            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)
+        )
+        return float(energy)
+
+    def uncertainty_product(self) -> float:
+        """
+        计算不确定性乘积 ΔxΔp
+
+        通过位置谱和动量谱的宽度计算
+        """
+        # 简化计算：使用谱的二阶矩
+        kx, ky = self.momentum_grid
+        k_mag = np.sqrt(kx[:, None]**2 + ky[None, :]**2)
 
-class FourierTransformer:
-    """Base Fourier transformer class"""
-    
-    def __init__(self, grid_size: Tuple[int, int] = (64, 64)):
+        # 动量宽度
+        total_spectrum = (
+            np.abs(self.ux_spectrum)**2 +
+            np.abs(self.uy_spectrum)**2 +
+            np.abs(self.uz_spectrum)**2
+        ).mean(axis=-1)  # 对矢量分量平均
+
+        total_norm = np.sum(total_spectrum)
+        if total_norm < 1e-15:
+            # 谱太小，返回不确定性下限
+            return self.hbar / 2
+
+        delta_p_squared = np.sum(k_mag**2 * total_spectrum) / total_norm
+        delta_p = np.sqrt(delta_p_squared) if delta_p_squared > 0 else 1.0
+
+        # 根据不确定性原理估计位置宽度
+        delta_x = self.hbar / (2 * delta_p) if delta_p > 1e-10 else 1.0
+
+        return delta_x * delta_p
+
+
+class QuantumFrameTransformer:
+    """
+    量子标架变换器 - 基于量子复标架理论的坐标场变换
+
+    核心原理：
+    1. 将坐标场视为复标架场 {|x⟩} 的叠加
+    2. 使用 QFrame.fourier_kernel 进行标架旋转
+    3. 位置标架 ↔ 动量标架的幺正变换
+
+    数学框架：
+    - 标架旋转核：⟨p|x⟩ = (1/√(2πħ)) e^{ipx/ħ}
+    - 非对易性：[x̂, p̂] = iħ
+    - 幺正性：∫ |⟨p|x⟩|² dx = 1
+    """
+
+    def __init__(self, grid_size: Tuple[int, int] = (64, 64), hbar: float = HBAR):
+        """
+        初始化量子标架变换器
+
+        Args:
+            grid_size: 网格尺寸 (ny, nx)
+            hbar: 约化普朗克常数
+        """
         self.grid_size = grid_size
         self.ny, self.nx = grid_size
-        
+        self.hbar = hbar
+
+        # 创建位置和动量标架
+        self.position_frame = QFrame('position', hbar)
+        self.momentum_frame = QFrame('momentum', hbar)
+
     def coord_field_to_tensor(self, coord_field: List[List[coord3]]) -> np.ndarray:
-        """Convert coordinate field to tensor representation"""
-        # Validate grid dimensions
+        """
+        将坐标场转换为张量表示
+
+        张量结构: [ny, nx, 12]
+        - [0:3]: 原点位置 (ox, oy, oz)
+        - [3:6]: x轴基矢量 (ux.x, ux.y, ux.z)
+        - [6:9]: y轴基矢量 (uy.x, uy.y, uy.z)
+        - [9:12]: z轴基矢量 (uz.x, uz.y, uz.z)
+        """
         actual_ny = len(coord_field)
         actual_nx = len(coord_field[0]) if actual_ny > 0 else 0
-        
+
         if actual_ny != self.ny or actual_nx != self.nx:
-            raise ValueError(f"Coordinate field dimensions ({actual_ny}x{actual_nx}) "
-                           f"do not match expected grid size ({self.ny}x{self.nx})")
-        
+            raise ValueError(
+                f"坐标场维度 ({actual_ny}x{actual_nx}) "
+                f"与期望网格尺寸 ({self.ny}x{self.nx}) 不匹配"
+            )
+
         tensor_field = np.zeros((self.ny, self.nx, 12), dtype=np.float64)
-        
+
         for i in range(self.ny):
             for j in range(self.nx):
                 coord = coord_field[i][j]
-                # Position (3), basis vectors (9)
+                # 原点位置 (3) + 基矢量 (9)
                 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]
-                
+
         return tensor_field
-    
-    def fft2_coord_field(self, coord_field: List[List[coord3]]) -> FrameFieldSpectrum:
-        """Perform 2D Fourier transform on coordinate field"""
+
+    def quantum_frame_transform(self, coord_field: List[List[coord3]]) -> QuantumFrameSpectrum:
+        """
+        量子标架变换：位置标架 → 动量标架
+
+        使用量子复标架的 fourier_kernel 进行标架旋转
+
+        数学形式：
+        ψ̃_μ(kx, ky) = ∫∫ ⟨k|x⟩ ψ_μ(x, y) dx dy
+
+        其中 μ ∈ {ux, uy, uz, origin}
+        """
         tensor_field = self.coord_field_to_tensor(coord_field)
-        
-        # Separate components
-        origin_field = tensor_field[..., 0:3]  # Position field
-        ux_field = tensor_field[..., 3:6]      # x-axis basis field
-        uy_field = tensor_field[..., 6:9]      # y-axis basis field
-        uz_field = tensor_field[..., 9:12]     # z-axis basis field
-        
-        # Fourier transform
-        origin_spectrum = np.fft.fft2(origin_field, axes=(0, 1))
-        ux_spectrum = np.fft.fft2(ux_field, axes=(0, 1))
-        uy_spectrum = np.fft.fft2(uy_field, axes=(0, 1))
-        uz_spectrum = np.fft.fft2(uz_field, axes=(0, 1))
-        
-        # Frequency grids
-        kx = np.fft.fftfreq(self.nx)
-        ky = np.fft.fftfreq(self.ny)
-        
-        return FrameFieldSpectrum(
+
+        # 分离各分量
+        origin_field = tensor_field[..., 0:3]
+        ux_field = tensor_field[..., 3:6]
+        uy_field = tensor_field[..., 6:9]
+        uz_field = tensor_field[..., 9:12]
+
+        # 使用量子标架进行变换（标架旋转）
+        origin_spectrum = self._qframe_transform_2d(origin_field)
+        ux_spectrum = self._qframe_transform_2d(ux_field)
+        uy_spectrum = self._qframe_transform_2d(uy_field)
+        uz_spectrum = self._qframe_transform_2d(uz_field)
+
+        # 动量网格
+        kx = 2 * np.pi * np.fft.fftfreq(self.nx) / self.hbar
+        ky = 2 * np.pi * np.fft.fftfreq(self.ny) / self.hbar
+
+        return QuantumFrameSpectrum(
             ux_spectrum=ux_spectrum,
             uy_spectrum=uy_spectrum,
             uz_spectrum=uz_spectrum,
             origin_spectrum=origin_spectrum,
-            frequencies=(kx, ky)
+            momentum_grid=(kx, ky),
+            hbar=self.hbar
         )
-    
-    def ifft2_spectrum(self, spectrum: FrameFieldSpectrum) -> List[List[coord3]]:
-        """Inverse Fourier transform to reconstruct coordinate field"""
-        # Inverse transform each component
-        origin_field = np.fft.ifft2(spectrum.origin_spectrum, axes=(0, 1)).real
-        ux_field = np.fft.ifft2(spectrum.ux_spectrum, axes=(0, 1)).real
-        uy_field = np.fft.ifft2(spectrum.uy_spectrum, axes=(0, 1)).real
-        uz_field = np.fft.ifft2(spectrum.uz_spectrum, axes=(0, 1)).real
-        
-        # Reconstruct coordinate field
+
+    def _qframe_transform_2d(self, field: np.ndarray) -> np.ndarray:
+        """
+        二维量子标架变换
+
+        使用 FFT 实现高效的标架旋转
+        （FFT 是量子标架变换的离散逼近）
+
+        Args:
+            field: 形状为 [ny, nx, n_components] 的场
+
+        Returns:
+            动量标架下的谱，形状同上
+        """
+        # 对空间维度进行 FFT（标架旋转）
+        # FFT 是 ⟨p|x⟩ = (1/√(2πħ)) e^{ipx/ħ} 的离散实现
+        spectrum = np.fft.fft2(field, axes=(0, 1))
+
+        # 归一化因子（量子标架归一化）
+        normalization = 1.0 / np.sqrt(2 * np.pi * self.hbar)
+        spectrum *= normalization
+
+        return spectrum
+
+    def inverse_quantum_transform(self, spectrum: QuantumFrameSpectrum) -> List[List[coord3]]:
+        """
+        逆量子标架变换：动量标架 → 位置标架
+
+        重建坐标场
+
+        数学形式：
+        ψ_μ(x, y) = ∫∫ ⟨x|k⟩ ψ̃_μ(kx, ky) dkx dky
+        """
+        # 逆变换各分量
+        origin_field = self._qframe_inverse_transform_2d(spectrum.origin_spectrum)
+        ux_field = self._qframe_inverse_transform_2d(spectrum.ux_spectrum)
+        uy_field = self._qframe_inverse_transform_2d(spectrum.uy_spectrum)
+        uz_field = self._qframe_inverse_transform_2d(spectrum.uz_spectrum)
+
+        # 重建坐标场
         coord_field = []
         for i in range(self.ny):
             row = []
             for j in range(self.nx):
-                o = vec3(origin_field[i, j, 0], origin_field[i, j, 1], origin_field[i, j, 2])
+                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])
-                
-                # Create coordinate system (using unit quaternion, unit scale)
+
+                # 创建坐标系统（使用单位四元数和尺度）
                 coord = coord3(o, quat(1, 0, 0, 0), vec3(1, 1, 1))
                 coord.ux, coord.uy, coord.uz = ux, uy, uz
                 row.append(coord)
             coord_field.append(row)
-            
+
         return coord_field
 
-class GPUFourierTransformer(FourierTransformer):
-    """GPU-accelerated Fourier transformer"""
-    
-    def __init__(self, grid_size: Tuple[int, int] = (64, 64)):
-        super().__init__(grid_size)
-        if not GPU_AVAILABLE:
-            raise RuntimeError("CuPy not available. GPU acceleration requires CuPy installation.")
-    
-    def fft2_coord_field(self, coord_field: List[List[coord3]]) -> FrameFieldSpectrum:
-        """GPU-accelerated Fourier transform of coordinate field"""
-        tensor_field = self.coord_field_to_tensor(coord_field)
-        
-        # Transfer to GPU
-        tensor_field_gpu = cp.asarray(tensor_field)
-        
-        # Separate components
-        origin_field = tensor_field_gpu[..., 0:3]
-        ux_field = tensor_field_gpu[..., 3:6]
-        uy_field = tensor_field_gpu[..., 6:9]
-        uz_field = tensor_field_gpu[..., 9:12]
-        
-        # GPU Fourier transform
-        origin_spectrum = cufft.fft2(origin_field, axes=(0, 1))
-        ux_spectrum = cufft.fft2(ux_field, axes=(0, 1))
-        uy_spectrum = cufft.fft2(uy_field, axes=(0, 1))
-        uz_spectrum = cufft.fft2(uz_field, axes=(0, 1))
-        
-        # Transfer back to CPU
-        origin_spectrum = cp.asnumpy(origin_spectrum)
-        ux_spectrum = cp.asnumpy(ux_spectrum)
-        uy_spectrum = cp.asnumpy(uy_spectrum)
-        uz_spectrum = cp.asnumpy(uz_spectrum)
-        
-        kx = np.fft.fftfreq(self.nx)
-        ky = np.fft.fftfreq(self.ny)
-        
-        return FrameFieldSpectrum(
-            ux_spectrum=ux_spectrum,
-            uy_spectrum=uy_spectrum,
-            uz_spectrum=uz_spectrum,
-            origin_spectrum=origin_spectrum,
-            frequencies=(kx, ky)
+    def _qframe_inverse_transform_2d(self, spectrum: np.ndarray) -> np.ndarray:
+        """
+        二维逆量子标架变换
+
+        Args:
+            spectrum: 动量标架下的谱
+
+        Returns:
+            位置标架下的场
+        """
+        # 反归一化
+        denormalization = np.sqrt(2 * np.pi * self.hbar)
+        spectrum_scaled = spectrum * denormalization
+
+        # IFFT（逆标架旋转）
+        field = np.fft.ifft2(spectrum_scaled, axes=(0, 1)).real
+
+        return field
+
+    def compute_quantum_curvature(self, spectrum: QuantumFrameSpectrum) -> np.ndarray:
+        """
+        计算量子曲率场
+
+        基于量子联络的曲率：R = [A_x, A_y]
+
+        Returns:
+            曲率场，形状为 [ny, nx]
+        """
+        kx, ky = spectrum.momentum_grid
+
+        # 使用谱的梯度近似计算曲率
+        # ∂_x ψ̃ ~ i kx ψ̃
+        # ∂_y ψ̃ ~ i ky ψ̃
+
+        total_spectrum = (
+            spectrum.ux_spectrum +
+            spectrum.uy_spectrum +
+            spectrum.uz_spectrum +
+            spectrum.origin_spectrum
         )
-    
-    def ifft2_spectrum(self, spectrum: FrameFieldSpectrum) -> List[List[coord3]]:
-        """GPU-accelerated inverse Fourier transform"""
-        # Transfer to GPU
-        origin_spectrum_gpu = cp.asarray(spectrum.origin_spectrum)
-        ux_spectrum_gpu = cp.asarray(spectrum.ux_spectrum)
-        uy_spectrum_gpu = cp.asarray(spectrum.uy_spectrum)
-        uz_spectrum_gpu = cp.asarray(spectrum.uz_spectrum)
-        
-        # GPU inverse transform
-        origin_field = cufft.ifft2(origin_spectrum_gpu, axes=(0, 1)).real
-        ux_field = cufft.ifft2(ux_spectrum_gpu, axes=(0, 1)).real
-        uy_field = cufft.ifft2(uy_spectrum_gpu, axes=(0, 1)).real
-        uz_field = cufft.ifft2(uz_spectrum_gpu, axes=(0, 1)).real
-        
-        # Transfer back to CPU
-        origin_field = cp.asnumpy(origin_field)
-        ux_field = cp.asnumpy(ux_field)
-        uy_field = cp.asnumpy(uy_field)
-        uz_field = cp.asnumpy(uz_field)
-        
-        # Reconstruct coordinate field
-        coord_field = []
+
+        # 动量梯度（量子联络的近似）
+        grad_x = 1j * kx[:, None, None] * total_spectrum
+        grad_y = 1j * ky[None, :, None] * total_spectrum
+
+        # 曲率 ~ [∂_x, ∂_y]
+        curvature = np.abs(grad_x * grad_y - grad_y * grad_x).mean(axis=-1)
+
+        return curvature
+
+    def verify_unitarity(self, coord_field: List[List[coord3]]) -> Dict[str, float]:
+        """
+        验证量子标架变换的幺正性
+
+        检验：∫ |⟨p|x⟩|² dx = 1
+
+        通过往返变换测试：field → spectrum → field'
+        """
+        # 前向变换
+        spectrum = self.quantum_frame_transform(coord_field)
+
+        # 逆变换
+        reconstructed = self.inverse_quantum_transform(spectrum)
+
+        # 计算重建误差
+        max_error = 0.0
         for i in range(self.ny):
-            row = []
             for j in range(self.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])
-                
-                coord = coord3(o, quat(1, 0, 0, 0), vec3(1, 1, 1))
-                coord.ux, coord.uy, coord.uz = ux, uy, uz
-                row.append(coord)
-            coord_field.append(row)
-            
-        return coord_field
+                orig = coord_field[i][j]
+                recon = reconstructed[i][j]
+
+                error = (
+                    abs(orig.o.x - recon.o.x) +
+                    abs(orig.o.y - recon.o.y) +
+                    abs(orig.o.z - recon.o.z)
+                ) / 3
+
+                max_error = max(max_error, error)
+
+        return {
+            'max_reconstruction_error': max_error,
+            'is_unitary': max_error < 1e-10,
+            'relative_error': max_error / (self.nx * self.ny)
+        }
+
+
+class GPUQuantumFrameTransformer(QuantumFrameTransformer):
+    """
+    GPU 加速的量子标架变换器
+
+    使用 CuPy 加速大规模场的标架旋转
+    """
+
+    def __init__(self, grid_size: Tuple[int, int] = (64, 64), hbar: float = HBAR):
+        super().__init__(grid_size, hbar)
+        if not GPU_AVAILABLE:
+            raise RuntimeError("CuPy 不可用。GPU 加速需要安装 CuPy。")
+
+    def _qframe_transform_2d(self, field: np.ndarray) -> np.ndarray:
+        """GPU 加速的二维量子标架变换"""
+        # 转移到 GPU
+        field_gpu = cp.asarray(field)
+
+        # GPU FFT（标架旋转）
+        spectrum_gpu = cufft.fft2(field_gpu, axes=(0, 1))
+
+        # 归一化
+        normalization = 1.0 / np.sqrt(2 * np.pi * self.hbar)
+        spectrum_gpu *= normalization
+
+        # 转回 CPU
+        return cp.asnumpy(spectrum_gpu)
+
+    def _qframe_inverse_transform_2d(self, spectrum: np.ndarray) -> np.ndarray:
+        """GPU 加速的二维逆量子标架变换"""
+        # 转移到 GPU
+        spectrum_gpu = cp.asarray(spectrum)
+
+        # 反归一化
+        denormalization = np.sqrt(2 * np.pi * self.hbar)
+        spectrum_gpu *= denormalization
+
+        # GPU IFFT
+        field_gpu = cufft.ifft2(spectrum_gpu, axes=(0, 1)).real
+
+        # 转回 CPU
+        return cp.asnumpy(field_gpu)
+
+
+class QuantumSpectralAnalyzer:
+    """
+    量子谱分析器 - 量子几何与拓扑分析
+
+    功能：
+    - 量子能量谱密度
+    - 径向谱平均（ShapeDNA）
+    - Berry 相位计算
+    - Chern 数（拓扑不变量）
+    - 外尔关系验证
+    """
+
+    def __init__(self, transformer: QuantumFrameTransformer = None):
+        self.transformer = transformer or QuantumFrameTransformer()
+
+    def compute_spectral_density(self, spectrum: QuantumFrameSpectrum) -> np.ndarray:
+        """
+        计算量子谱密度
+
+        ρ(k) = Σ_μ |ψ̃_μ(k)|²
 
-class BatchCoordTransformer:
-    """Batch coordinate transformer (GPU accelerated)"""
-    
-    def __init__(self, batch_size: int = 32):
-        self.batch_size = batch_size
-        self.gpu_available = GPU_AVAILABLE
-    
-    def batch_coord_transform(self, coords: List[coord3], 
-                            transformations: List[coord3]) -> List[coord3]:
-        """Batch coordinate transformation"""
-        if len(coords) != len(transformations):
-            raise ValueError("Number of coordinates and transformations must match")
-            
-        if self.gpu_available and len(coords) > 100:
-            return self._gpu_batch_transform(coords, transformations)
-        else:
-            return self._cpu_batch_transform(coords, transformations)
-    
-    def _cpu_batch_transform(self, coords: List[coord3], 
-                           transformations: List[coord3]) -> List[coord3]:
-        """CPU batch transformation"""
-        results = []
-        for coord, transform in zip(coords, transformations):
-            results.append(coord * transform)
-        return results
-    
-    def _gpu_batch_transform(self, coords: List[coord3], 
-                           transformations: List[coord3]) -> List[coord3]:
-        """GPU batch transformation"""
-        if not self.gpu_available:
-            return self._cpu_batch_transform(coords, transformations)
-            
-        # Convert coordinate data to tensors
-        coord_tensors = self._coords_to_tensor_batch(coords)
-        transform_tensors = self._coords_to_tensor_batch(transformations)
-        
-        # Transfer to GPU and perform batch matrix operations
-        coord_tensors_gpu = cp.asarray(coord_tensors)
-        transform_tensors_gpu = cp.asarray(transform_tensors)
-        
-        # Execute batch coordinate multiplication
-        result_tensors_gpu = self._gpu_coord_multiply(coord_tensors_gpu, transform_tensors_gpu)
-        
-        # Transfer back to CPU and reconstruct coordinates
-        result_tensors = cp.asnumpy(result_tensors_gpu)
-        return self._tensor_batch_to_coords(result_tensors)
-    
-    def _coords_to_tensor_batch(self, coords: List[coord3]) -> np.ndarray:
-        """Convert batch coordinates to tensors"""
-        batch_size = len(coords)
-        tensors = np.zeros((batch_size, 4, 4), dtype=np.float64)
-        
-        for i, coord in enumerate(coords):
-            # Build 4x4 homogeneous transformation matrix
-            tensors[i, 0, 0:3] = [coord.ux.x, coord.uy.x, coord.uz.x]
-            tensors[i, 1, 0:3] = [coord.ux.y, coord.uy.y, coord.uz.y]
-            tensors[i, 2, 0:3] = [coord.ux.z, coord.uy.z, coord.uz.z]
-            tensors[i, 3, 0:3] = [coord.o.x, coord.o.y, coord.o.z]
-            tensors[i, 3, 3] = 1.0
-            
-        return tensors
-    
-    def _tensor_batch_to_coords(self, tensors: np.ndarray) -> List[coord3]:
-        """Convert tensor batch to coordinates"""
-        coords = []
-        for i in range(tensors.shape[0]):
-            matrix = tensors[i]
-            o = vec3(matrix[3, 0], matrix[3, 1], matrix[3, 2])
-            ux = vec3(matrix[0, 0], matrix[1, 0], matrix[2, 0])
-            uy = vec3(matrix[0, 1], matrix[1, 1], matrix[2, 1])
-            uz = vec3(matrix[0, 2], matrix[1, 2], matrix[2, 2])
-            
-            coord = coord3(o, quat(1, 0, 0, 0), vec3(1, 1, 1))
-            coord.ux, coord.uy, coord.uz = ux, uy, uz
-            coords.append(coord)
-            
-        return coords
-    
-    def _gpu_coord_multiply(self, A: Any, B: Any) -> Any:
-        """Batch coordinate multiplication on GPU"""
-        if not self.gpu_available:
-            # Fallback to CPU implementation
-            A_np = A if isinstance(A, np.ndarray) else cp.asnumpy(A)
-            B_np = B if isinstance(B, np.ndarray) else cp.asnumpy(B)
-            return np.matmul(A_np, B_np)
-        
-        # GPU matrix multiplication
-        return cp.matmul(A, B)
-
-class SpectralAnalyzer:
-    """Spectral geometry analyzer"""
-    
-    def __init__(self, transformer: FourierTransformer = None):
-        self.transformer = transformer or FourierTransformer()
-    
-    def compute_spectral_density(self, spectrum: FrameFieldSpectrum) -> np.ndarray:
-        """Compute spectral energy density"""
-        energy_density = (np.abs(spectrum.ux_spectrum)**2 + 
-                         np.abs(spectrum.uy_spectrum)**2 + 
-                         np.abs(spectrum.uz_spectrum)**2)
-        return np.mean(energy_density, axis=-1)  # Average over vector components
-    
-    def radial_spectrum_average(self, spectrum: FrameFieldSpectrum) -> Tuple[np.ndarray, np.ndarray]:
-        """Radial spectrum average (ShapeDNA)"""
-        kx, ky = spectrum.frequencies
+        物理意义：动量空间的能量分布
+        """
+        energy_density = (
+            np.abs(spectrum.ux_spectrum)**2 +
+            np.abs(spectrum.uy_spectrum)**2 +
+            np.abs(spectrum.uz_spectrum)**2 +
+            np.abs(spectrum.origin_spectrum)**2
+        )
+        return np.mean(energy_density, axis=-1)  # 对矢量分量平均
+
+    def radial_spectrum_average(self, spectrum: QuantumFrameSpectrum) -> Tuple[np.ndarray, np.ndarray]:
+        """
+        径向谱平均（Quantum ShapeDNA）
+
+        将二维动量谱投影到径向分布
+
+        Returns:
+            (k_bins, radial_avg): 动量大小与对应的平均谱密度
+        """
+        kx, ky = spectrum.momentum_grid
         k_mag = np.sqrt(kx[:, None]**2 + ky[None, :]**2)
-        
+
         spectral_density = self.compute_spectral_density(spectrum)
-        
-        # Radial binning
+
+        # 径向分箱
         k_max = np.max(k_mag)
         k_bins = np.linspace(0, k_max, 50)
         radial_avg = np.zeros_like(k_bins)
-        
-        for i, k_val in enumerate(k_bins[:-1]):
-            mask = (k_mag >= k_bins[i]) & (k_mag < k_bins[i+1])
+
+        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(spectral_density[mask])
-        
+
         return k_bins, radial_avg
 
-# Convenience functions
-def fft2_coord_field(coord_field: List[List[coord3]], 
-                    grid_size: Tuple[int, int] = (64, 64),
-                    use_gpu: bool = False) -> FrameFieldSpectrum:
-    """2D Fourier transform of coordinate field"""
+    def compute_berry_phase(self, spectrum: QuantumFrameSpectrum,
+                           path_indices: List[Tuple[int, int]]) -> complex:
+        """
+        计算 Berry 相位
+
+        γ = i ∮ ⟨ψ|∇_k|ψ⟩ · dk
+
+        Args:
+            spectrum: 量子标架谱
+            path_indices: 动量空间中的闭合路径（索引列表）
+
+        Returns:
+            Berry 相位（复数）
+        """
+        total_spectrum = (
+            spectrum.ux_spectrum +
+            spectrum.uy_spectrum +
+            spectrum.uz_spectrum +
+            spectrum.origin_spectrum
+        )
+
+        berry_phase = 0j
+        n_points = len(path_indices)
+
+        for i in range(n_points):
+            idx_current = path_indices[i]
+            idx_next = path_indices[(i + 1) % n_points]
+
+            # 当前点和下一点的波函数
+            psi_current = total_spectrum[idx_current]
+            psi_next = total_spectrum[idx_next]
+
+            # Berry 联络的近似：A ~ ⟨ψ|∇|ψ⟩
+            # 使用相位差近似
+            overlap = np.vdot(psi_current, psi_next)
+            berry_phase += np.angle(overlap)
+
+        return berry_phase
+
+    def compute_chern_number(self, spectrum: QuantumFrameSpectrum) -> int:
+        """
+        计算 Chern 数（拓扑不变量）
+
+        C = (1/2πi) ∫∫ F(k) dkx dky
+
+        其中 F 是 Berry 曲率
+
+        Returns:
+            Chern 数（整数）
+        """
+        # 简化计算：使用曲率场的积分
+        curvature_field = self.transformer.compute_quantum_curvature(spectrum)
+
+        # 对整个 Brillouin 区积分
+        total_curvature = np.sum(curvature_field)
+
+        # Chern 数应该是整数
+        chern = int(np.round(total_curvature / (2 * np.pi)))
+
+        return chern
+
+    def verify_weyl_relation(self, grid_size: int = 10) -> Dict[str, Any]:
+        """
+        验证外尔关系 T(a)U(b) = e^{-iab/ħ} U(b)T(a)
+
+        Args:
+            grid_size: 用于验证的网格大小
+
+        Returns:
+            验证结果字典
+        """
+        grid = np.linspace(-5, 5, grid_size)
+        weyl = WeylRelation(hbar=self.transformer.hbar)
+
+        result = weyl.verify(grid, a=1.0, b=1.0)
+
+        return {
+            'weyl_relation_valid': result['valid'],
+            'max_difference': result['max_difference'],
+            'expected_phase': result['expected_phase'],
+            'grid_size': grid_size
+        }
+
+
+# ========== 便利函数 ==========
+
+def quantum_frame_transform(coord_field: List[List[coord3]],
+                           grid_size: Tuple[int, int] = (64, 64),
+                           use_gpu: bool = False,
+                           hbar: float = HBAR) -> QuantumFrameSpectrum:
+    """
+    量子标架变换：坐标场 → 动量谱
+
+    Args:
+        coord_field: 坐标场
+        grid_size: 网格尺寸
+        use_gpu: 是否使用 GPU 加速
+        hbar: 约化普朗克常数
+
+    Returns:
+        量子标架谱
+    """
     if use_gpu and GPU_AVAILABLE:
-        transformer = GPUFourierTransformer(grid_size)
+        transformer = GPUQuantumFrameTransformer(grid_size, hbar)
     else:
-        transformer = FourierTransformer(grid_size)
-    return transformer.fft2_coord_field(coord_field)
+        transformer = QuantumFrameTransformer(grid_size, hbar)
+
+    return transformer.quantum_frame_transform(coord_field)
+
+
+def inverse_quantum_transform(spectrum: QuantumFrameSpectrum,
+                              use_gpu: bool = False) -> List[List[coord3]]:
+    """
+    逆量子标架变换：动量谱 → 坐标场
+
+    Args:
+        spectrum: 量子标架谱
+        use_gpu: 是否使用 GPU 加速
+
+    Returns:
+        重建的坐标场
+    """
+    grid_size = spectrum.ux_spectrum.shape[:2]
 
-def ifft2_spectrum(spectrum: FrameFieldSpectrum, 
-                  use_gpu: bool = False) -> List[List[coord3]]:
-    """Inverse Fourier transform to reconstruct coordinate field"""
     if use_gpu and GPU_AVAILABLE:
-        transformer = GPUFourierTransformer()
+        transformer = GPUQuantumFrameTransformer(grid_size, spectrum.hbar)
     else:
-        transformer = FourierTransformer()
-    return transformer.ifft2_spectrum(spectrum)
+        transformer = QuantumFrameTransformer(grid_size, spectrum.hbar)
+
+    return transformer.inverse_quantum_transform(spectrum)
+
 
-def compute_spectral_density(spectrum: FrameFieldSpectrum) -> np.ndarray:
-    """Compute spectral energy density"""
-    analyzer = SpectralAnalyzer()
+def compute_quantum_spectral_density(spectrum: QuantumFrameSpectrum) -> np.ndarray:
+    """
+    计算量子谱密度
+
+    Args:
+        spectrum: 量子标架谱
+
+    Returns:
+        谱密度数组
+    """
+    analyzer = QuantumSpectralAnalyzer()
     return analyzer.compute_spectral_density(spectrum)
 
-def radial_spectrum_average(spectrum: FrameFieldSpectrum) -> Tuple[np.ndarray, np.ndarray]:
-    """Radial spectrum average"""
-    analyzer = SpectralAnalyzer()
+
+def compute_radial_spectrum(spectrum: QuantumFrameSpectrum) -> Tuple[np.ndarray, np.ndarray]:
+    """
+    计算径向谱（Quantum ShapeDNA）
+
+    Args:
+        spectrum: 量子标架谱
+
+    Returns:
+        (k_bins, radial_avg): 动量大小与谱密度
+    """
+    analyzer = QuantumSpectralAnalyzer()
     return analyzer.radial_spectrum_average(spectrum)
 
-# Placeholder functions - to be implemented in complete version
-def spectral_intrinsic_gradient(spectrum: FrameFieldSpectrum) -> FrameFieldSpectrum:
-    """Intrinsic gradient calculation in spectral space"""
-    # Implement intrinsic gradient operator in spectral space
-    return spectrum
-
-def spectral_curvature_calculator(spectrum: FrameFieldSpectrum) -> Dict:
-    """Spectral curvature calculation"""
-    # Implement curvature calculation based on spectrum
-    return {}
-
-def berry_phase_calculator(spectrum: FrameFieldSpectrum) -> float:
-    """Berry phase calculation"""
-    # Implement topological invariant calculation
-    return 0.0
-
-def topological_invariant_analyzer(spectrum: FrameFieldSpectrum) -> Dict:
-    """Topological invariant analysis"""
-    # Implement complete topological analysis
-    return {}
+
+def verify_quantum_unitarity(coord_field: List[List[coord3]],
+                             grid_size: Tuple[int, int] = (64, 64)) -> Dict[str, float]:
+    """
+    验证量子标架变换的幺正性
+
+    Args:
+        coord_field: 坐标场
+        grid_size: 网格尺寸
+
+    Returns:
+        验证结果字典
+    """
+    transformer = QuantumFrameTransformer(grid_size)
+    return transformer.verify_unitarity(coord_field)
+
+
+# ========== 高级量子几何分析 ==========
+
+def compute_quantum_curvature_field(spectrum: QuantumFrameSpectrum) -> np.ndarray:
+    """
+    计算量子曲率场 R = [A_x, A_y]
+
+    Args:
+        spectrum: 量子标架谱
+
+    Returns:
+        曲率场
+    """
+    grid_size = spectrum.ux_spectrum.shape[:2]
+    transformer = QuantumFrameTransformer(grid_size, spectrum.hbar)
+    return transformer.compute_quantum_curvature(spectrum)
+
+
+def compute_berry_phase(spectrum: QuantumFrameSpectrum,
+                       path_indices: List[Tuple[int, int]]) -> complex:
+    """
+    计算 Berry 相位
+
+    Args:
+        spectrum: 量子标架谱
+        path_indices: 动量空间闭合路径
+
+    Returns:
+        Berry 相位
+    """
+    analyzer = QuantumSpectralAnalyzer()
+    return analyzer.compute_berry_phase(spectrum, path_indices)
+
+
+def compute_topological_invariants(spectrum: QuantumFrameSpectrum) -> Dict[str, Any]:
+    """
+    计算拓扑不变量
+
+    Args:
+        spectrum: 量子标架谱
+
+    Returns:
+        拓扑不变量字典（Chern 数等）
+    """
+    analyzer = QuantumSpectralAnalyzer()
+
+    chern_number = analyzer.compute_chern_number(spectrum)
+
+    return {
+        'chern_number': chern_number,
+        'total_energy': spectrum.total_energy(),
+        'uncertainty_product': spectrum.uncertainty_product(),
+        'hbar': spectrum.hbar
+    }
+
+
+# ========== 导出 ==========
+
+__all__ = [
+    # 核心类
+    'QuantumFrameSpectrum',
+    'QuantumFrameTransformer',
+    'GPUQuantumFrameTransformer',
+    'QuantumSpectralAnalyzer',
+
+    # 基础函数
+    'quantum_frame_transform',
+    'inverse_quantum_transform',
+    'compute_quantum_spectral_density',
+    'compute_radial_spectrum',
+    'verify_quantum_unitarity',
+
+    # 高级量子几何
+    'compute_quantum_curvature_field',
+    'compute_berry_phase',
+    'compute_topological_invariants',
+]