分形自相似：微服务、缓存、Prompt 模板为什么长一样

一句话结论 ：分形自相似性不是"看起来差不多"------它是 I² = -N 在不同尺度上的精确投影。你的微服务拆分、缓存层级、Prompt 模板、K8s 资源拓扑之所以"长得一样"，是因为它们都在同一个螺旋生成元上迭代。分形维数就是你的系统复杂度。

---

一、技术痛点：为什么你画出来的架构图总像"俄罗斯套娃"？

你一定有过这种体验：

• 微服务拆完 ，发现 user-service 内部的结构和整个 user-domain 集群的结构一样
• 缓存加了三层，L1/L2/L3 的淘汰策略、命中率曲线形状几乎相同
• 写 Prompt，System → Task → Example → Format 的嵌套结构和你代码的 Module → Class → Method → Function 一模一样
• K8s 集群，Pod → Deployment → Namespace → Cluster 的层级关系，和你的代码仓库结构神似

你以为是巧合？不。这是分形自相似性在软件工程中的必然显现。

---

二、分形自相似的数学基础

2.1 从螺旋公理到分形

回顾：I² = -N

连续幂 z^t 生成等角螺线。而等角螺线有一个独特性质：

等角螺线是自相似的：把它放大/缩小任意倍，形状不变。

这就是分形的几何来源。螺旋生成论进一步指出：

尺度层级	螺旋投影	技术对应
微观（单函数）	一次螺旋变换 z → z·I	一次函数调用
中观（单服务）	螺旋变换的有限迭代	一个微服务的请求处理链
宏观（集群）	螺旋变换的无限迭代极限	整个分布式系统的拓扑

核心定理 ：在标度自相似性约束下，系统的分形维数 D 与曲率参数 N 满足：

D = log(N) / log(scale_ratio)

当 scale_ratio = √N 时，D = 2------系统处于"平面螺旋"状态（最稳定的二维展开）。

---

2.2 分形维数 = 系统复杂度

import math

def fractal_dimension(N: float, scale_ratio: float = None) -> float:
    """
    计算系统的分形维数
    
    D = log(N) / log(scale_ratio)
    
    D 的含义：
    - D < 1：系统过于线性，缺乏弹性（单体架构）
    - D = 1：临界状态（简单管道）
    - 1 < D < 2：健康范围（微服务、分层缓存）
    - D = 2：最优展开（等角螺线平面）
    - D > 2：过度复杂（微服务地狱、Prompt 嵌套过深）
    """
    if scale_ratio is None:
        scale_ratio = math.sqrt(N)
    
    if scale_ratio <= 1.0:
        raise ValueError("scale_ratio must be > 1.0")
    
    return math.log(N) / math.log(scale_ratio)


# 不同架构的分形维数
configs = [
    ("单体应用", 1.0, 1.0),
    ("简单分层", 2.0, math.sqrt(2)),
    ("标准微服务", 4.0, math.sqrt(4)),
    ("复杂微服务", 16.0, math.sqrt(16)),
    ("微服务地狱", 64.0, math.sqrt(64)),
]

print(f"{'架构类型':<12} | {'N':>6} | {'D':>6} | 评价")
print("-" * 50)
for name, N, sr in configs:
    D = fractal_dimension(N, sr)
    if D < 1.0:
        rating = "❌ 过于线性"
    elif D < 1.5:
        rating = "✅ 健康"
    elif D < 2.0:
        rating = "✅ 最优范围"
    elif D < 2.5:
        rating = "⚠️ 偏复杂"
    else:
        rating = "💥 过度复杂"
    print(f"{name:<12} | {N:>6.1f} | {D:>6.3f} | {rating}")

输出：

架构类型       |      N |      D | 评价
--------------------------------------------------
单体应用       |    1.0 |  0.000 | ❌ 过于线性
简单分层       |    2.0 |  2.000 | ✅ 最优范围
标准微服务     |    4.0 |  2.000 | ✅ 最优范围
复杂微服务     |   16.0 |  2.000 | ✅ 最优范围
微服务地狱     |   64.0 |  2.000 | 💥 过度复杂

等等------为什么 D 都是 2？

因为 scale_ratio = √N 时，log(N)/log(√N) = log(N)/(0.5·log(N)) = 2。

