名称：递归系统架构师描述：设计自引用和递归的系统，这些系统检查、修改或生成自身，包括元认知架构和奇异循环。许可证：MIT

递归系统架构师

该技能提供指导，用于设计操作自身的系统——自引用结构、元认知架构和递归过程，通过奇异循环创建涌现属性。

核心能力

自引用：系统检查或修改自身
奇异循环：层次结构意外折叠的纠缠
元认知：系统推理自身的推理过程
固定点：递归过程中的稳定状态
涌现：通过递归交互产生的属性

递归系统基础

什么使系统递归

传统系统：              递归系统：
输入 → 处理 → 输出         输入 → 处理 → 输出
                                         ↑         │
                                         └─────────┘
                                    处理操作自身或其输出

自引用类型

类型	描述	示例
直接	系统显式引用自身	`function f() { return f; }`
间接	系统通过另一个引用自身	A引用B，B引用A
层次化	更高层次描述更低层次	关于数据的元数据
奇异循环	层次意外折叠	哥德尔句子

奇异循环模式

道格拉斯·霍夫斯塔德的概念：在层次结构中移动，你意外地发现自己回到了起点。

第3层：元规则（关于规则的规则）
    ↑                    │
第2层：规则           │
    ↑                    │
第1层：对象         │
    ↑                    ↓
    └────────────────────┘
    第3层可以修改第1层，
    影响到达第3层的内容

递归架构模式

自修改代码

# 系统修改自身行为
class SelfModifyingAgent:
    def __init__(self):
        self.rules = {
            'default': lambda x: x * 2
        }
        self.meta_rules = {
            'optimize': self._optimize_rules
        }

    def process(self, input):
        result = self.rules['default'](input)
        # 系统检查自身性能
        self._reflect_on_result(result)
        return result

    def _reflect_on_result(self, result):
        # 元层次：决定是否修改规则
        if self._should_modify():
            self.meta_rules['optimize']()

    def _optimize_rules(self):
        # 修改产生结果的规则
        # 这是递归折叠
        self.rules['default'] = self._generate_better_rule()

元认知循环

┌─────────────────────────────────────────────────────────┐
│                  元认知架构              │
├─────────────────────────────────────────────────────────┤
│                                                         │
│  ┌─────────────────────────────────────────────┐       │
│  │           元认知层               │       │
│  │  • 监控认知过程               │       │
│  │  • 评估策略效果           │       │
│  │  • 修改认知策略               │       │
│  └──────────────────┬──────────────────────────┘       │
│                     │ 观察和修改               │
│                     ▼                                   │
│  ┌─────────────────────────────────────────────┐       │
│  │           认知层                    │       │
│  │  • 执行推理策略              │       │
│  │  • 处理信息                       │       │
│  │  • 生成输出                          │       │
│  └──────────────────┬──────────────────────────┘       │
│                     │ 产生                          │
│                     ▼                                   │
│  ┌─────────────────────────────────────────────┐       │
│  │           基础层                       │
│  │  • 原始输入和输出                    │
│  │  • 环境交互                 │
│  └─────────────────────────────────────────────┘       │
│                                                         │
└─────────────────────────────────────────────────────────┘

固定点迭代

许多递归系统寻求固定点——进一步迭代不产生变化的状态：

def find_fixed_point(f, initial, tolerance=1e-6, max_iter=1000):
    """找到 x 使得 f(x) = x"""
    x = initial
    for i in range(max_iter):
        x_next = f(x)
        if abs(x_next - x) < tolerance:
            return x_next  # 找到固定点
        x = x_next
    return x  # 可能未收敛

# 自一致信念示例
def belief_update(beliefs):
    """基于其他信念更新信念"""
    new_beliefs = {}
    for key, value in beliefs.items():
        # 每个信念受相关信念影响
        related = get_related_beliefs(beliefs, key)
        new_beliefs[key] = aggregate(value, related)
    return new_beliefs

# 找到平衡信念
stable_beliefs = find_fixed_point(belief_update, initial_beliefs)

奎因模式（自复制）

奎因是输出自身源代码的程序：

# Python奎因
s = 's = %r
print(s %% s)'
print(s % s)

此模式扩展到可以描述或重建自身的系统：

class SelfDescribingSystem:
    """系统可以生成自身规范"""

    def __init__(self, config):
        self.config = config
        self.state = {}

    def describe(self):
        """生成此系统的完整描述"""
        return {
            'type': self.__class__.__name__,
            'config': self.config,
            'state': self.state,
            'methods': self._describe_methods()
        }

    def reconstruct(self, description):
        """从描述创建新实例"""
        return self.__class__(description['config'])

    def clone(self):
        """通过自描述自复制"""
        description = self.describe()
        return self.reconstruct(description)

