拓扑学深度指南

引言与拓扑学思想

从欧几里得到拓扑学

两千多年前，欧几里得几何学建立了点、线、面之间精确的度量关系：两点之间直线最短、三角形内角和等于180度、平行线永不相交。这些结论建立在距离和角度的精确测量之上，构成了古典几何学的核心。

然而，数学家们逐渐意识到：当我们放松对”精确”的执着追求，转而关注那些在连续变形下保持不变的性质时，会发现一个更加广阔、更加深刻的几何世界。这就是拓扑学——“橡皮几何学”或”连续几何学”。

拓扑学的基本思想

拓扑学（Topology） 研究的是空间在连续变形下的不变量。在拓扑学家眼中，一个咖啡杯和一个甜甜圈是”相同”的，因为它们都可以通过连续变形（不撕裂、不粘贴）变成彼此。这种等价关系称为同胚（Homeomorphism）。

拓扑学在人工智能中的地位

在人工智能和机器学习的语境下，拓扑学的重要性日益凸显：

深度学习的几何理解：神经网络的表达能力、泛化能力的拓扑分析
流形学习：高维数据的低维结构发现
拓扑数据分析（TDA）： Persistent Homology 在模式识别中的应用
图神经网络：拓扑图结构的深度学习
计算机视觉：拓扑性质在图像识别中的作用

理解拓扑学，为理解现代人工智能算法提供了高层次的数学视角。

集合论基础

集合的基本运算

定义与记号

集合（Set）：一堆对象的全体，记作 $A, B, X, Y$ 等
元素（Element）：属于集合的对象，记作 $a \in A$
空集（Empty Set）：不含任何元素的集合，记作 $\emptyset$

并集、交集、差集

并集： $A \cup B = {x : x \in A 或 x \in B}$
交集： $A \cap B = {x : x \in A 且 x \in B}$
差集： $A ∖ B = {x : x \in A 且 x \in / B}$

德摩根定律

$\overline{A \cup B} = \overline{A} \cap \overline{B}$ $\overline{A \cap B} = \overline{A} \cup \overline{B}$

其中 $\overline{A}$ 表示 $A$ 在全集中的补集。

笛卡尔积

$A \times B = {(a, b) : a \in A, b \in B}$

对于多个集合：

$A_{1} \times A_{2} \times \dots \times A_{n} = {(a_{1}, a_{2}, \dots, a_{n}) : a_{i} \in A_{i}}$

关系与函数

关系

$R$ 是 $A$ 到 $B$ 的关系，若 $R \subseteq A \times B$ 。

等价关系满足：

自反性： $(a, a) \in R$
对称性： $(a, b) \in R \Rightarrow (b, a) \in R$
传递性： $(a, b) \in R, (b, c) \in R \Rightarrow (a, c) \in R$

偏序关系满足：

自反性
反对称性： $(a, b) \in R, (b, a) \in R \Rightarrow a = b$
传递性

函数

$f : A \to B$ 是 $A$ 到 $B$ 的函数，若对每个 $a \in A$ ，恰好有一个 $b \in B$ 与之对应。

单射（Injective）： $f (a_{1}) = f (a_{2}) \Rightarrow a_{1} = a_{2}$ 满射（Surjective）： $\forall b \in B, \exists a \in A, f (a) = b$ 双射（Bijective）：既单射又满射

无限集与基数

可数与不可数

有限集：与 ${1, 2, \dots, n}$ 等势
可数无限集：与 $N$ 等势，如 $Q$
不可数集：如 $R$ ，其基数记作 $c$

重要结论： $R$ 与 $R^{n}$ 等势（通过 Cantor 的对角线论证）。

选择公理

对于任意非空集合族 ${X_{i}}_{i \in I}$ ，存在函数 $f : I \to ⋃_{i \in I} X_{i}$ 使得 $f (i) \in X_{i}$ 。

选择公理是现代数学的基础公理之一，许多深刻的结果都依赖于它。

度量空间与拓扑空间

度量空间的定义

度量（距离函数）

设 $X$ 是非空集合。函数 $d : X \times X \to R$ 称为度量，若满足：

非负性： $d (x, y) \geq 0$
同一性： $d (x, y) = 0 \Leftrightarrow x = y$
对称性： $d (x, y) = d (y, x)$
三角不等式： $d (x, z) \leq d (x, y) + d (y, z)$

则 $(X, d)$ 称为度量空间（Metric Space）。

常见度量

欧几里得度量（ $R^{n}$ ）：

$d_{2} (x, y) = \sum_{i = 1}^{n} (x_{i} - y_{i})^{2}$

曼哈顿度量：

$d_{1} (x, y) = \sum_{i = 1}^{n} ∣ x_{i} - y_{i} ∣$

切比雪夫度量（上确界度量）：

$d_{\infty} (x, y) = max_{1 \leq i \leq n} ∣ x_{i} - y_{i} ∣$

离散度量：