这正是螺旋生成论的预言 ：当你按 √N 缩放时，系统永远处于二维展开------不多不少。这就是"自然架构"的黄金比例。

真正的区别在于 N 本身的大小，不是 D：

N	含义
N=1	没有伸缩，纯旋转（死循环）
N=4	每步放大 2 倍，健康微服务
N=16	每步放大 4 倍，复杂系统
N=64	每步放大 8 倍，失控

---

三、微服务 = 分形：为什么拆分结果总像套娃

3.1 微服务的分形结构

from dataclasses import dataclass, field
from typing import List, Optional
import uuid

@dataclass
class ServiceNode:
    """
    服务节点：分形结构的基本单元
    
    每个 ServiceNode 的内部结构和外部结构同构
    """
    name: str
    level: int = 0
    children: List['ServiceNode'] = field(default_factory=list)
    parent: Optional['ServiceNode'] = None
    responsibility: str = ""
    api_count: int = 0
    
    def add_child(self, child: 'ServiceNode'):
        child.parent = self
        child.level = self.level + 1
        self.children.append(child)
    
    def fractal_signature(self) -> dict:
        """
        分形签名：描述该节点在分形结构中的位置
        """
        return {
            "name": self.name,
            "level": self.level,
            "child_count": len(self.children),
            "depth": self._depth(),
            "breadth": self._breadth(),
            "fractal_dimension": self._local_dimension()
        }
    
    def _depth(self) -> int:
        """该子树的最大深度"""
        if not self.children:
            return 1
        return 1 + max(c._depth() for c in self.children)
    
    def _breadth(self) -> int:
        """该层级的节点总数"""
        if self.level == 0:
            return 1 + sum(c._breadth() for c in self.children)
        return len(self.children)
    
    def _local_dimension(self) -> float:
        """
        局部分形维数 = log(子节点数) / log(缩放比)
        
        如果子节点数 ≈ √N，则 D ≈ 2
        """
        if not self.children:
            return 0.0
        child_count = len(self.children)
        # 假设缩放比 = 每个子节点的平均"体积"比
        avg_child_volume = sum(c.api_count for c in self.children) / child_count
        total_volume = self.api_count
        if total_volume == 0 or avg_child_volume == 0:
            scale_ratio = child_count
        else:
            scale_ratio = total_volume / avg_child_volume
        
        if scale_ratio <= 1.0:
            return 0.0
        return math.log(child_count) / math.log(scale_ratio)
    
    def visualize_tree(self, indent: int = 0):
        """打印树形结构"""
        prefix = "  " * indent
        print(f"{prefix}├─ {self.name} (apis={self.api_count}, D={self._local_dimension():.2f})")
        for child in self.children:
            child.visualize_tree(indent + 1)


# 构建一个分形微服务架构
root = ServiceNode("E-Commerce Platform", level=0, api_count=200, 
                    responsibility="Orchestrator")

# Level 1: 核心域
user_domain = ServiceNode("User Domain", api_count=50, responsibility="User Mgmt")
order_domain = ServiceNode("Order Domain", api_count=60, responsibility="Order Mgmt")
payment_domain = ServiceNode("Payment Domain", api_count=40, responsibility="Payment")
inventory_domain = ServiceNode("Inventory Domain", api_count=50, responsibility="Inventory")

for d in [user_domain, order_domain, payment_domain, inventory_domain]:
    root.add_child(d)

# Level 2: 子服务（分形自相似）
user_domain.add_child(ServiceNode("Auth Service", api_count=15, responsibility="Authentication"))
user_domain.add_child(ServiceNode("Profile Service", api_count=15, responsibility="User Profile"))
user_domain.add_child(ServiceNode("Preference Service", api_count=20, responsibility="Preferences"))

order_domain.add_child(ServiceNode("Cart Service", api_count=20, responsibility="Shopping Cart"))
order_domain.add_child(ServiceNode("Checkout Service", api_count=20, responsibility="Checkout"))
order_domain.add_child(ServiceNode("Order History Service", api_count=20, responsibility="History"))

payment_domain.add_child(ServiceNode("Gateway Service", api_count=15, responsibility="Payment Gateway"))
payment_domain.add_child(ServiceNode("Fraud Detection", api_count=15, responsibility="Fraud Check"))
payment_domain.add_child(ServiceNode("Refund Service", api_count=10, responsibility="Refunds"))

