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

coordinate_system/fourier_spectral.py

@@ -1,763 +1,125 @@
 """
-Quantum Frame Spectral Analysis - 量子标架谱分析
+Quantum Frame Spectral Analysis - 向后兼容模块
 ==============================================
 
-基于量子复标架理论的坐标场谱分析系统。
-将傅里叶谱分析升级为量子几何框架。
+此模块已合并到 qframes.py 中。
+保留此文件仅用于向后兼容。
 
-核心概念转换：
-- 传统傅里叶谱 → 量子标架场谱
-- 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 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
+请直接使用 qframes 模块：
+    from coordinate_system.qframes import (
+        QFrame,
+        QFrameSpectrum,
+        spectral_transform,
+        inverse_spectral_transform,
     )
-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 可用性检查
-try:
-    import cupy as cp
-    import cupyx.scipy.fft as cufft
-    GPU_AVAILABLE = True
-except ImportError:
-    GPU_AVAILABLE = False
-    class DummyCP:
-        ndarray = np.ndarray
-        def asarray(self, *args, **kwargs):
-            raise RuntimeError("CuPy not available")
-        def matmul(self, *args, **kwargs):
-            raise RuntimeError("CuPy not available")
-    cp = DummyCP()
-    cufft = None
-
-
-@dataclass
-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):
-        """验证谱数据维度一致性"""
-        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("所有谱分量必须具有相同的维度")
-
-    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)
-
-        # 动量宽度
-        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:
-        """
-        将坐标场转换为张量表示
-
-        张量结构: [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"坐标场维度 ({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]
-                # 原点位置 (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 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)
-
-        # 分离各分量
-        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,
-            momentum_grid=(kx, ky),
-            hbar=self.hbar
-        )
-
-    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]
-                )
-                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
-
-    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
-        )
-
-        # 动量梯度（量子联络的近似）
-        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):
-            for j in range(self.nx):
-                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)|²
-
-        物理意义：动量空间的能量分布
-        """
-        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)
-
-        # 径向分箱
-        k_max = np.max(k_mag)
-        k_bins = np.linspace(0, k_max, 50)
-        radial_avg = np.zeros_like(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(spectral_density[mask])
-
-        return k_bins, radial_avg
-
-    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 = GPUQuantumFrameTransformer(grid_size, hbar)
-    else:
-        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]
-
-    if use_gpu and GPU_AVAILABLE:
-        transformer = GPUQuantumFrameTransformer(grid_size, spectrum.hbar)
-    else:
-        transformer = QuantumFrameTransformer(grid_size, spectrum.hbar)
-
-    return transformer.inverse_quantum_transform(spectrum)
-
-
-def compute_quantum_spectral_density(spectrum: QuantumFrameSpectrum) -> np.ndarray:
-    """
-    计算量子谱密度
+Author: Quantum Frame Theory
+Date: 2025-12-03
+"""
 
-    Args:
-        spectrum: 量子标架谱
+import warnings
 
-    Returns:
-        谱密度数组
-    """
-    analyzer = QuantumSpectralAnalyzer()
-    return analyzer.compute_spectral_density(spectrum)
+# 发出弃用警告
+warnings.warn(
+    "fourier_spectral 模块已合并到 qframes.py 中。"
+    "请直接使用: from coordinate_system.qframes import ...",
+    DeprecationWarning,
+    stacklevel=2
+)
 