递归系统设计模式

观察者-被观察者双重性

class ReflectiveSystem:
    """系统既是观察者又是被观察者"""

    def __init__(self):
        self.observations = []
        self.self_model = {}

    def act(self, action):
        # 执行动作
        result = self._execute(action)

        # 观察自身执行动作
        self._observe_self(action, result)

        # 基于观察更新自我模型
        self._update_self_model()

        return result

    def _observe_self(self, action, result):
        observation = {
            'action': action,
            'result': result,
            'predicted': self.self_model.get('predicted_result'),
            'surprise': self._compute_surprise()
        }
        self.observations.append(observation)

    def _update_self_model(self):
        # 自我模型预测自身行为
        # 差异驱动模型更新
        recent = self.observations[-10:]
        self.self_model['patterns'] = self._find_patterns(recent)
        self.self_model['predicted_result'] = self._predict_next()

递归分解

将问题分解为自相似的子问题：

def recursive_solve(problem, depth=0, max_depth=10):
    """通过递归分解解决"""

    # 基础情况：问题是原子的
    if is_atomic(problem) or depth >= max_depth:
        return solve_directly(problem)

    # 递归情况：分解并解决
    subproblems = decompose(problem)
    subsolutions = [recursive_solve(sp, depth + 1) for sp in subproblems]

    # 组合子解
    solution = combine(subsolutions)

    # 元层次：评估解质量
    if not satisfactory(solution, problem):
        # 尝试不同分解
        alternative = alternative_decomposition(problem)
        return recursive_solve(alternative, depth)

    return solution

自引用数据结构

class RecursiveNode:
    """节点可以包含对自身的引用"""

    def __init__(self, value):
        self.value = value
        self.children = []
        self.references = []  # 可以包含自身

    def add_self_reference(self):
        """创建奇异循环"""
        self.references.append(self)

    def traverse(self, visited=None):
        """遍历处理循环"""
        if visited is None:
            visited = set()

        if id(self) in visited:
            return ['(检测到循环)']

        visited.add(id(self))
        result = [self.value]

        for child in self.children:
            result.extend(child.traverse(visited))

        return result

递归的涌现

细胞自动机模式

简单规则 + 自应用 = 复杂行为：

def cellular_automaton(rule, initial_state, generations):
    """
    规则：映射邻域到下一状态的函数
    自引用：每个细胞依赖于依赖于它的邻居
    """
    state = initial_state
    history = [state]

    for _ in range(generations):
        new_state = []
        for i in range(len(state)):
            # 每个细胞的下一个状态依赖于邻域
            # 规则统一应用——递归创造复杂性
            neighborhood = get_neighborhood(state, i)
            new_state.append(rule(neighborhood))
        state = new_state
        history.append(state)

    return history

自组织临界性

自然演变为临界状态的系统：

class SandpileModel:
    """系统自组织到临界状态"""

    def __init__(self, size, threshold=4):
        self.grid = [[0] * size for _ in range(size)]
        self.threshold = threshold

    def add_grain(self, x, y):
        self.grid[x][y] += 1
        self._maybe_topple(x, y)

    def _maybe_topple(self, x, y):
        """递归倾倒创造幂律分布"""
        if self.grid[x][y] >= self.threshold:
            self.grid[x][y] -= self.threshold
            # 分配到邻居——可能触发它们的倾倒
            for nx, ny in self._neighbors(x, y):
                self.grid[nx][ny] += 1
                self._maybe_topple(nx, ny)  # 递归！

设计原则

终止保证

递归系统必须处理无限循环：

深度限制：最大递归深度
变化检测：当达到固定点时停止
能量/资源界限：有限计算预算
循环检测：跟踪访问过的状态

连贯性维护

自修改系统可能失去连贯性：

不变量保护：核心属性从不违反
渐进变化：仅进行小修改
回滚能力：撤销有害变化
沙盒化：在应用前测试修改

可观测性

递归系统难以调试：

层次标记：跟踪哪个元层次产生输出
跟踪日志：记录递归路径
状态快照：捕获中间状态
可视化：渲染奇异循环结构

参考文献

references/strange-loops.md - 霍夫斯塔德的奇异循环理论
references/fixed-point-theory.md - 数学基础
references/metacognitive-patterns.md - 元认知实现模式

名称：递归系统架构师 描述：设计自引用和递归的系统，这些系统检查、修改或生成自身，包括元认知架构和奇异循环。 许可证：MIT