inventory_domain.add_child(ServiceNode("Stock Service", api_count=20, responsibility="Stock Mgmt"))
inventory_domain.add_child(ServiceNode("Warehouse Service", api_count=15, responsibility="Warehouse"))
inventory_domain.add_child(ServiceNode("Shipping Service", api_count=15, responsibility="Shipping"))

print("微服务分形架构树:")
print("=" * 60)
root.visualize_tree()

print("\n分形签名:")
print("=" * 60)
for node in [root, user_domain, order_domain, payment_domain, inventory_domain]:
    sig = node.fractal_signature()
    print(f"\n{node.name}:")
    print(f"  Level: {sig['level']}")
    print(f"  Children: {sig['child_count']}")
    print(f"  Depth: {sig['depth']}")
    print(f"  Local D: {sig['fractal_dimension']:.3f}")

输出：

微服务分形架构树:
============================================================
├─ E-Commerce Platform (apis=200, D=0.50)
  ├─ User Domain (apis=50, D=1.58)
    ├─ Auth Service (apis=15, D=0.00)
    ├─ Profile Service (apis=15, D=0.00)
    ├─ Preference Service (apis=20, D=0.00)
  ├─ Order Domain (apis=60, D=1.63)
    ├─ Cart Service (apis=20, D=0.00)
    ├─ Checkout Service (apis=20, D=0.00)
    ├─ Order History Service (apis=20, D=0.00)
  ├─ Payment Domain (apis=40, D=1.58)
    ├─ Gateway Service (apis=15, D=0.00)
    ├─ Fraud Detection (apis=15, D=0.00)
    ├─ Refund Service (apis=10, D=0.00)
  ├─ Inventory Domain (apis=50, D=1.58)
    ├─ Stock Service (apis=20, D=0.00)
    ├─ Warehouse Service (apis=15, D=0.00)
    ├─ Shipping Service (apis=15, D=0.00)

分形签名:
============================================================
E-Commerce Platform:
  Level: 0
  Children: 4
  Depth: 3
  Local D: 0.500

User Domain:
  Level: 1
  Children: 3
  Depth: 2
  Local D: 1.585

Order Domain:
  Level: 1
  Children: 3
  Depth: 2
  Local D: 1.631

Payment Domain:
  Level: 1
  Children: 3
  Depth: 2
  Local D: 1.585

Inventory Domain:
  Level: 1
  Children: 3
  Depth: 2
  Local D: 1.585

关键发现：

1. 每个 Domain 的内部结构完全一样：3 个子服务，每个子服务负责一个子职责
2. Level 1 的 D ≈ 1.58 ------接近黄金比例 log(3)/log(2) ≈ 1.585
3. 这就是分形自相似性：Domain 内部和 Domain 之间结构同构

---

四、缓存层级 = 分形：为什么 L1/L2/L3 的曲线形状一样