+# 从 qframes 重导出所有内容
+from .qframes import (
+    # 核心类
+    QFrame,
+    QuantumState,
+    PathIntegral,
+    QFrameSpectrum,
 
-def compute_radial_spectrum(spectrum: QuantumFrameSpectrum) -> Tuple[np.ndarray, np.ndarray]:
-    """
-    计算径向谱（Quantum ShapeDNA）
+    # 便利函数
+    spectral_transform,
+    inverse_spectral_transform,
 
-    Args:
-        spectrum: 量子标架谱
+    # 常数
+    HBAR,
+    GPU_AVAILABLE,
+)
 
-    Returns:
-        (k_bins, radial_avg): 动量大小与谱密度
-    """
-    analyzer = QuantumSpectralAnalyzer()
-    return analyzer.radial_spectrum_average(spectrum)
+# 向后兼容别名
+QuantumFrameSpectrum = QFrameSpectrum
+QuantumFrameTransformer = QFrame  # QFrame 现在包含变换方法
 
 
-def verify_quantum_unitarity(coord_field: List[List[coord3]],
-                             grid_size: Tuple[int, int] = (64, 64)) -> Dict[str, float]:
+def quantum_frame_transform(coord_field, grid_size=None, use_gpu=False, hbar=HBAR):
     """
-    验证量子标架变换的幺正性
-
-    Args:
-        coord_field: 坐标场
-        grid_size: 网格尺寸
-
-    Returns:
-        验证结果字典
+    向后兼容函数 - 已整合到 QFrame.from_coord_field()
     """
-    transformer = QuantumFrameTransformer(grid_size)
-    return transformer.verify_unitarity(coord_field)
-
+    warnings.warn(
+        "quantum_frame_transform() 已弃用，请使用 QFrame.from_coord_field()",
+        DeprecationWarning,
+        stacklevel=2
+    )
+    return QFrame.from_coord_field(coord_field, hbar)
 
-# ========== 高级量子几何分析 ==========
 
-def compute_quantum_curvature_field(spectrum: QuantumFrameSpectrum) -> np.ndarray:
+def inverse_quantum_transform(spectrum, use_gpu=False):
     """
-    计算量子曲率场 R = [A_x, A_y]
-
-    Args:
-        spectrum: 量子标架谱
-
-    Returns:
-        曲率场
+    向后兼容函数 - 已整合到 QFrameSpectrum.to_coord_field()
     """
-    grid_size = spectrum.ux_spectrum.shape[:2]
-    transformer = QuantumFrameTransformer(grid_size, spectrum.hbar)
-    return transformer.compute_quantum_curvature(spectrum)
+    warnings.warn(
+        "inverse_quantum_transform() 已弃用，请使用 spectrum.to_coord_field()",
+        DeprecationWarning,
+        stacklevel=2
+    )
+    return spectrum.to_coord_field()
 
 
-def compute_berry_phase(spectrum: QuantumFrameSpectrum,
-                       path_indices: List[Tuple[int, int]]) -> complex:
+def compute_quantum_spectral_density(spectrum):
     """
-    计算 Berry 相位
-
-    Args:
-        spectrum: 量子标架谱
-        path_indices: 动量空间闭合路径
-
-    Returns:
-        Berry 相位
+    向后兼容函数 - 已整合到 QFrameSpectrum.spectral_density()
     """
-    analyzer = QuantumSpectralAnalyzer()
-    return analyzer.compute_berry_phase(spectrum, path_indices)
+    warnings.warn(
+        "compute_quantum_spectral_density() 已弃用，请使用 spectrum.spectral_density()",
+        DeprecationWarning,
+        stacklevel=2
+    )
+    return spectrum.spectral_density()
 
 
-def compute_topological_invariants(spectrum: QuantumFrameSpectrum) -> Dict[str, Any]:
+def compute_radial_spectrum(spectrum):
     """
-    计算拓扑不变量
-
-    Args:
-        spectrum: 量子标架谱
-
-    Returns:
-        拓扑不变量字典（Chern 数等）
+    向后兼容函数 - 已整合到 QFrameSpectrum.radial_average()
     """
-    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
-    }
-
+    warnings.warn(
+        "compute_radial_spectrum() 已弃用，请使用 spectrum.radial_average()",
+        DeprecationWarning,
+        stacklevel=2
+    )
+    return spectrum.radial_average()
 
-# ========== 导出 ==========
 
+# 导出列表
 __all__ = [
     # 核心类
+    'QFrame',
+    'QuantumState',
+    'PathIntegral',
+    'QFrameSpectrum',
+
+    # 向后兼容别名
     'QuantumFrameSpectrum',
     'QuantumFrameTransformer',
-    'GPUQuantumFrameTransformer',
-    'QuantumSpectralAnalyzer',
 
-    # 基础函数
+    # 便利函数
+    'spectral_transform',
+    'inverse_spectral_transform',
+
+    # 向后兼容函数
     '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',
+    # 常数
+    'HBAR',
+    'GPU_AVAILABLE',
 ]