$d (x, y) = {01 x = y x \neq = y$

度量空间的例子

$R^{n}$ 与欧几里得度量： $(X, d_{2})$ 是最常见的度量空间
$[0, 1]$ 上的连续函数空间 $C [0, 1]$ ： $d (f, g) = max_{t \in [0, 1]} ∣ f (t) - g (t)∣$
$ℓ^{p}$ 空间： $ℓ^{p} = {(x_{n}) : \sum ∣ x_{n} ∣^{p} < \infty}$ ，度量 $d_{p} (x, y) = (\sum ∣ x_{n} - y_{n} ∣^{p})^{1/ p}$

拓扑空间的定义

拓扑

设 $X$ 是非空集合。 $X$ 上的拓扑（Topology） $τ$ 是满足以下条件的子集族：

空集与全集： $\emptyset \in τ, X \in τ$
任意并：若 $U_{i} \in τ$ （任意指标集），则 $⋃_{i} U_{i} \in τ$
有限交：若 $U_{1}, U_{2}, \dots, U_{n} \in τ$ ，则 $U_{1} \cap U_{2} \cap \dots \cap U_{n} \in τ$

则 $(X, τ)$ 称为拓扑空间（Topological Space）。

$τ$ 中的元素称为开集（Open Sets）。

度量诱导的拓扑

每个度量空间都有自然的度量拓扑：由所有开球 $B (x, ε) = {y : d (x, y) < ε}$ 生成的拓扑。

度量空间必是拓扑空间，但拓扑空间不一定是度量空间。

常见拓扑空间例子

离散拓扑： $τ = P (X)$ （所有子集都是开集）

平凡拓扑： $τ = {\emptyset, X}$

余有限拓扑： $R$ 上，开集为 $\emptyset$ 或余集有限的集合

余可数拓扑： $R$ 上，开集为 $\emptyset$ 或余集可数的集合

邻域与内部、闭包

邻域

$p$ 的邻域（Neighborhood） $N$ 是满足：存在开集 $U$ ， $p \in U \subseteq N$ 的集合。

开邻域：既是邻域又是开集

邻域系： $p$ 的所有邻域构成的族，记作 $N (p)$

内部与闭包

内部（Interior）： $A$ 的内部是包含在 $A$ 中的最大开集，记作 $int (A)$ 或 $A^{\circ}$

闭包（Closure）： $A$ 的闭包是包含 $A$ 的最小闭集，记作 $\overset{ˉ}{A}$ 或 $cl (A)$

性质：

$A$ 是闭集 $\Leftrightarrow A = \overset{ˉ}{A}$
$A$ 是开集 $\Leftrightarrow A = int (A)$
$int (A) \subseteq A \subseteq \overset{ˉ}{A}$

边界

边界（Boundary）： $\partial A = \overset{ˉ}{A} ∖ int (A)$

性质：

$\partial A$ 是闭集
$X = int (A) \cup \partial A$ （不交并）
$\partial A = \partial (X ∖ A)$

基与子基

基

$B$ 是拓扑 $τ$ 的基（Base），若：

$B \subseteq τ$
每个开集可以表示为基中元素的并

基的等价定义： $B$ 是 $X$ 上某个拓扑的基，当且仅当：

$⋃_{B \in B} B = X$
若 $B_{1}, B_{2} \in B$ ，则对每个 $x \in B_{1} \cap B_{2}$ ，存在 $B_{3} \in B$ ， $x \in B_{3} \subseteq B_{1} \cap B_{2}$

度量空间中的基：所有开球构成的族是度量拓扑的基。

子基

$S$ 是拓扑的子基（Subbase），若由 $S$ 中有限个元的交集生成的族是拓扑的基。

序列与收敛

序列收敛

在拓扑空间 $(X, τ)$ 中，序列 $(x_{n})$ 收敛到 $x$ ：

$lim_{n \to \infty} x_{n} = x \Leftrightarrow \forall U \in N (x), \exists N, \forall n > N, x_{n} \in U$

注意：在一般拓扑空间中，序列收敛不能完全刻画拓扑性质。

第一可数性

$X$ 在点 $x$ 处第一可数，若存在可数邻域基。

度量空间是第一可数的：每个点处有可数邻域基 ${B (x, 1/ n) : n \in N}$ 。

第二可数性

拓扑空间是第二可数的，若存在可数基。

重要性质：第二可数空间是可分的（存在稠密可数子集）。

拓扑的基本性质

开集与闭集

闭集的定义

$F$ 是闭集，若 $X ∖ F$ 是开集。

闭集的性质

有限并：闭集的有限并是闭集
任意交：闭集的任意交是闭集
空集与全集： $\emptyset$ 和 $X$ 既是开集又是闭集

闭包的刻画

$x \in \overset{ˉ}{A}$ 的等价条件：

$x$ 的每个邻域与 $A$ 相交
存在 $A$ 中的序列收敛到 $x$ （第一可数空间）

导集与孤立点

导集（Derived Set）： $A$ 的所有极限点构成的集合，记作 $A^{'}$

孤立点（Isolated Point）： $x \in A$ 是孤立点，若存在邻域 $U$ ， $U \cap A = {x}$

关系： $\overset{ˉ}{A} = A \cup A^{'}$

内点、极限点、边界点

极限点（聚点）

$x$ 是 $A$ 的极限点（Limit Point），若 $x$ 的每个邻域都包含 $A ∖ {x}$ 中的点。

注意： $x$ 本身可以在 $A$ 中，也可以不在。

闭集的等价刻画

以下条件等价：

$F$ 是闭集
$F$ 包含其所有极限点
$\overset{ˉ}{F} = F$

序列极限的唯一性

在Hausdorff 空间（见分离公理部分）中，序列极限唯一。

度量空间是 Hausdorff 空间。

外部空间

对于 $A \subseteq X$ ，外部（Exterior） 定义为：

$ext (A) = X ∖ \overset{ˉ}{A}$

性质：外部是开集（如果内部是开集）。

连续映射与同胚

连续性的定义

度量空间中的连续性

$f : (X, d_{X}) \to (Y, d_{Y})$ 在 $x$ 处连续：

$\forall ε > 0, \exists δ > 0, d_{X} (x, y) < δ \Rightarrow d_{Y} (f (x), f (y)) < ε$

拓扑空间中的连续性

$f : (X, τ_{X}) \to (Y, τ_{Y})$ 是**连续（Continuous）**的，若：

$V \in τ_{Y} \Rightarrow f^{- 1} (V) \in τ_{X}$

即开集的原像是开集。

这是拓扑学中连续性的标准定义，它不依赖于度量，只依赖于拓扑结构。

局部连续性

$f$ 在 $x$ 处连续，当且仅当对 $f (x)$ 的每个邻域 $V$ ，存在 $x$ 的邻域 $U$ ， $f (U) \subseteq V$ 。

连续映射的性质

复合保持连续性

连续函数的复合是连续的：

若 $f : X \to Y$ 连续， $g : Y \to Z$ 连续，则 $g \circ f : X \to Z$ 连续。

极限与连续

$f$ 在 $x$ 处连续 $\Leftrightarrow$ 对任何收敛于 $x$ 的序列 $(x_{n})$ ，有 $lim f (x_{n}) = f (x)$ （第一可数空间）。

同胚（Homeomorphism）

定义

$f : X \to Y$ 是同胚，若：

$f$ 是双射
$f$ 连续
$f^{- 1}$ 连续

若存在同胚 $f : X \to Y$ ，则称 $X$ 与 $Y$ 同胚（Homeomorphic），记作 $X ≅ Y$ 。

同胚是拓扑学中的等价关系。

同胚的重要性

同胚保持所有拓扑性质。若 $X ≅ Y$ ：

$X$ 连通 $\Leftrightarrow$ $Y$ 连通
$X$ 紧致 $\Leftrightarrow$ $Y$ 紧致
$X$ 可分 $\Leftrightarrow$ $Y$ 可分

同胚的直观例子

咖啡杯与甜甜圈同胚（都有一个”洞”）
字母 I 与字母 T 不同胚
$R$ 与 $S^{1}$ 不同胚
$(0, 1)$ 与 $R$ 同胚（通过双射 $f (x) = tan (π x - π /2)$ ）

嵌入

定义

$i : X \to Y$ 是嵌入（Embedding），若 $i$ 是单射且 $i : X \to i (X)$ 是同胚（ $i (X)$ 赋予子空间拓扑）。

嵌入将 $X$ “放入” $Y$ 中，保持拓扑结构。

开映射与闭映射

开映射

$f : X \to Y$ 是开映射，若 $U$ 开 $\Rightarrow f (U)$ 开。

闭映射

$f : X \to Y$ 是闭映射，若 $F$ 闭 $\Rightarrow f (F)$ 闭。

注意：连续映射不一定是开映射或闭映射。

拓扑不变量

定义

拓扑不变量是在同胚下保持不变的性质。

常见拓扑不变量：

连通性
紧致性
分离性
可数性公理
基本群
同调群

证明不同胚

要证明 $X$ 与 $Y$ 不同胚，只需找一个拓扑不变量在两者中取值不同。

例子： $S^{1}$ 与 $[0, 1]$ 不同胚，因为 $S^{1}$ 连通，去掉一个点仍然连通；而 $[0, 1]$ 去掉一个点（内部点）就不连通了。

代码实现：验证同胚

import numpy as np
from scipy.spatial.distance import cdist
from scipy.optimize import minimize
from typing import Callable, Tuple
 
class TopologicalSpace:
    """拓扑空间的基类"""
    def __init__(self, name: str):
        self.name = name
    
    def __repr__(self):
        return f"TopologicalSpace({self.name})"
 
 
class MetricSpace(TopologicalSpace):
    """度量空间"""
    def __init__(self, points: np.ndarray, metric: str = 'euclidean'):
        super().__init__("MetricSpace")
        self.points = points
        self.n = len(points)
        self.metric = metric
        self._compute_distances()
    
    def _compute_distances(self):
        """计算距离矩阵"""
        self.distances = cdist(self.points, self.points, metric=self.metric)
    
    def diameter(self) -> float:
        """空间直径"""
        return np.max(self.distances)
    
    def radius(self, center: int = None) -> float:
        """空间半径（以某点为心）"""
        if center is None:
            center = np.argmin(np.max(self.distances, axis=1))
        return np.max(self.distances[center])
    
    def ball(self, center: int, radius: float) -> np.ndarray:
        """开球"""
        return np.where(self.distances[center] < radius)[0]
 
 
class TopologicalInvariants:
    """拓扑不变量计算"""
    
    @staticmethod
    def is_connected(points: np.ndarray, threshold: float = 0.1) -> bool:
        """
        检查点集的连通性（基于阈值图）
        
        使用 BFS/DFS 检查图连通性
        """
        n = len(points)
        distances = cdist(points, points)
        
        # 构建邻接矩阵
        adj = distances < threshold
        np.fill_diagonal(adj, False)
        
        # BFS 检查连通性
        visited = set()
        queue = [0]
        
        while queue:
            node = queue.pop(0)
            if node in visited:
                continue
            visited.add(node)
            neighbors = np.where(adj[node])[0]
            queue.extend([n for n in neighbors if n not in visited])
        
        return len(visited) == n
    
    @staticmethod
    def euler_characteristic(points: np.ndarray, edges: list) -> int:
        """
        计算欧拉示性数
        
        χ = V - E + F（对于平面图，F可以通过Euler公式计算）
        """
        V = len(points)
        E = len(edges)
        # 对于平面图：V - E + F = 2
        # 因此 F = 2 - V + E
        F = 2 - V + E
        return V - E + F
    
    @staticmethod
    def betti_numbers(points: np.ndarray, threshold: float, 
                     max_dim: int = 2) -> list:
        """
        计算 Betti 数（需要更复杂的同调计算，这里用简化版本）
        
        β₀: 连通分支数
        β₁: 洞的数量
        β₂: 空洞的数量
        """
        from scipy.spatial import Delaunay
        
        tri = Delaunay(points)
        n_simplices = len(tri.simplices)
        
        # 简化版本的连通分支估计
        connected_components = 1 if TopologicalInvariants.is_connected(
            points, threshold) else len(points)
        
        # Betti 数的近似
        betti_0 = max(1, connected_components)
        betti_1 = max(0, n_simplices - len(points) + 1)  # 简化的洞估计
        betti_2 = 0  # 简化
        
        return [betti_0, betti_1, betti_2]
 
 
class HomeomorphismChecker:
    """同胚检查工具"""
    
    @staticmethod
    def check_basic_invariants(space1: MetricSpace, 
                               space2: MetricSpace) -> dict:
        """检查基本拓扑不变量"""
        invariants = {
            'diameter_1': space1.diameter(),
            'diameter_2': space2.diameter(),
            'points_1': space1.n,
            'points_2': space2.n,
        }
        
        # 连通性
        invariants['connected_1'] = TopologicalInvariants.is_connected(
            space1.points)
        invariants['connected_2'] = TopologicalInvariants.is_connected(
            space2.points)
        
        return invariants
    
    @staticmethod
    def find_homeomorphism_mapping(space1: MetricSpace, 
                                    space2: MetricSpace,
                                    n_iterations: int = 100) -> Tuple:
        """
        尝试寻找同胚映射（如果存在的话）
        
        这是一个简化版本，只适用于简单的空间
        """
        if space1.n != space2.n:
            return None, float('inf')
        
        def objective(params):
            """最小化距离变形"""
            # params 是变换参数
            transformed = space1.points.copy()
            for i in range(len(transformed)):
                transformed[i] += params[i * 2:(i + 1) * 2]
            
            # 计算距离矩阵的差异
            dist1 = cdist(transformed, transformed).flatten()
            dist2 = space2.distances.flatten()
            
            return np.sum((dist1 - dist2) ** 2)
        
        # 初始猜测
        x0 = np.zeros(space1.n * 2)
        
        result = minimize(objective, x0, method='L-BFGS-B',
                         options={'maxiter': n_iterations})
        
        return result.x, result.fun
 
 
class PersistentHomology:
    """持续同调计算（简化版）"""
    
    def __init__(self, points: np.ndarray, max_edge_length: float = 1.0):
        self.points = points
        self.max_edge_length = max_edge_length
    
    def compute_vietoris_rips(self, epsilon: float) -> list:
        """
        计算 Vietoris-Rips 复形在给定阈值处的单纯复形
        
        Parameters:
        -----------
        epsilon : float
            距离阈值
            
        Returns:
        --------
        simplices : list
            复形中的单纯形列表
        """
        n = len(self.points)
        distances = cdist(self.points, self.points)
        
        # 0-单纯形（点）
        simplices = [(i,) for i in range(n)]
        
        # 1-单纯形（边）
        edges = []
        for i in range(n):
            for j in range(i + 1, n):
                if distances[i, j] <= epsilon:
                    edges.append((i, j))
        simplices.extend(edges)
        
        # 2-单纯形（三角形）- 简化版本
        triangles = []
        for i in range(n):
            for j in range(i + 1, n):
                for k in range(j + 1, n):
                    if (distances[i, j] <= epsilon and 
                        distances[j, k] <= epsilon and 
                        distances[i, k] <= epsilon):
                        triangles.append((i, j, k))
        simplices.extend(triangles)
        
        return simplices
    
    def compute_persistence(self) -> dict:
        """
        计算持续同调
        
        Returns:
        --------
        persistence : dict
            各维数的持续区间
        """
        epsilons = np.linspace(0, self.max_edge_length, 50)
        
        betti_curves = {0: [], 1: [], 2: []}
        
        for eps in epsilons:
            simplices = self.compute_vietoris_rips(eps)
            
            # 计算连通分支（简化）
            n_components = TopologicalInvariants.is_connected(
                self.points, eps)
            betti_curves[0].append(n_components)
            
            # 边数作为 β₁ 的估计
            n_edges = len([s for s in simplices if len(s) == 2])
            betti_curves[1].append(n_edges)
        
        return {
            'epsilons': epsilons,
            'betti_curves': betti_curves
        }
 
 
# 示例和测试
if __name__ == "__main__":
    # 创建简单的拓扑空间示例
    print("=== Topological Invariants Demo ===")
    
    # 示例1：圆周
    theta = np.linspace(0, 2 * np.pi, 20, endpoint=False)
    circle_points = np.column_stack([np.cos(theta), np.sin(theta)])
    circle_space = MetricSpace(circle_points)
    
    print(f"Circle: {circle_space.n} points, diameter = {circle_space.diameter():.4f}")
    print(f"Circle connected: {TopologicalInvariants.is_connected(circle_points)}")
    
    # 示例2：线段
    line_points = np.column_stack([np.linspace(-1, 1, 20), np.zeros(20)])
    line_space = MetricSpace(line_points)
    
    print(f"Line: {line_space.n} points, diameter = {line_space.diameter():.4f}")
    print(f"Line connected: {TopologicalInvariants.is_connected(line_points)}")
    
    # 示例3：两个分离的点簇
    cluster1 = np.random.randn(10, 2) + np.array([-2, 0])
    cluster2 = np.random.randn(10, 2) + np.array([2, 0])
    two_clusters = np.vstack([cluster1, cluster2])
    cluster_space = MetricSpace(two_clusters)
    
    print(f"Two clusters: {cluster_space.n} points")
    print(f"Two clusters connected: {TopologicalInvariants.is_connected(two_clusters, threshold=0.5)}")
    
    # 持续同调示例
    print("\n=== Persistent Homology Demo ===")
    points = circle_points + np.random.randn(20, 2) * 0.1
    ph = PersistentHomology(points, max_edge_length=2.0)
    persistence = ph.compute_persistence()
    
    print("Persistence computed successfully")
    print(f"Number of epsilon values: {len(persistence['epsilons'])}")

连通性与紧致性

连通性

连通空间的定义

$(X, τ)$ 是**连通（Connected）**的，若 $X$ 不能写成两个非空不相交开集的并。

等价表述：不存在非空的既开又闭的子集。

连通性的直观理解

连通空间是”一整块”的空间，不能被”切成两半”而不破坏连续性。

连通性的例子

连通的：

$R$
$[0, 1]$
区间（任意形式）
$R^{n}$

不连通的：

$Q$ （有理数在 $R$ 中不连通）
$(0, 1) \cup (2, 3)$
离散空间（多于一点时）

连通性的性质

连通性是拓扑不变量：同胚映射保持连通性
连通子集的并：若子集族有公共点，则并集连通
闭包的连通性：连通集的闭包是连通的
连续映射保持连通性：若 $f$ 连续， $X$ 连通，则 $f (X)$ 连通

路径连通

$(X, τ)$ 是**路径连通（Path Connected）**的，若对任意 $x, y \in X$ ，存在连续映射 $γ : [0, 1] \to X$ ，使得 $γ (0) = x$ ， $γ (1) = y$ 。

性质：

路径连通必连通
反之不一定成立

反例： $R^{2}$ 中的”梳子空间”是连通但非路径连通的。

局部连通

$(X, τ)$ 在 $x$ 处局部连通，若 $x$ 的邻域基由连通集组成。

整体局部连通：每个点处都局部连通。

分支与路径分支

连通分支（Component）：极大的连通子集

路径连通分支（Path Component）：极大的路径连通子集

性质：

连通分支是闭集
路径连通分支是既开又闭的
空间可以分解为不相交的连通分支

紧致性

开覆盖

${U_{i}}_{i \in I}$ 是 $X$ 的开覆盖，若 $⋃_{i \in I} U_{i} = X$ 。

子覆盖：从覆盖中选取的仍覆盖 $X$ 的子族。

紧致空间的定义

$(X, τ)$ 是**紧致（Compact）**的，若每个开覆盖都有有限子覆盖。

即：对任何 ${U_{i}}$ ，若 $⋃ U_{i} = X$ ，则存在有限子集 $J \subseteq I$ ，使得 $⋃_{i \in J} U_{i} = X$ 。

紧致性的直观理解

紧致空间是”有限”的空间，虽然可能无限，但它在拓扑意义上接近有限。

紧致性的例子

紧致的：

有限空间
闭区间 $[a, b]$
$S^{n}$ （球面）
Cantor 集

非紧致的：

$R$ （开覆盖 ${(- n, n) : n \in N}$ 无有限子覆盖）
$(0, 1)$
$Q$

紧致性的等价刻画

在度量空间中，以下条件等价：

$X$ 紧致
每个序列都有收敛子列（序列紧致）
$X$ 完全有界且完备（完备紧致）
每个无限子集都有极限点（极限点紧致）

紧致性的性质

闭集保持紧致性：紧致空间的闭子集是紧致的
紧致集在 Hausdorff 空间中闭：若 $X$ Hausdorff， $K \subseteq X$ 紧致，则 $K$ 闭
紧致性是拓扑不变量
连续映射保持紧致性：若 $f$ 连续， $X$ 紧致，则 $f (X)$ 紧致

紧致性的重要推论

海涅-博雷尔定理：在 $R^{n}$ 中，紧致 $\Leftrightarrow$ 有界且闭。

极值定理：若 $f : K \to R$ 连续， $K$ 紧致，则 $f$ 在 $K$ 上达到最大值和最小值。

有限交性质： $X$ 紧致 $\Leftrightarrow$ 闭集族的任意有限交若交为空，则整个族的交为空。

局部紧致

$X$ 是局部紧致的，若每点都有紧致邻域。

性质：局部紧致 Hausdorff 空间可以紧致化（单点紧致化）。

林德洛夫性质

$X$ 是**林德洛夫（Lindelöf）**的，若每个开覆盖都有可数子覆盖。

关系：

第二可数 $\Rightarrow$ 林德洛夫
紧致 $\Rightarrow$ 林德洛夫

Tychonoff 乘积定理

定理：紧空间的任意乘积（有限或无限）是紧致的。

这是拓扑学中最深刻的结果之一，展示了紧致性在无穷乘积下的稳定性。

分离公理

$T_{0}$ 空间（Kolmogorov 空间）

$X$ 是 $T_{0}$ 空间，若对任意不同点 $x \neq = y$ ，存在开集包含其中之一但不包含另一个。

目的：区分不同的点。

$T_{1}$ 空间（Frechet 空间）

$X$ 是 $T_{1}$ 空间，若对任意不同点 $x \neq = y$ ，存在开集 $U$ 使得 $x \in U$ 但 $y \in / U$ 。

等价刻画：单点集是闭集。

性质：在 $T_{1}$ 空间中，极限唯一（如果存在）。

$T_{2}$ 空间（Hausdorff 空间）

$X$ 是 $T_{2}$ 空间（Hausdorff），若对任意不同点 $x \neq = y$ ，存在不相交的开集 $U, V$ ， $x \in U, y \in V$ 。

性质：

$T_{2}$ 空间中的序列极限唯一
紧致集是闭集
$T_{2}$ + 局部紧致 $\Rightarrow$ 正则

$T_{3}$ 空间（正则 Hausdorff）

$X$ 是 $T_{3}$ 的，若 $X$ 是 $T_{1}$ 的且正则的。

$Y$ 是**正则（Regular）**的，若对任意闭集 $F$ 和点 $x \in / F$ ，存在不相交的开集 $U, V$ ， $x \in U, F \subseteq V$ 。

$T_{4}$ 空间（正规 Hausdorff）

$X$ 是 $T_{4}$ 的，若 $X$ 是 $T_{1}$ 的且正规的。

$Y$ 是**正规（Normal）**的，若对任意不相交闭集 $F, G$ ，存在不相交开集 $U, V$ ， $F \subseteq U, G \subseteq V$ 。

Urysohn 引理与 Tietze 扩张定理

Urysohn 引理

$X$ 正规 $\Leftrightarrow$ 对任意不相交闭集 $A, B$ ，存在连续函数 $f : X \to [0, 1]$ ，使得 $f (A) = {0}, f (B) = {1}$ 。

意义：正规空间可以用连续函数分离闭集。

Tietze 扩张定理

$X$ 正规 $\Leftrightarrow$ 对任意闭集 $A \subseteq X$ 和连续函数 $f : A \to [a, b]$ ，存在连续扩张 $F : X \to [a, b]$ ， $F ∣_{A} = f$ 。

意义：闭子集上的连续函数可以扩张到整个空间。

分离公理之间的关系

$T_{4} \Rightarrow T_{3} \Rightarrow T_{2} \Rightarrow T_{1} \Rightarrow T_{0}$

所有度量空间都是正规 Hausdorff 空间（ $T_{4}$ ）。

完全正则与 Tietze

$X$ 是**完全正则（Tychonoff）**的，若 $X$ 是 $T_{1}$ 的且完全正则的。

$Y$ 是完全正则的，若对任意闭集 $F$ 和点 $x \in / F$ ，存在连续函数 $f : Y \to [0, 1]$ ，使得 $f (x) = 0, f (F) = {1}$ 。

重要例子：紧 Hausdorff 空间必完全正则。

乘积空间与商空间

乘积拓扑

有限乘积

$X \times Y$ 上的乘积拓扑由投影 $π_{X} : X \times Y \to X$ 和 $π_{Y} : X \times Y \to Y$ 刻画。

基： ${U \times V : U \in τ_{X}, V \in τ_{Y}}$

任意乘积

${X_{i}}_{i \in I}$ 的乘积 $\prod_{i \in I} X_{i}$ 上的箱型拓扑以 ${U_{i}}$ 的积为基。

盒型拓扑在无限乘积时不满足良好的泛性质。

乘积拓扑（或 Tychonoff 拓扑）：

基： ${π_{i_{1}}^{- 1} (U_{i_{1}}) \cap \dots \cap π_{i_{n}}^{- 1} (U_{i_{n}}) : U_{i_{k}} \in τ_{X_{i_{k}}}}$
投影连续
是使投影连续的最粗拓扑

泛性质

乘积空间具有泛性质（万有性质）：

对任意空间 $Z$ 和连续映射族 $f_{i} : Z \to X_{i}$ ，存在唯一连续映射 $f : Z \to \prod X_{i}$ ，使得 $π_{i} \circ f = f_{i}$ 。

商拓扑

商空间的定义

设 $\sim$ 是 $X$ 上的等价关系。商集 $X / \sim$ 上的商拓扑定义为：

$U \subseteq X / \sim$ 是开集 $\Leftrightarrow π^{- 1} (U)$ 是 $X$ 中的开集

其中 $π : X \to X / \sim$ 是自然投影。

商空间的直观理解

商拓扑将 $X$ 中的某些点”粘合”在一起形成新的空间。

常见商空间例子

圆柱面： $[0, 1] \times [0, 1] / \sim$ ，其中 $(0, t) \sim (1, t)$

莫比乌斯带： $[0, 1] \times [0, 1] / \sim$ ，其中 $(0, t) \sim (1, 1 - t)$

环面： $S^{1} \times S^{1}$ （同构于 $R^{2} / Z^{2}$ ）

克莱因瓶： $R^{2}$ 中模去某个等价关系

投射平面：将圆盘的边界上对径点粘合

商映射

$p : X \to Y$ 是商映射，若 $p$ 连续且 $Y$ 具有商拓扑（即 $V$ 开 $\Leftrightarrow p^{- 1} (V)$ 开）。

满射开映射和满射闭映射都是商映射。

粘合引理

粘合引理（Collar Lemma）

设 $A$ 是 $X$ 的闭子空间， $f : A \to Y$ 连续，则 $Y \cup_{f} X$ （将 $A$ 中的点通过 $f$ 粘合到 $Y$ ）在商拓扑下是 Hausdorff 的，当且仅当 $f$ 是嵌入且 $f (A)$ 是 $Y$ 的闭子集。

闭粘合引理

设 $A$ 是 $X$ 的闭子空间， $Y$ 是 Hausdorff 的， $f : A \to Y$ 连续，则 $Y \cup_{f} X$ 是 Hausdorff 的。

曲面拓扑

闭曲面的分类定理

定理：每个紧致连通二维流形（同构于）以下两种之一：

球面 $S^{2}$ 的连通和（带 $g$ 个环柄）
球面 $S^{2}$ 的连通和（带 $n$ 个交叉帽）

前者称为** orientable**（可定向）曲面，亏格为 $g$ 后者称为** non-orientable**（不可定向）曲面，亏格为 $n$

欧拉示性数：

orientable: $χ = 2 - 2 g$
non-orientable: $χ = 2 - n$

例子

$S^{2}$ ： $χ = 2$ （球面）
$T^{2}$ ： $χ = 0$ （环面， $g = 1$ ）
射影平面： $χ = 1$ （ $n = 1$ ，不可定向）
Klein 瓶： $χ = 0$ （ $n = 2$ ，不可定向）

基本群理论

道路与同伦

道路

从 $x_{0}$ 到 $x_{1}$ 的道路是连续映射 $γ : [0, 1] \to X$ ，满足 $γ (0) = x_{0}$ ， $γ (1) = x_{1}$ 。

同伦

两条道路 $γ_{0}, γ_{1}$ 是**同伦（Homotopic）**的，记作 $γ_{0} ≃ γ_{1}$ ，若存在连续映射 $H : [0, 1] \times [0, 1] \to X$ ，使得：

$H (s, 0) = γ_{0} (s)$
$H (s, 1) = γ_{1} (s)$
$H (0, t) = x_{0}$ （固定起点）
$H (1, t) = x_{1}$ （固定终点）

$H$ 称为同伦。

道路类的概念

起点终点相同的道路同伦关系是一个等价关系。

等价类称为道路类。

基本群的定义

乘法

$[α]$ 和 $[β]$ 是道路类， $α (1) = β (0)$ ，定义：

$[α] \cdot [β] = [α \cdot β]$

其中 $α \cdot β$ 是拼接道路：

$(α \cdot β) (t) = {α (2 t) β (2 t - 1) 0 \leq t \leq 1/2 1/2 \leq t \leq 1$

单位元

常值道路 $[e_{x_{0}}]$ 是单位元。

逆元

$α$ 的逆道路 $α^{-}$ ：

$α^{-} (t) = α (1 - t)$

基本群

以 $x_{0}$ 为基点的基本群（Fundamental Group）：

$π_{1} (X, x_{0}) = {以 x_{0} 为基点的道路类}$

运算为道路类的乘法。

定理： $π_{1} (X, x_{0})$ 是群。

基本群的例子

$R^{n}$

$π_{1} (R^{n}, x_{0}) = {e}$ （平凡群）

因为 $R^{n}$ 是单连通的。

$S^{1}$

$π_{1} (S^{1}, 1) ≅ Z$

直觉：圆周上的道路绕圈数决定其类。

同伦类： $S^{1}$ 上的道路可以顺时针或逆时针绕任意整数圈。

更高维球面

$S^{n}$ 的基本群：

$n \geq 2$ 时， $π_{1} (S^{n}) = {e}$ （单连通）

这说明高维球面与低维流形有本质区别。

环面 $T^{2}$

$π_{1} (T^{2}) ≅ Z \times Z$

基本群是 $Z^{2}$ ，由两个生成元（水平和竖直方向的圈）生成。

覆叠空间简介

覆叠空间的定义

$p : \tilde{X} \to X$ 是覆叠空间，若对每个 $x \in X$ ，存在开邻域 $U$ ，使得 $p^{- 1} (U)$ 是 $\tilde{X}$ 中一些开集的并，且每个开集在 $p$ 下的像是 $U$ （同胚）。

$U$ 称为等变开集。

万有覆叠空间

$\tilde{X}$ 是 $X$ 的万有覆叠空间，若 $\tilde{X}$ 单连通。

重要例子：

$R$ 是 $S^{1}$ 的万有覆叠空间
$S^{2}$ 是射影平面的万有覆叠空间

基本群与覆叠空间

覆叠变换群与基本群有深层联系。

对于覆叠空间 $p : \tilde{X} \to X$ ， $p_{*} (π_{1} (\tilde{X}, \tilde{x}_{0}))$ 是 $π_{1} (X, x_{0})$ 的子群。

不同的子群对应不同的覆叠空间。

同伦的类型

同伦等价

$f : X \to Y$ 是同伦等价，若存在 $g : Y \to X$ ，使得 $g \circ f ≃ id_{X}$ 且 $f \circ g ≃ id_{Y}$ 。

记作 $X ≃ Y$ 。

同伦等价比同胚弱：同伦等价的拓扑空间可能有不同的基本群。

例子

实心球与单点： $D^{n} ≃ {pt}$
$R^{2} ∖ {0} ≃ S^{1}$ （同伦等价）
任何可缩空间与单点同伦等价

可缩空间

$X$ 是可缩的，若 $id_{X}$ 同伦于常值映射。

性质：可缩空间的基本群平凡。

例子： $R^{n}$ 、凸集、单形

拓扑学与神经网络

神经网络的拓扑分析

深度神经网络可以看作是从输入空间到输出空间的连续映射。

基本群可以用来分析神经网络的拓扑性质：

输入空间的”洞”如何影响输出空间
决策边界与拓扑障碍的关系

流形假设

机器学习中的流形假设：真实数据分布在高维空间中的低维流形上。

流形学习的目标：发现这个低维流形的拓扑结构。

覆叠空间理论

覆叠空间的基本理论

覆叠映射的性质

设 $p : \tilde{X} \to X$ 是覆叠映射：

局部同胚： $p$ 是局部同胚（局部双射 + 连续逆）
道路提升：给定 $\tilde{x}_{0}$ 和 $α : [0, 1] \to X$ ，存在唯一的提升 $\tilde{α} : [0, 1] \to \tilde{X}$ ， $\tilde{α} (0) = \tilde{x}_{0}$
同伦提升：同伦的道路可以提升为端点固定的道路同伦

覆叠空间与基本群的关系

定理：若 $p : \tilde{X} \to X$ 是覆叠映射， $\tilde{x}_{0} \in \tilde{X}$ ， $x_{0} = p (\tilde{x}_{0})$ ，则：

$p_{*} : π_{1} (\tilde{X}, \tilde{x}_{0}) \to π_{1} (X, x_{0})$

是单射，且 $p_{*} (π_{1} (\tilde{X}, \tilde{x}_{0}))$ 是 $π_{1} (X, x_{0})$ 的子群。

纤维 $p^{- 1} (x_{0})$ 与陪集空间 $π_{1} (X, x_{0}) / p_{*} (π_{1} (\tilde{X}, \tilde{x}_{0}))$ 等势。

万有覆叠空间

定义

$\tilde{X}$ 是 $X$ 的万有覆叠空间，若 $\tilde{X}$ 单连通。

万有覆叠空间的存在性

对于局部道路连通、半局部单连通的路径连通空间，万有覆叠空间存在。

注意：并非所有空间都有万有覆叠空间。

万有覆叠空间的泛性质

万有覆叠空间 $\tilde{X}$ 具有泛性质：

对任意覆叠空间 $p^{'} : \tilde{X}^{'} \to X$ 和映射 $\tilde{X} \to \tilde{X}^{'}$ （局部同胚），存在唯一映射 $f : \tilde{X} \to \tilde{X}^{'}$ ，使得 $p^{'} \circ f = p$ 。

群作用与商空间

覆盖变换群

万有覆叠空间 $\tilde{X}$ 的覆盖变换群（Deck Transformation Group）：

$Γ = {h : \tilde{X} \to \tilde{X} : h 是覆叠变换}$

性质： $Γ ≅ π_{1} (X, x_{0}) / p_{*} (π_{1} (\tilde{X}, \tilde{x}_{0}))$

对于万有覆叠， $p_{*} (π_{1} (\tilde{X})) = {e}$ ，因此 $Γ ≅ π_{1} (X)$ 。

商空间与覆叠

$X = \tilde{X} /Γ$ ，其中 $Γ$ 是覆盖变换群。

例子：

$S^{1} = R / Z$
$T^{2} = R^{2} / Z^{2}$
$S^{n} = R^{n + 1} ∖ {0} / R_{> 0}$

同调论初步

单纯复形

定义

单纯复形（Simplicial Complex） $K$ 是满足以下条件的单纯形的集合：

每个单纯形的面也是 $K$ 中的单纯形
若 $σ_{1}, σ_{2} \in K$ ，则 $σ_{1} \cap σ_{2}$ 是两者的面

单纯形： $n$ 维单形是 $n + 1$ 个仿射独立点的凸包

0-单形：点
1-单形：线段
2-单形：三角形
3-单形：四面体

多面体

$∣ K ∣$ 是 $K$ 中所有单形的并（欧几里得空间中的子集），赋予子空间拓扑。

多面体是某个有限或无穷单纯复形的几何实现。

链复形与同调群

有向单纯形

赋予单纯形一个定向（顺序），得到有向单纯形。

相同顶点不同定向的单纯形互为相反。

边缘算子

$n$ 维有向单形 $σ = [v_{0} v_{1} \dots v_{n}]$ 的边缘：

$\partial_{n} (σ) = \sum_{i = 0}^{n} (- 1)^{i} [v_{0} \dots \overset{v}{^}_{i} \dots v_{n}]$

其中 $\overset{v}{^}_{i}$ 表示去掉 $v_{i}$ 。

链群

$C_{n} (K)$ ： $K$ 中所有 $n$ 维有向单形生成的自由阿贝尔群。

边缘同态： $\partial_{n} : C_{n} (K) \to C_{n - 1} (K)$

边缘算子的性质

$\partial_{n - 1} \circ \partial_{n} = 0$

直观理解：高维单形的边缘的边缘是空集。

同调群

闭链群： $Z_{n} (K) = ker \partial_{n}$ （边缘为零的链）

边缘链群： $B_{n} (K) = im \partial_{n + 1}$ （是某高维链的边缘）

$n$ 维同调群：

$H_{n} (K) = Z_{n} (K) / B_{n} (K)$

几何意义：

$H_{0}$ ：连通分支数（独立分量）
$H_{1}$ ：“一维洞”（环）
$H_{2}$ ：“二维洞”（空洞）

欧拉示性数

定义

$χ (K) = \sum_{i = 0}^{n} (- 1)^{i} f_{i}$

其中 $f_{i}$ 是 $i$ 维单形的个数。

欧拉-庞加莱公式

$χ (K) = \sum_{i = 0}^{n} (- 1)^{i} rank H_{i} (K)$

应用：验证同调计算的正确性。

约化同调

定义

约化同调群：

$\tilde{H}_{n} (K) = Z_{n} (K) / B_{n} (K)$

其中 $B_{- 1} = {0}$ 。

关系：

$\tilde{H}_{0} (K) ≅ H_{0} (K) \oplus Z - Z （修正连通分支数）$

实际上，对于 $n > 0$ ， $\tilde{H}_{n} (K) ≅ H_{n} (K)$ 。

单纯逼近

单纯逼近定理

设 $f : ∣ K ∣ \to ∣ L ∣$ 连续，则存在充分细分 $K^{'}$ 和单纯映射 $g : K^{'} \to L$ ，使得 $g$ 同伦于 $f$ （限制在 $∣ K ∣$ 上）。

意义：连续映射可以用单纯映射逼近。

同调的性质

同调是同伦不变量：若 $∣ K ∣ ≃ ∣ L ∣$ ，则 $H_{n} (K) ≅ H_{n} (L)$
正合序列：切除定理、相对同调等产生正合序列
万有系数定理：将同调与上同调联系起来

拓扑学在人工智能中的应用

拓扑数据分析（TDA）

Persistent Homology

持续同调是拓扑数据分析的核心工具：

从数据点构建过滤（filtration）
计算各维数的同调群随过滤参数的变化
生成持续图（Persistence Diagram）或持续条码（Persistence Barcode）

持续图

在二维平面上标记出生-死亡点：

点 $(b, d)$ 表示某拓扑特征在 $b$ 时出生， $d$ 时死亡
离对角线越远的点越可能是真实拓扑信号

应用场景

药物发现：分子拓扑结构分析
材料科学：晶体结构分类
金融：市场数据的时间序列分析
计算机视觉：形状识别

流形学习

等距映射（Isomap）

构建数据点的邻域图
计算所有点对之间的测地距离（沿图的最短路径）
用 MDS（多维缩放）找到保持测地距离的低维嵌入

拓扑学视角：试图恢复数据的潜在流形结构。

t-SNE

保持局部邻域结构的概率嵌入。

数学基础：概率分布的比较（KL 散度）结合拓扑邻近性。

UMAP

基于黎曼几何和拓扑理论的降维方法。

核心思想：用模糊单形复形近似数据的拓扑结构。

图神经网络（GNN）

图的拓扑性质

节点度数：局部拓扑信息
连通分量：全局连通性
环结构：检测反馈回路
中心性：拓扑重要性度量

GNN 的理论基础

消息传递神经网络可以看作是在图拓扑上的信息扩散。

表达能力：Weisfeiler-Lehman 测试与图同构的关联。

神经网络的拓扑分析

决策边界

神经网络的决策边界是输入空间中的低维曲面。

拓扑分析：

边界如何分割输入空间
不同类别的流形如何相互嵌套

神经网络的可视化

UMAP/t-SNE 可视化：将神经网络层或激活的拓扑结构可视化。

代码实现：持续同调

import numpy as np
from scipy.spatial import Delaunay
from scipy.sparse import csr_matrix, lil_matrix
from scipy.sparse.linalg import eigsh
from typing import List, Tuple, Dict
import heapq
 
class SimplicialComplex:
    """单纯复形的表示"""
    
    def __init__(self):
        self.simplices = {0: set(), 1: set(), 2: set()}  # 0-单纯形（点）、1-单纯形（边）、2-单纯形（面）
        self.boundary_matrix = {}
    
    def add_simplex(self, simplex: Tuple, dim: int = None):
        """添加单纯形"""
        if dim is None:
            dim = len(simplex) - 1
        
        if dim not in self.simplices:
            self.simplices[dim] = set()
        
        self.simplices[dim].add(simplex)
    
    def compute_boundary_matrix(self, dim: int) -> csr_matrix:
        """计算边缘矩阵"""
        if dim not in self.simplices or dim - 1 not in self.simplices:
            return csr_matrix((0, 0))
        
        n_lower = len(self.simplices[dim - 1])
        n_curr = len(self.simplices[dim])
        
        # 映射索引
        lower_dict = {s: i for i, s in enumerate(self.simplices[dim - 1])}
        curr_dict = {s: i for i, s in enumerate(self.simplices[dim])}
        
        # 构建稀疏矩阵
        data, rows, cols = [], [], []
        
        for simplex in self.simplices[dim]:
            # 单纯形的边缘是其面
            for i in range(len(simplex)):
                face = simplex[:i] + simplex[i+1:]
                if face in lower_dict:
                    # 计算定向
                    sign = (-1) ** i
                    data.append(sign)
                    rows.append(curr_dict[simplex])
                    cols.append(lower_dict[face])
        
        return csr_matrix((data, (rows, cols)), 
                          shape=(n_curr, n_lower))
    
    def betti_numbers(self, max_dim: int = 2) -> List[int]:
        """计算 Betti 数"""
        betti = []
        
        for dim in range(max_dim + 1):
            if dim not in self.simplices:
                betti.append(0)
                continue
            
            # 计算边缘矩阵的秩和零空间维数
            if dim in self.boundary_matrix:
                B = self.boundary_matrix[dim]
                rank_B = np.linalg.matrix_rank(B.toarray())
            else:
                rank_B = 0
            
            if dim + 1 in self.boundary_matrix:
                B_next = self.boundary_matrix[dim + 1]
                rank_B_next = np.linalg.matrix_rank(B_next.toarray())
            else:
                rank_B_next = 0
            
            n_simplices = len(self.simplices[dim])
            beta = n_simplices - rank_B - rank_B_next
            betti.append(max(0, beta))
        
        return betti
 
 
class VietorisRipsFiltration:
    """Vietoris-Rips 过滤"""
    
    def __init__(self, points: np.ndarray, max_dimension: int = 2):
        self.points = points
        self.n = len(points)
        self.max_dimension = max_dimension
        self.distances = None
        self._compute_distances()
    
    def _compute_distances(self):
        """计算点对距离"""
        self.distances = np.zeros((self.n, self.n))
        for i in range(self.n):
            self.distances[i, j] = np.linalg.norm(self.points[i] - self.points[j])
    
    def build_filtration(self, n_steps: int = 100) -> List[Dict]:
        """
        构建过滤
        
        Returns:
        --------
        filtration : list
            每个阈值处的复形信息
        """
        # 获取所有唯一距离值
        epsilons = np.unique(self.distances[np.triu_indices(self.n, k=1)])
        epsilons = np.linspace(epsilons.min(), epsilons.max(), n_steps)
        
        filtration = []
        
        for eps in epsilons:
            complex_info = {
                'epsilon': eps,
                'vertices': list(range(self.n)),
                'edges': [],
                'triangles': []
            }
            
            # 边
            edges = set()
            for i in range(self.n):
                for j in range(i + 1, self.n):
                    if self.distances[i, j] <= eps:
                        edges.add((i, j))
            complex_info['edges'] = list(edges)
            
            # 三角形
            if self.max_dimension >= 2:
                triangles = set()
                edges_list = list(edges)
                edge_dict = {frozenset(e): True for e in edges}
                
                for i in range(self.n):
                    for j in range(i + 1, self.n):
                        for k in range(j + 1, self.n):
                            if (frozenset({i, j}) in edge_dict and
                                frozenset({j, k}) in edge_dict and
                                frozenset({i, k}) in edge_dict):
                                if (self.distances[i, j] <= eps and
                                    self.distances[j, k] <= eps and
                                    self.distances[i, k] <= eps):
                                    triangles.add((i, j, k))
                complex_info['triangles'] = list(triangles)
            
            filtration.append(complex_info)
        
        return filtration
 
 
class PersistentHomologyCalculator:
    """持续同调计算"""
    
    def __init__(self, points: np.ndarray):
        self.points = points
        self.n = len(points)
        self.distances = self._compute_distances()
    
    def _compute_distances(self) -> np.ndarray:
        """计算距离矩阵"""
        distances = np.zeros((self.n, self.n))
        for i in range(self.n):
            for j in range(i + 1, self.n):
                d = np.linalg.norm(self.points[i] - self.points[j])
                distances[i, j] = d
                distances[j, i] = d
        return distances
    
    def compute_persistence_diagram(self, homology_dim: int = 1, 
                                   max_eps: float = None) -> List[Tuple]:
        """
        计算持续图
        
        Parameters:
        -----------
        homology_dim : int
            同调维数（1 = 环，2 = 空洞）
        max_eps : float
            最大过滤值
            
        Returns:
        --------
        pairs : list of (birth, death) tuples
            持续对
        """
        if max_eps is None:
            max_eps = self.distances.max()
        
        # 获取所有边及权重
        edges = []
        for i in range(self.n):
            for j in range(i + 1, self.n):
                edges.append((self.distances[i, j], i, j))
        
        edges.sort()
        
        # Union-Find 数据结构
        parent = list(range(self.n))
        rank = [0] * self.n
        
        def find(x):
            if parent[x] != x:
                parent[x] = find(parent[x])
            return parent[x]
        
        def union(x, y):
            px, py = find(x), find(y)
            if px == py:
                return False
            if rank[px] < rank[py]:
                px, py = py, px
            parent[py] = px
            if rank[px] == rank[py]:
                rank[px] += 1
            return True
        
        # 存储环
        cycles = {i: {i} for i in range(self.n)}
        
        # 存储持续对
        pairs = []
        
        for eps, i, j in edges:
            if eps > max_eps:
                break
            
            if union(i, j):
                # 合并连通分支，不产生拓扑特征
                pass
            else:
                # 形成环
                if homology_dim == 1:
                    # H₁: 1维同调（环）
                    birth = eps
                    death = eps  # 在这个简化版本中，环在形成时"死亡"
                    pairs.append((birth, death))
        
        return pairs
    
    def compute_persistent_betti(self, n_steps: int = 100) -> Dict:
        """
        计算持续 Betti 曲线
        
        Returns:
        --------
        betti_curves : dict
            各维数的 Betti 数随过滤参数变化的曲线
        """
        epsilons = np.linspace(0, self.distances.max(), n_steps)
        
        betti_0 = []  # 连通分支
        betti_1 = []  # 环
        
        # Union-Find
        parent = list(range(self.n))
        rank = [0] * self.n
        
        def find(x):
            if parent[x] != x:
                parent[x] = find(parent[x])
            return parent[x]
        
        def union(x, y):
            px, py = find(x), find(y)
            if px == py:
                return False
            if rank[px] < rank[py]:
                px, py = py, px
            parent[py] = px
            if rank[px] == rank[py]:
                rank[px] += 1
            return True
        
        # 边排序
        edges = []
        for i in range(self.n):
            for j in range(i + 1, self.n):
                edges.append((self.distances[i, j], i, j))
        edges.sort()
        edge_idx = 0
        
        n_components = self.n
        n_cycles = 0
        
        for eps in epsilons:
            # 添加满足条件的边
            while edge_idx < len(edges) and edges[edge_idx][0] <= eps:
                _, i, j = edges[edge_idx]
                if union(i, j):
                    n_components -= 1
                else:
                    n_cycles += 1
                edge_idx += 1
            
            betti_0.append(n_components)
            betti_1.append(n_cycles)
        
        return {
            'epsilons': epsilons,
            'betti_0': betti_0,
            'betti_1': betti_1
        }
 
 
class TopologicalFeatureExtractor:
    """拓扑特征提取器"""
    
    @staticmethod
    def extract_persistent_features(points: np.ndarray, 
                                   n_bins: int = 20) -> np.ndarray:
        """
        从持续图中提取特征
        
        Parameters:
        -----------
        points : np.ndarray
            数据点
        n_bins : int
            特征直方图的箱数
            
        Returns:
        --------
        features : np.ndarray
            提取的拓扑特征
        """
        ph_calc = PersistentHomologyCalculator(points)
        persistence = ph_calc.compute_persistent_betti(n_steps=50)
        
        features = []
        
        # 持续 Betti 曲线
        features.extend(persistence['betti_0'][:n_bins])
        features.extend(persistence['betti_1'][:n_bins])
        
        # 计算持续图的统计量
        diagram = ph_calc.compute_persistence_diagram(homology_dim=1)
        if diagram:
            lifetimes = [d - b for b, d in diagram]
            features.append(np.mean(lifetimes) if lifetimes else 0)
            features.append(np.max(lifetimes) if lifetimes else 0)
            features.append(np.sum(lifetimes) if lifetimes else 0)
        
        return np.array(features)
 
 
# 示例和测试
if __name__ == "__main__":
    print("=== Topological Data Analysis Demo ===")
    
    # 示例1：圆周
    n_points = 100
    theta = np.linspace(0, 2 * np.pi, n_points, endpoint=False)
    circle_points = np.column_stack([np.cos(theta), np.sin(theta)])
    
    print(f"Testing on circle with {n_points} points...")
    ph = PersistentHomologyCalculator(circle_points)
    persistence = ph.compute_persistent_betti(n_steps=50)
    
    print(f"Initial Betti-0: {persistence['betti_0'][0]}")
    print(f"Initial Betti-1: {persistence['betti_1'][0]}")
    print(f"Final Betti-0: {persistence['betti_0'][-1]}")
    print(f"Final Betti-1: {persistence['betti_1'][-1]}")
    
    # 示例2：两个分离的簇
    cluster1 = np.random.randn(30, 2)
    cluster2 = np.random.randn(30, 2) + np.array([5, 5])
    two_clusters = np.vstack([cluster1, cluster2])
    
    print(f"\nTesting on two clusters with {len(two_clusters)} points...")
    ph2 = PersistentHomologyCalculator(two_clusters)
    persistence2 = ph2.compute_persistent_betti(n_steps=50)
    
    print(f"Initial Betti-0: {persistence2['betti_0'][0]}")
    print(f"Final Betti-0: {persistence2['betti_0'][-1]}")
    print(f"Final Betti-1: {persistence2['betti_1'][-1]}")
    
    # 示例3：提取拓扑特征
    print("\n=== Topological Feature Extraction ===")
    features = TopologicalFeatureExtractor.extract_persistent_features(circle_points)
    print(f"Extracted {len(features)} topological features")
    print(f"First 5 features: {features[:5]}")

延伸阅读与参考文献

经典教材

《拓扑学》（Topology）- James Munkres
《代数拓扑》（Algebraic Topology）- Allen Hatcher
《基础拓扑学》（Basic Topology）- M.A. Armstrong
《点集拓扑》（Point Set Topology）- John L. Kelley
《流形与几何简介》（An Introduction to Manifolds）- Loring Tu

拓扑数据分析

《拓扑数据分析的计算持久同调》（Computational Topology for Data Analysis）- Tal Y. Berger, Herbert Edelsbrunner
《持久同调导论》（A Concise Course in Algebraic Topology）- J. Peter May

机器学习与拓扑

《深度学习中的几何与拓扑》（Geometry and Topology in Machine Learning）
论文：Zomorodian & Carlsson - “Computing Persistent Homology”
论文：Ghorshi, Ghrist, etc. - TDA 在机器学习中的应用系列

在线资源

nlab: ncatlab.org（范畴论与拓扑学百科）
Allen Hatcher’s Algebraic Topology（免费在线书籍）
MIT OpenCourseWare: Algebraic Topology

附录：补充专题

G. 范畴论视角下的拓扑

Top 范畴

对象：所有拓扑空间态射：连续映射

性质：

有积（乘积拓扑）和余积（不交并）
有终对象（单点空间）和始对象（空空间）

Top 中的极限与余极限

积：乘积空间 $\prod X_{i}$
余积：不交并 $∐ X_{i}$
等化子： ${(x, y) \in X \times X : f (x) = f (y)}$
余等化子：商空间 $X / \sim$

函子与自然变换

函子 $F : Top \to Set$ ：

基本群函子 $π_{1} : Top_{*} \to Grp$
同调函子 $H_{n} : Top \to Ab$

自然变换：拓扑不变量之间的映射

H. 拓扑量子场论简介

拓扑不变量在物理中的应用

陈数（Chern number）：量子霍尔效应的拓扑不变量
贝里曲率（Berry curvature）：拓扑相的数学描述
拓扑绝缘体：由拓扑不变量分类

量子计算中的拓扑

拓扑量子比特：受拓扑保护的量子信息存储
辫子群（Braid group）：任意子统计的数学描述

I. 计算拓扑学

欧拉特征数的计算

def euler_characteristic(vertices, edges, faces):
    """计算欧拉特征数"""
    return len(vertices) - len(edges) + len(faces)
 
def betti_from_triangulation(triangles):
    """从三角剖分计算Betti数"""
    # 创建边集合
    edges = set()
    for tri in triangles:
        for i in range(3):
            edges.add(frozenset([tri[i], tri[(i+1)%3]]))
    
    # 简化估计 Betti 数
    v = len(set(v for t in triangles for v in t))
    e = len(edges)
    f = len(triangles)
    
    chi = v - e + f
    
    # 对于连通曲面: chi = 2 - 2g (orientable) 或 chi = 2 - n
    return chi

持续同调的计算复杂性

单纯复形的大小可能指数增长
实际算法使用稀疏技术和增量构建
Vietoris-Rips 复形的计算复杂度分析

J. 拓扑优化

拓扑优化在工程中的应用

结构力学中的拓扑优化
最小化柔顺性设计
应力均匀化

数学模型

目标函数： $min \int_{Ω} f (u) d x$ 约束： $\int_{Ω} u d x = V$ （体积约束）

K. 拓扑机器学习的前沿

图神经网络的表达能力

** Weisfeiler-Lehman 测试**是图同构的近似判定算法：

聚合邻居节点的标签
哈希聚合结果
迭代直到稳定

定理：GNN 的表达能力不超过 1-WL 测试。

拓扑图神经网络

拓扑感知的注意力机制
持续同调增强的特征
高阶消息传递

L. 拓扑数据分析的算法

简化复形的构建

class AlphaComplex:
    """
    Alpha Complex 实现
    
    是 Rips 复形的子复形，计算更高效
    """
    def __init__(self, points):
        self.points = points
        self.n = len(points)
        self.delaunay = None
    
    def compute_complex(self, max_radius):
        """
        计算 alpha 复形
        
        Parameters:
        -----------
        max_radius : float
            最大过滤半径
        """
        from scipy.spatial import Delaunay
        
        tri = Delaunay(self.points)
        
        simplices = {
            'vertices': [(i,) for i in range(self.n)],
            'edges': [],
            'triangles': [],
            'tetrahedra': []
        }
        
        for simplex in tri.simplices:
            if len(simplex) == 2:
                simplices['edges'].append(tuple(simplex))
            elif len(simplex) == 3:
                simplices['triangles'].append(tuple(simplex))
            elif len(simplex) == 4:
                simplices['tetrahedra'].append(tuple(simplex))
        
        return simplices

附录：经典问题与解答

问题精选

问题1：证明 $R^{2}$ 与 $R$ 等势（等基数）

解答：使用 Cantor-Bernstein-Schroeder 定理或显式构造双射。

问题2：构造一个非度量拓扑空间

解答：余有限拓扑：开集为空集或余集有限的集合。

问题3：证明 $S^{1}$ 与 $[0, 1]$ 不同胚

解答： $S^{1}$ 去掉一点仍连通， $[0, 1]$ 去掉内点不连通。连通性是拓扑不变量。

思考题

流形的基本群： $S^{1} \lor S^{1}$ （两个圆周在一点粘合）的基本群是什么？
- 答案：自由群 $F_{2}$
Klein 瓶的可定向性：为什么 Klein 瓶不可定向？
- 提示：考虑 Möbius 带的性质
覆叠空间的唯一性：给定基空间和子群，基本群的子群对应唯一的覆叠空间吗？
- 答案：在适当条件下是

符号表

符号	含义
$X ≅ Y$	$X$ 与 $Y$ 同胚
$X ≃ Y$	$X$ 与 $Y$ 同伦等价
$π_{1} (X, x_{0})$	$X$ 在 $x_{0}$ 处的基本群
$H_{n} (X)$	$X$ 的 $n$ 维同调群
$χ (X)$	欧拉示性数
$β_{n}$	$n$ 维 Betti 数
$\partial$	边缘算子
$\overset{ˉ}{A}$	$A$ 的闭包
$A^{\circ}$	$A$ 的内部

名词索引

同胚：第3章
同伦：第7章
基本群：第7章
覆叠空间：第8章
同调群：第9章
紧致性：第5章
连通性：第5章
分离公理：第6章

参考网站与数据库

数据库
- OEIS（整数数列在线百科）
- MathWorld
- arXiv（数学预印本）
软件工具
- GUDHI：拓扑数据分析库
- Dionysus：持续同调库
- SnapPy：三维流形工具
在线课程
- MIT OpenCourseWare: Algebraic Topology
- Coursera: Topology in Medicine

人工智能知识库

探索

拓扑学深度指南

拓扑学深度指南

目录

引言与拓扑学思想

从欧几里得到拓扑学

拓扑学的基本思想

拓扑学在人工智能中的地位

集合论基础

集合的基本运算

定义与记号

并集、交集、差集

德摩根定律

笛卡尔积

关系与函数

关系

函数

无限集与基数

可数与不可数

选择公理

度量空间与拓扑空间

度量空间的定义

度量（距离函数）

常见度量

度量空间的例子

拓扑空间的定义

拓扑

度量诱导的拓扑

常见拓扑空间例子

邻域与内部、闭包

邻域

内部与闭包

边界

基与子基

基

子基

序列与收敛

序列收敛

第一可数性

第二可数性

拓扑的基本性质

开集与闭集

闭集的定义

闭集的性质

闭包的刻画

导集与孤立点

内点、极限点、边界点

极限点（聚点）

闭集的等价刻画

序列极限的唯一性

外部空间

连续映射与同胚

连续性的定义

度量空间中的连续性

拓扑空间中的连续性

局部连续性

连续映射的性质

复合保持连续性

极限与连续

同胚（Homeomorphism）

定义

同胚的重要性

同胚的直观例子

嵌入

定义

开映射与闭映射

开映射

闭映射

拓扑不变量

定义

证明不同胚

代码实现：验证同胚

连通性与紧致性

连通性

连通空间的定义

连通性的直观理解

连通性的例子

连通性的性质

路径连通

$T_{0}$ 空间（Kolmogorov 空间）

$T_{1}$ 空间（Frechet 空间）

$T_{2}$ 空间（Hausdorff 空间）

$T_{3}$ 空间（正则 Hausdorff）

$T_{4}$ 空间（正规 Hausdorff）

$R^{n}$

$S^{1}$

环面 $T^{2}$