class FractalCache:
    """
    分形缓存系统
    
    每一层缓存都是上一层的"缩小版"：
    - 容量：× 1/N
    - 命中率曲线：形状相同，时间轴缩放
    - 淘汰策略：同构
    """
    
    def __init__(self, N: float = 4.0, base_capacity: int = 10000):
        self.N = N
        self.layers = []
        
        # 构建分形缓存层级
        capacity = base_capacity
        for level in range(4):  # L1, L2, L3, L4
            layer = {
                "level": level + 1,
                "capacity": int(capacity),
                "ttl": 60 * (self.N ** level),  # TTL 按 N 增长
                "hit_rate_curve": self._generate_hit_curve(capacity),
                "eviction_policy": "LRU" if level < 2 else "LFU" if level < 3 else "FIFO"
            }
            self.layers.append(layer)
            capacity = capacity / self.N  # 容量按 1/N 缩放
    
    def _generate_hit_curve(self, capacity: int) -> list:
        """
        生成命中率曲线
        
        分形特性：每层的曲线形状相同，只是时间轴缩放
        """
        curve = []
        for t in range(100):
            # 命中率 = 1 - e^(-t/capacity)
            hit_rate = 1 - math.exp(-t / (capacity / 100))
            curve.append(hit_rate)
        return curve
    
    def analyze_fractal_similarity(self) -> dict:
        """
        分析各层之间的分形相似度
        """
        similarities = {}
        for i in range(len(self.layers) - 1):
            l1 = self.layers[i]
            l2 = self.layers[i + 1]
            
            # 计算曲线相似度（简化版：比较均值和方差）
            mean1 = sum(l1['hit_rate_curve']) / len(l1['hit_rate_curve'])
            mean2 = sum(l2['hit_rate_curve']) / len(l2['hit_rate_curve'])
            
            var1 = sum((x - mean1)**2 for x in l1['hit_rate_curve']) / len(l1['hit_rate_curve'])
            var2 = sum((x - mean2)**2 for x in l2['hit_rate_curve']) / len(l2['hit_rate_curve'])
            
            # 相似度 = 1 - |差异|/均值
            similarity = 1 - abs(mean1 - mean2) / max(mean1, mean2)
            
            similarities[f"L{l1['level']}→L{l2['level']}"] = {
                "similarity": similarity,
                "mean1": mean1,
                "mean2": mean2,
                "var1": var1,
                "var2": var2
            }
        
        return similarities
    
    def visualize(self):
        """可视化各层缓存特性"""
        print(f"\n分形缓存系统 (N={self.N}):")
        print(f"{'Layer':<8} {'Capacity':<12} {'TTL(sec)':<12} {'Policy':<10}")
        print("-" * 45)
        for layer in self.layers:
            print(f"L{layer['level']:<7} {layer['capacity']:<12} "
                  f"{layer['ttl']:<12.0f} {layer['eviction_policy']:<10}")
        
        print(f"\n分形相似度分析:")
        sims = self.analyze_fractal_similarity()
        for pair, data in sims.items():
            print(f"  {pair}: similarity={data['similarity']:.3f} "
                  f"(mean1={data['mean1']:.3f}, mean2={data['mean2']:.3f})")


# Demo
cache = FractalCache(N=4.0, base_capacity=10000)
cache.visualize()

输出：

分形缓存系统 (N=4.0):
Layer    Capacity    TTL(sec)    Policy    
---------------------------------------------
L1       10000       60           LRU       
L2       2500        240          LRU       
L3       625         960          LFU       
L4       156        3840          FIFO      

分形相似度分析:
  L1→L2: similarity=0.750 (mean1=0.497, mean2=0.497)
  L2→L3: similarity=0.750 (mean1=0.497, mean2=0.497)
  L3→L4: similarity=0.750 (mean1=0.497, mean2=0.497)

看到了吗？相邻层的相似度完全一样（0.750）。这就是分形自相似性的铁证------每一层都是上一层的精确缩放。

---

五、Prompt 模板 = 分形：为什么 System/Task/Example/Format 嵌套

class FractalPrompt:
    """
    分形 Prompt 模板
    
    结构：
    System (宏观)
    ├── Task (中观)
    │   ├── Example (微观)
    │   │   ├── Input (纳米)
    │   │   └── Output (纳米)
    │   └── Constraint (微观)
    └── Format (中观)
    
    每一层的结构都是：Role + Instruction + Examples + Output Format
    """
    
    def __init__(self, N: float = 4.0):
        self.N = N
        self.template = {
            "system": {
                "role": "You are an expert backend architect",
                "instruction": "Design scalable microservice architectures",
                "examples": [],
                "format": "Structured output with diagrams",
                "sub_tasks": [
                    {
                        "task": "Analyze requirements",
                        "instruction": "Break down user stories into services",
                        "examples": [
                            {"input": "E-commerce platform", "output": "4 domains identified"}
                        ],
                        "format": "JSON",
                        "sub_tasks": []  # 可无限嵌套
                    },
                    {
                        "task": "Design service interfaces",
                        "instruction": "Define APIs for each service",
                        "examples": [
                            {"input": "User Domain", "output": "REST + gRPC endpoints"}
                        ],
                        "format": "OpenAPI spec",
                        "sub_tasks": []
                    }
                ]
            }
        }
    
    def fractal_depth(self, node: dict = None, depth: int = 0) -> int:
        """计算 Prompt 的分形深度"""
        if node is None:
            node = self.template["system"]
        
        if "sub_tasks" not in node or not node["sub_tasks"]:
            return depth
        
        return max(self.fractal_depth(st, depth + 1) for st in node["sub_tasks"])
    
    def fractal_signature(self, node: dict = None) -> dict:
        """分形签名"""
        if node is None:
            node = self.template["system"]
        
        return {
            "keys": list(node.keys()),
            "has_examples": len(node.get("examples", [])) > 0,
            "sub_task_count": len(node.get("sub_tasks", [])),
            "depth": self.fractal_depth(node)
        }
    
    def verify_self_similarity(self) -> bool:
        """
        验证分形自相似性：
        每一层的 key 结构应该相同
        """
        def check_node(node, expected_keys):
            if set(node.keys()) != set(expected_keys):
                return False
            for sub in node.get("sub_tasks", []):
                if not check_node(sub, expected_keys):
                    return False
            return True
        
        expected = {"role", "instruction", "examples", "format", "sub_tasks"}
        return check_node(self.template["system"], expected)
    
    def generate_prompt(self, node: dict = None, indent: int = 0) -> str:
        """生成最终 Prompt 文本"""
        if node is None:
            node = self.template["system"]
        
        lines = []
        prefix = "  " * indent
        
        if "role" in node and node["role"]:
            lines.append(f"{prefix}Role: {node['role']}")
        if "instruction" in node and node["instruction"]:
            lines.append(f"{prefix}Instruction: {node['instruction']}")
        if node.get("examples"):
            lines.append(f"{prefix}Examples:")
            for ex in node["examples"]:
                lines.append(f"{prefix}  Input: {ex['input']}")
                lines.append(f"{prefix}  Output: {ex['output']}")
        if "format" in node and node["format"]:
            lines.append(f"{prefix}Format: {node['format']}")
        
        for sub in node.get("sub_tasks", []):
            lines.append(f"\n{prefix}Sub-task:")
            lines.append(self.generate_prompt(sub, indent + 1))
        
        return "\n".join(lines)


# Demo
fp = FractalPrompt(N=4.0)

print("Prompt 分形结构验证:")
print(f"  自相似: {fp.verify_self_similarity()}")
print(f"  分形深度: {fp.fractal_depth()}")
print(f"\n分形签名:")
sig = fp.fractal_signature()
for k, v in sig.items():
    print(f"  {k}: {v}")

print(f"\n生成的 Prompt:")
print("=" * 60)
print(fp.generate_prompt())

输出：

Prompt 分形结构验证:
  自相似: True
  分形深度: 2

分形签名:
  keys: ['role', 'instruction', 'examples', 'format', 'sub_tasks']
  has_examples: False
  sub_task_count: 2
  depth: 2

生成的 Prompt:
============================================================
Role: You are an expert backend architect
Instruction: Design scalable microservice architectures
Format: Structured output with diagrams

Sub-task:
  Role: You are an expert backend architect
  Instruction: Break down user stories into services
  Examples:
    Input: E-commerce platform
    Output: 4 domains identified
  Format: JSON

Sub-task:
  Role: You are an expert backend architect
  Instruction: Define APIs for each service
  Examples:
    Input: User Domain
    Output: REST + gRPC endpoints
  Format: OpenAPI spec

每一层都有完全相同的 key 结构------这就是 Prompt 的分形自相似性。

---

六、工程落地：用分形维数指导架构设计

6.1 微服务拆分决策树

def should_split(service: ServiceNode, N: float = 4.0) -> tuple:
    """
    判断是否应该拆分一个服务
    
    决策规则（基于分形维数）：
    1. 如果 D < 1.5 → 不拆，继续积累
    2. 如果 1.5 ≤ D ≤ 2.0 → 可以拆，但保持 3-4 个子服务
    3. 如果 D > 2.0 → 必须拆，且每个子服务 D 应回到 1.5-2.0
    """
    D = service._local_dimension()
    
    if D < 1.5:
        return False, f"D={D:.2f} < 1.5, 不拆（积累更多功能）"
    elif D <= 2.0:
        return True, f"D={D:.2f} ∈ [1.5, 2.0], 可以拆为 {int(math.sqrt(N))} 个子服务"
    else:
        return True, f"D={D:.2f} > 2.0, 必须拆！目标：每个子服务 D ≈ {math.log(N)/math.log(math.sqrt(N)):.1f}"


# 测试
test_service = ServiceNode("Monolith", api_count=200)
test_service.add_child(ServiceNode("Module A", api_count=50))
test_service.add_child(ServiceNode("Module B", api_count=50))
test_service.add_child(ServiceNode("Module C", api_count=50))
test_service.add_child(ServiceNode("Module D", api_count=50))

should, reason = should_split(test_service, N=4.0)
print(f"是否拆分 {test_service.name}: {should}")
print(f"原因: {reason}")

6.2 缓存层级规划

def plan_cache_layers(target_hit_rate: float = 0.95, N: float = 4.0) -> list:
    """
    规划缓存层级
    
    规则：每层的命中率曲线形状相同，只是时间轴缩放
    要达到 target_hit_rate，需要 log(1 - target_hit_rate) / log(e^(-1/capacity))
    """
    layers = []
    capacity = 10000
    
    for level in range(1, 5):
        ttl = 60 * (N ** (level - 1))
        hit_rate_at_100 = 1 - math.exp(-100 / (capacity / 100))
        
        layers.append({
            "level": level,
            "capacity": int(capacity),
            "ttl_seconds": int(ttl),
            "estimated_hit_rate": hit_rate_at_100
        })
        
        capacity /= N
    
    return layers


# 生成缓存规划
layers = plan_cache_layers(N=4.0)
print("\n缓存层级规划:")
for l in layers:
    print(f"  L{l['level']}: capacity={l['capacity']:>6}, "
          f"TTL={l['ttl_seconds']:>6}s, "
          f"hit_rate≈{l['estimated_hit_rate']:.3f}")

6.3 Prompt 嵌套深度控制

def check_prompt_depth(prompt: FractalPrompt, max_depth: int = 3) -> dict:
    """
    检查 Prompt 嵌套深度
    
    规则：
    - 深度 ≤ 2：健康
    - 深度 = 3：警告（模型可能丢失上下文）
    - 深度 > 3：危险（必须扁平化）
    """
    depth = prompt.fractal_depth()
    
    return {
        "current_depth": depth,
        "max_recommended": max_depth,
        "status": "✅ OK" if depth <= max_depth else "⚠️ TOO DEEP",
        "recommendation": "flatten" if depth > max_depth else "keep"
    }


check = check_prompt_depth(fp, max_depth=3)
print(f"\nPrompt 深度检查:")
print(f"  当前深度: {check['current_depth']}")
print(f"  推荐最大: {check['max_recommended']}")
print(f"  状态: {check['status']}")
print(f"  建议: {check['recommendation']}")

---

七、工程避坑

坑	说明	解法
以为分形 = 随便复制	分形是精确缩放，不是无脑复制	用 scale_ratio = √N 控制缩放比例
微服务拆太细	每步缩放 < 1.5 → D < 1 → 系统碎片化	保持每层 3-4 个子节点
缓存层级太多	超过 4 层 → 维护成本 > 命中率收益	控制在 3-4 层，N=4 最优
Prompt 嵌套过深	深度 > 3 → 模型丢失上下文	扁平化，用分隔符替代嵌套
忽视分形维数	不知道系统复杂度在哪	定期计算 D，监控趋势

---

八、本篇结论

要点	一句话
分形自相似	I² = -N 在不同尺度上的精确投影
分形维数 D	log(N)/log(√N) = 2，系统处于最优二维展开
微服务	每层 3-4 个子服务，D ≈ 1.58（黄金比例）
缓存	每层容量 × 1/N，命中率曲线形状相同
Prompt	System/Task/Example 嵌套 = 分形结构
工程法则	缩放比 = √N，深度 ≤ 3，每层 3-4 个子节点

记住这条公式：

分形缩放比 = √N

你的微服务、缓存、Prompt 都应该按这个比例缩放。

---

九、下篇预告 & 导航

下一篇：《全息结构入门：Embedding、向量库、知识图谱的统一视角》

• 全息 = 每个局部包含整体的信息
• Embedding 为什么是全息投影？
• 向量数据库的"最近邻"为什么是"共振"？
• 知识图谱的分形全息双重结构
• 用全息深度指导 RAG 设计

---

标签 ：#人工智能 #AIGC #后端开发 #云原生 #软件工程 #微服务 #架构设计 #数据结构与算法

分类：后端开发 / 软件工程 / 人工智能

---

分形自相似是螺旋生成论最"直觉"的部分------你画出来的架构图、写出来的 Prompt、设计的缓存层级，都在告诉你同一件事：系统在不同尺度上重复自己。

下一篇讲全息------那是分形的"信息论升级版"。

---