liquid-loop 0.7.0__tar.gz → 0.8.0__tar.gz

{liquid_loop-0.7.0 → liquid_loop-0.8.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: liquid-loop
-Version: 0.7.0
+Version: 0.8.0
 Summary: Self-Organizing Cognitive Memory for AI Agents — Liquid Loop theory implementation
 Author: fishbook0001
 Maintainer: fishbook0001
@@ -72,7 +72,7 @@ Dynamic: license-file
 | **Anchor** 锚点 | 晶种 | 认知关注点，有稳定性值 s ∈ [0,1] |
 | **Evidence** 证据 | 附着粒子 | 锚点下的具体观察，权重指数衰减 w×0.95ᵗ |
 | **Memory** 结晶 | 结晶体 | 2+ 条一致 Evidence 自动凝聚，有置信度 c |
-| **Entropy** 熵值 | 流体无序度 | 八维加权（锚点漂移 / 冲突密度 / 碎片 / 活跃间隔 / 价值衰减 / 锚定强度 / CPE 三维） |
+| **Entropy** 熵值 (LEI) | 流体无序度 | 八维加权（锚点漂移 / 冲突密度 / 碎片 / 活跃间隔 / 价值衰减 / 锚定强度 / CPE 三维） |
 
 **状态判定：**
 ```
@@ -81,6 +81,64 @@ YELLOW (0.3 ≤ entropy < 0.6) — 需关注
 RED    (entropy ≥ 0.6)  — 需清理
 ```
 
+> **关于 "Entropy" 的语义澄清 — Liquid Entropy Index (LEI)**
+>
+> 本项目中的 `entropy` 是 **Liquid Entropy Index (LEI): a system-stability deviation metric, inspired by entropy but NOT equivalent to thermodynamic entropy.**
+> 它不是物理熵 `S = -k Σ pᵢ log pᵢ`，而是对**系统状态偏离稳定流形程度**的综合度量——由八个可解释分量人工加权而成（锚点漂移 / 冲突密度 / 证据碎片 / 活跃间隔 / 价值衰减 / 锚定强度 + CPE 三维：回顾性衰退 / 策略漂移 / 泛化崩塌）。
+> 代码层函数名保留 `calculate()`（历史连续性）；文档 / 论文层一律以 **LEI** 指称，避免与热力学熵混淆。
+
+---
+
+## v0.8 反证轨 + 时间动力学（液态循环核心）
+
+液环 v0.8 从"静态结晶"升级为**自调节记忆动力学**：记忆不是对象，而是过程。
+
+### 反证轨（Contradiction Track）
+
+证据可标记与记忆的关系，打破"一致即真"：
+
+```python
+from liquid_loop import WorkspaceState
+
+state = WorkspaceState()
+a = state.add_anchor("用户偏好", "红还是蓝")
+state.add_evidence(a, "用户喜欢红色")          # support (默认)
+state.add_evidence(a, "用户喜欢红色")          # 2 次一致 -> 结晶, stability≈0.67
+mem = state.memories[0]
+state.add_evidence(a, "用户喜欢蓝色",
+                   relation="contradiction",    # 冲突证据
+                   target_memory_id=mem.id)     # 显式指向被反驳的记忆
+# -> mem.stability 降到 ≈0.40（一致增稳 / 冲突降稳）
+```
+
+稳定性公式：`stability = support / (support + 2·contradiction + 1)`。
+`contradiction_weight=2.0` 使单条冲突的降稳效力 ≈ 两条支持，直接对抗**群体幻觉固化**。
+
+### 时间动力学 `state.step(dt)`
+
+显式演化步（记忆随时间衰减 / 被新证据强化）：
+
+```python
+# 无新支持证据时，时间推进使稳定性衰减
+state.step(dt=10, decay_rate=0.05)
+# M(t+1) = M(t) + reinforcement − decay − contradiction_penalty
+```
+
+- 每条证据权重按 `(1−decay_rate)^dt` 衰减（无强化则价值流失，下限 0.05）
+- 记忆在**自上次 step 以来获得新 support** 时恢复到固有稳定性（强化）；否则时间衰减且不超过固有上限
+
+### 实验验证（examples/experiments/，全部 PASS）
+
+| 实验 | 问题 | 结论 |
+|------|------|------|
+| **E2 错误记忆恢复** | 能否主动遗忘错误并恢复？ | 80%错误+20%真实 → 反证轨使错误 stability 0.67→0.30、正确升至 0.69 主导 ✅ |
+| **E3 多 Agent 冲突** | mesh v2 能否形成稳定共享认知？ | A support / B contradiction / C noise → 核心 claim 进入受争议稳定区(0.40)，噪声隔离 ✅ |
+| **E1 长期漂移** | 1000 轮随机注入是否收敛？ | 300 轮压测 → 48 记忆(≤池×3)、plateau、LEI GREEN、avg_stab 0.80 ✅ |
+
+```bash
+python3 examples/experiments/run_all.py   # 生成 REPORT_v0.8.json
+```
+
 ---
 
 ## 快速开始
@@ -93,7 +151,7 @@ pip install liquid-loop
 
 ### 3 分钟上手
 ```python
-from liquid_loop import WorkspaceState, load, save, calculate_entropy
+from liquid_loop import WorkspaceState, load, save, calculate
 
 # 1. 创建/加载工作区
 state = WorkspaceState()  # 或 load(Path("."))
@@ -111,7 +169,7 @@ for m in state.memories:
     print(f"结晶: {m.content[:50]}... (置信度={m.confidence:.2f})")
 
 # 5. 监控认知健康
-entropy = calculate_entropy(state)
+entropy = calculate(state)
 print(f"熵值: {entropy:.4f} → {'🟢GREEN' if entropy < 0.3 else '🟡YELLOW' if entropy < 0.6 else '🔴RED'}")
 
 # 6. 持久化
@@ -167,6 +225,26 @@ print(health["CCI"], health["consensus_crystals"])
 
 ---
 
+## 定位：Self-Regulating Persistent Memory Dynamics
+
+液环的本质不是"AI 意识"，而是一套 **agent 系统的自调节持久记忆动力学（Self-Regulating Persistent Memory Dynamics for Agent Systems）**。`AuditChain + LEI(Entropy) + Memory decay` 三者组合形成闭环，使记忆从"外部管理"转向"内部自组织"：
+
+```
+   Input Evidence
+        ↓
+   Memory State  ←──────────────┐
+        ↓                        │
+   LEI Evaluation (八维熵)        │
+        ↓                        │
+   Decay / Reinforcement ────────┘
+        ↓
+   AuditChain (SHA256 链式追溯)
+```
+
+这比单独的 memory store 更接近一个可被实验检验的**动态系统**：输入驱动状态、熵评估稳定性、衰减/强化回流状态、审计链保证来源可信。
+
+---
+
 ## 架构对比
 
 ```
@@ -213,7 +291,7 @@ liquid-loop/
 │   ├── __init__.py      # 公共 API 导出
 │   ├── workspace.py     # 核心数据模型 + AuditChain + auto_classify + decay
 │   ├── storage.py       # JSON 持久化 + 审计链写入
-│   ├── entropy.py       # 四维熵值计算
+│   ├── entropy.py       # 八维熵值计算（含 CPE 三维）
 │   ├── mesh/            # MESH v2 多智能体共识协议集成（validate_evidence / compute_cci / ...）
 │   └── cli.py           # Click CLI (11 命令)
 ├── examples/
@@ -240,12 +318,16 @@ pytest -v
 
 ## 路线图
 
-- [ ] 语义一致性结晶（嵌入相似度替代精确匹配）
 - [x] 多 Agent 液环耦合（`liquid_loop.mesh` v2 共识协议，2026-07-15 落地）
-- [ ] LX 扩展：世界模型预测纳入液环
+- [x] **[v0.8] 反证轨（Evidence Graph）**：Evidence 分 support / contradiction，一致增稳、冲突降稳，驱动 memory stability score（不再"一致即真"）
+- [x] **[v0.8] 显式时间动力学**：`M(t+1) = M(t) + reinforcement − decay − contradiction_penalty`，让记忆成为"过程"而非"对象"（真正的液态循环）
+- [x] **[v0.8] 三实验全 PASS**：E2 错误记忆恢复 → E3 多 agent 冲突 → E1 长期漂移（见上节）
+- [ ] **[v0.9 优化项]**：`_detect_conflicts` 由每证据 O(g²) 两两扫描改为增量/采样（大规模高频写入性能，非正确性）
 - [ ] LoCoMo / LongMemEval 基准对比
 - [ ] 边缘端部署优化（<50KB）
 
+> 零向量是液环的硬约束：一致性判定永不引入 embedding / 相似度（这正是液环要替代的方案）。
+
 ---
 
 ## 许可证

{liquid_loop-0.7.0 → liquid_loop-0.8.0}/README.md

@@ -33,7 +33,7 @@
 | **Anchor** 锚点 | 晶种 | 认知关注点，有稳定性值 s ∈ [0,1] |
 | **Evidence** 证据 | 附着粒子 | 锚点下的具体观察，权重指数衰减 w×0.95ᵗ |
 | **Memory** 结晶 | 结晶体 | 2+ 条一致 Evidence 自动凝聚，有置信度 c |
-| **Entropy** 熵值 | 流体无序度 | 八维加权（锚点漂移 / 冲突密度 / 碎片 / 活跃间隔 / 价值衰减 / 锚定强度 / CPE 三维） |
+| **Entropy** 熵值 (LEI) | 流体无序度 | 八维加权（锚点漂移 / 冲突密度 / 碎片 / 活跃间隔 / 价值衰减 / 锚定强度 / CPE 三维） |
 
 **状态判定：**
 ```
@@ -42,6 +42,64 @@ YELLOW (0.3 ≤ entropy < 0.6) — 需关注
 RED    (entropy ≥ 0.6)  — 需清理
 ```
 
+> **关于 "Entropy" 的语义澄清 — Liquid Entropy Index (LEI)**
+>
+> 本项目中的 `entropy` 是 **Liquid Entropy Index (LEI): a system-stability deviation metric, inspired by entropy but NOT equivalent to thermodynamic entropy.**
+> 它不是物理熵 `S = -k Σ pᵢ log pᵢ`，而是对**系统状态偏离稳定流形程度**的综合度量——由八个可解释分量人工加权而成（锚点漂移 / 冲突密度 / 证据碎片 / 活跃间隔 / 价值衰减 / 锚定强度 + CPE 三维：回顾性衰退 / 策略漂移 / 泛化崩塌）。
+> 代码层函数名保留 `calculate()`（历史连续性）；文档 / 论文层一律以 **LEI** 指称，避免与热力学熵混淆。
+
+---
+
+## v0.8 反证轨 + 时间动力学（液态循环核心）
+
+液环 v0.8 从"静态结晶"升级为**自调节记忆动力学**：记忆不是对象，而是过程。
+
+### 反证轨（Contradiction Track）
+
+证据可标记与记忆的关系，打破"一致即真"：
+
+```python
+from liquid_loop import WorkspaceState
+
+state = WorkspaceState()
+a = state.add_anchor("用户偏好", "红还是蓝")
+state.add_evidence(a, "用户喜欢红色")          # support (默认)
+state.add_evidence(a, "用户喜欢红色")          # 2 次一致 -> 结晶, stability≈0.67
+mem = state.memories[0]
+state.add_evidence(a, "用户喜欢蓝色",
+                   relation="contradiction",    # 冲突证据
+                   target_memory_id=mem.id)     # 显式指向被反驳的记忆
+# -> mem.stability 降到 ≈0.40（一致增稳 / 冲突降稳）
+```
+
+稳定性公式：`stability = support / (support + 2·contradiction + 1)`。
+`contradiction_weight=2.0` 使单条冲突的降稳效力 ≈ 两条支持，直接对抗**群体幻觉固化**。
+
+### 时间动力学 `state.step(dt)`
+
+显式演化步（记忆随时间衰减 / 被新证据强化）：
+
+```python
+# 无新支持证据时，时间推进使稳定性衰减
+state.step(dt=10, decay_rate=0.05)
+# M(t+1) = M(t) + reinforcement − decay − contradiction_penalty
+```
+
+- 每条证据权重按 `(1−decay_rate)^dt` 衰减（无强化则价值流失，下限 0.05）
+- 记忆在**自上次 step 以来获得新 support** 时恢复到固有稳定性（强化）；否则时间衰减且不超过固有上限
+
+### 实验验证（examples/experiments/，全部 PASS）
+
+| 实验 | 问题 | 结论 |
+|------|------|------|
+| **E2 错误记忆恢复** | 能否主动遗忘错误并恢复？ | 80%错误+20%真实 → 反证轨使错误 stability 0.67→0.30、正确升至 0.69 主导 ✅ |
+| **E3 多 Agent 冲突** | mesh v2 能否形成稳定共享认知？ | A support / B contradiction / C noise → 核心 claim 进入受争议稳定区(0.40)，噪声隔离 ✅ |
+| **E1 长期漂移** | 1000 轮随机注入是否收敛？ | 300 轮压测 → 48 记忆(≤池×3)、plateau、LEI GREEN、avg_stab 0.80 ✅ |
+
+```bash
+python3 examples/experiments/run_all.py   # 生成 REPORT_v0.8.json
+```
+
 ---
 
 ## 快速开始
@@ -54,7 +112,7 @@ pip install liquid-loop
 
 ### 3 分钟上手
 ```python
-from liquid_loop import WorkspaceState, load, save, calculate_entropy
+from liquid_loop import WorkspaceState, load, save, calculate
 
 # 1. 创建/加载工作区
 state = WorkspaceState()  # 或 load(Path("."))
@@ -72,7 +130,7 @@ for m in state.memories:
     print(f"结晶: {m.content[:50]}... (置信度={m.confidence:.2f})")
 
 # 5. 监控认知健康
-entropy = calculate_entropy(state)
+entropy = calculate(state)
 print(f"熵值: {entropy:.4f} → {'🟢GREEN' if entropy < 0.3 else '🟡YELLOW' if entropy < 0.6 else '🔴RED'}")
 
 # 6. 持久化
@@ -128,6 +186,26 @@ print(health["CCI"], health["consensus_crystals"])
 
 ---
 
+## 定位：Self-Regulating Persistent Memory Dynamics
+
+液环的本质不是"AI 意识"，而是一套 **agent 系统的自调节持久记忆动力学（Self-Regulating Persistent Memory Dynamics for Agent Systems）**。`AuditChain + LEI(Entropy) + Memory decay` 三者组合形成闭环，使记忆从"外部管理"转向"内部自组织"：
+
+```
+   Input Evidence
+        ↓
+   Memory State  ←──────────────┐
+        ↓                        │
+   LEI Evaluation (八维熵)        │
+        ↓                        │
+   Decay / Reinforcement ────────┘
+        ↓
+   AuditChain (SHA256 链式追溯)
+```
+
+这比单独的 memory store 更接近一个可被实验检验的**动态系统**：输入驱动状态、熵评估稳定性、衰减/强化回流状态、审计链保证来源可信。
+
+---
+
 ## 架构对比
 
 ```
@@ -174,7 +252,7 @@ liquid-loop/
 │   ├── __init__.py      # 公共 API 导出
 │   ├── workspace.py     # 核心数据模型 + AuditChain + auto_classify + decay
 │   ├── storage.py       # JSON 持久化 + 审计链写入
-│   ├── entropy.py       # 四维熵值计算
+│   ├── entropy.py       # 八维熵值计算（含 CPE 三维）
 │   ├── mesh/            # MESH v2 多智能体共识协议集成（validate_evidence / compute_cci / ...）
 │   └── cli.py           # Click CLI (11 命令)
 ├── examples/
@@ -201,12 +279,16 @@ pytest -v
 
 ## 路线图
 
-- [ ] 语义一致性结晶（嵌入相似度替代精确匹配）
 - [x] 多 Agent 液环耦合（`liquid_loop.mesh` v2 共识协议，2026-07-15 落地）
-- [ ] LX 扩展：世界模型预测纳入液环
+- [x] **[v0.8] 反证轨（Evidence Graph）**：Evidence 分 support / contradiction，一致增稳、冲突降稳，驱动 memory stability score（不再"一致即真"）
+- [x] **[v0.8] 显式时间动力学**：`M(t+1) = M(t) + reinforcement − decay − contradiction_penalty`，让记忆成为"过程"而非"对象"（真正的液态循环）
+- [x] **[v0.8] 三实验全 PASS**：E2 错误记忆恢复 → E3 多 agent 冲突 → E1 长期漂移（见上节）
+- [ ] **[v0.9 优化项]**：`_detect_conflicts` 由每证据 O(g²) 两两扫描改为增量/采样（大规模高频写入性能，非正确性）
 - [ ] LoCoMo / LongMemEval 基准对比
 - [ ] 边缘端部署优化（<50KB）
 
+> 零向量是液环的硬约束：一致性判定永不引入 embedding / 相似度（这正是液环要替代的方案）。
+
 ---
 
 ## 许可证

{liquid_loop-0.7.0 → liquid_loop-0.8.0}/liquid_loop/__init__.py

@@ -1,5 +1,5 @@
-"""Liquid Loop — Workspace Cognitive Runtime v0.7.0 (CPE-fused, SEAL dual-opt, dual-track multi-agent, MESH v2 integration)"""
-__version__ = "0.7.0"
+"""Liquid Loop — Workspace Cognitive Runtime v0.8.0 (反证轨 + 时间动力学, CPE-fused, SEAL dual-opt, dual-track multi-agent, MESH v2 integration)"""
+__version__ = "0.8.0"
 
 from .workspace import (
     WorkspaceState, Anchor, Evidence, Memory, Conflict,

{liquid_loop-0.7.0 → liquid_loop-0.8.0}/liquid_loop/workspace.py

@@ -156,6 +156,8 @@ class Evidence:
     quality: str = "normal"
     archived: bool = False  # 预算超额冷归档标记（PEEK 落地，零丢失）
     agent_id: str = ""  # 多智能体共用：写入者标识（共用机制，缺省=legacy/单实例）
+    relation: str = "support"  # 反证轨：evidence 与 memory 的关系 "support"(一致) | "contradiction"(冲突) | ""(legacy 视为 support)
+    target_memory_id: str = ""  # relation=contradiction 时，可选显式指向被反驳的 memory（缺省=同锚点最近结晶）
 
 
 @dataclass
@@ -167,6 +169,11 @@ class Memory:
     confidence: float = 0.0
     scope: str = "private"  # 结晶来源: private(同 agent≥2一致) / consensus(跨 distinct owner≥2一致)
     contributors: list[str] = field(default_factory=list)  # 参与成核的 agent_id 列表
+    # ── v0.8 反证轨 + 时间动力学 ──
+    stability: float = 1.0  # 反证轨稳定性：一致增稳、冲突降稳（0~1）
+    support_count: int = 0  # 支持该 memory 的证据数
+    contradiction_count: int = 0  # 反驳该 memory 的证据数
+    last_reinforced: str = ""  # 最近一次被 support 证据强化的时间戳（时间动力学用）
 
 
 @dataclass
@@ -248,11 +255,16 @@ class WorkspaceState:
         self.updated_at = now()
         return a
 
-    def add_evidence(self, anchor, content: str, quality: float = 1.0, agent_id: str = "") -> Optional[Evidence]:
+    def add_evidence(self, anchor, content: str, quality: float = 1.0, agent_id: str = "",
+                     dedup: bool = False, relation: str = "support",
+                     target_memory_id: str = "") -> Optional[Evidence]:
         """向指定锚点添加一条证据。
 
         anchor 参数兼容：锚点名称(str) | 锚点ID(str) | Anchor对象
         agent_id：多智能体共用写入者标识（缺省空=legacy/单实例）
+        dedup：幂等去重开关（默认 False，核心语义允许重复写入以触发结晶）。
+        relation：反证轨关系 "support"(一致, 默认) | "contradiction"(冲突) —— 见 v0.8 反证轨。
+        target_memory_id：relation="contradiction" 时可选显式指向被反驳的 memory。
         """
         target = None
         if isinstance(anchor, Anchor):
@@ -264,13 +276,15 @@ class WorkspaceState:
                 target = next((a for a in self.anchors if a.id == anchor), None)
         if not target:
             return None
-        # 幂等去重：同锚点+同内容+同 agent 已存在则复用，防止重复证据膨胀（mesh 重试/高频喂入）
-        for ex in self.evidences:
-            if ex.anchor_id == target.id and ex.content == content and ex.agent_id == agent_id:
-                return ex
+        # 幂等去重（仅当 dedup=True）：同锚点+同内容+同 agent 已存在则复用
+        if dedup:
+            for ex in self.evidences:
+                if ex.anchor_id == target.id and ex.content == content and ex.agent_id == agent_id:
+                    return ex
         e = Evidence(
             id=uid(), anchor_id=target.id, content=content,
             quality=quality, timestamp=now(), agent_id=agent_id,
+            relation=relation, target_memory_id=target_memory_id,
         )
         self.evidences.append(e)
         target.evidence_ids.append(e.id)
@@ -280,9 +294,10 @@ class WorkspaceState:
         return e
 
     def _on_evidence_added(self, anchor_id: str):
-        """证据添加后的统一后处理：衰减→成核→稳定性刷新→冲突检测→预算稳态"""
+        """证据添加后的统一后处理：衰减→成核→反证轨稳定性→冲突检测→预算稳态"""
         self._decay_anchor(anchor_id)
         self._nucleate(anchor_id)
+        self._update_memory_stability(anchor_id)
         self._recalc_anchor(anchor_id)
         self._detect_conflicts(anchor_id)
         self._stabilize_budget()
@@ -434,6 +449,77 @@ class WorkspaceState:
         self.updated_at = now()
         return m
 
+    # ─────────────────────────────────────────────────────────────
+    # v0.8 反证轨 + 时间动力学（液态循环核心）
+    # ─────────────────────────────────────────────────────────────
+
+    def _update_memory_stability(self, anchor_id: str):
+        """反证轨：一致证据(support)增稳，冲突证据(contradiction)降稳。
+
+        稳定性 = support / (support + CONTRADICTION_WEIGHT * contradiction + 1)
+        - 同锚点下 content 相同的 support 证据计为支持
+        - relation="contradiction" 的证据计为反驳（显式 target_memory_id 或同锚点无指定则作用于该锚点结晶）
+        - 有 support 证据则刷新 last_reinforced（时间动力学强化信号）
+        """
+        CONTRADICTION_WEIGHT = 2.0
+        group = [e for e in self.evidences if e.anchor_id == anchor_id and not e.archived]
+        group_ids = {e.id for e in group}
+        anchor_memories = [m for m in self.memories
+                           if any(eid in group_ids for eid in m.evidence_ids)]
+        for m in anchor_memories:
+            supports = [e for e in group
+                        if e.relation in ("support", "") and e.content == m.content]
+            if m.id:
+                contradicts = [e for e in group
+                               if e.relation == "contradiction"
+                               and (e.target_memory_id == m.id or not e.target_memory_id)]
+            else:
+                contradicts = [e for e in group
+                               if e.relation == "contradiction" and not e.target_memory_id]
+            s = len(supports)
+            c = len(contradicts)
+            m.support_count = s
+            m.contradiction_count = c
+            m.stability = round(min(1.0, max(0.0,
+                                s / (s + CONTRADICTION_WEIGHT * c + 1))), 3)
+            if supports:
+                m.last_reinforced = max(e.timestamp for e in supports)
+
+    def step(self, dt: int = 1, decay_rate: float = 0.05):
+        """显式时间动力学步（v0.8 液态循环核心）：
+
+            M(t+1) = M(t) + reinforcement − decay − contradiction_penalty
+
+        - 每条证据按 (1−decay_rate)^dt 衰减权重（无强化则价值流失，下限 0.05）
+        - 每个 memory 按 support/contradiction 计数重算固有稳定性（矛盾惩罚持续作用）；
+          若本轮有 support 证据 → 稳定性恢复到固有值（强化）；否则按时间衰减（无强化流失）
+        - 重算锚点稳定性与审计更新时间
+        """
+        # 1. 证据权重时间衰减
+        for e in self.evidences:
+            if not e.archived:
+                e.weight = max(e.weight * ((1 - decay_rate) ** dt), 0.05)
+        # 2. 记忆稳定性：固有(计数驱动) + 时间衰减/强化
+        for a in self.anchors:
+            self._update_memory_stability(a.id)
+        last_step = getattr(self, "_last_step_at", "")
+        now_dt = datetime.now(timezone.utc)
+        for m in self.memories:
+            intrinsic = m.stability  # _update_memory_stability 已写入固有稳定性
+            # 强化 = 自上次 step 以来有过新 support 证据（last_reinforced 晚于上次 step）
+            reinforced = bool(m.last_reinforced) and (not last_step or m.last_reinforced > last_step)
+            if reinforced:
+                m.stability = intrinsic  # 被强化：恢复到固有稳定性
+            else:
+                # 无新强化：时间衰减，且不超过固有上限
+                m.stability = round(max(0.0, min(intrinsic,
+                                    m.stability * ((1 - decay_rate) ** dt))), 3)
+        self._last_step_at = now()
+        # 3. 重算锚点稳定性
+        for a in self.anchors:
+            self._recalc_anchor(a.id)
+        self.updated_at = now()
+
 
 # ==============================================================================
 # CPERegularizer — 能力保留正则化引擎（借鉴 UIUC CPE 论文 arXiv:2605.09315）

{liquid_loop-0.7.0 → liquid_loop-0.8.0}/liquid_loop.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: liquid-loop
-Version: 0.7.0
+Version: 0.8.0
 Summary: Self-Organizing Cognitive Memory for AI Agents — Liquid Loop theory implementation
 Author: fishbook0001
 Maintainer: fishbook0001
@@ -72,7 +72,7 @@ Dynamic: license-file
 | **Anchor** 锚点 | 晶种 | 认知关注点，有稳定性值 s ∈ [0,1] |
 | **Evidence** 证据 | 附着粒子 | 锚点下的具体观察，权重指数衰减 w×0.95ᵗ |
 | **Memory** 结晶 | 结晶体 | 2+ 条一致 Evidence 自动凝聚，有置信度 c |
-| **Entropy** 熵值 | 流体无序度 | 八维加权（锚点漂移 / 冲突密度 / 碎片 / 活跃间隔 / 价值衰减 / 锚定强度 / CPE 三维） |
+| **Entropy** 熵值 (LEI) | 流体无序度 | 八维加权（锚点漂移 / 冲突密度 / 碎片 / 活跃间隔 / 价值衰减 / 锚定强度 / CPE 三维） |
 
 **状态判定：**
 ```
@@ -81,6 +81,64 @@ YELLOW (0.3 ≤ entropy < 0.6) — 需关注
 RED    (entropy ≥ 0.6)  — 需清理
 ```
 
+> **关于 "Entropy" 的语义澄清 — Liquid Entropy Index (LEI)**
+>
+> 本项目中的 `entropy` 是 **Liquid Entropy Index (LEI): a system-stability deviation metric, inspired by entropy but NOT equivalent to thermodynamic entropy.**
+> 它不是物理熵 `S = -k Σ pᵢ log pᵢ`，而是对**系统状态偏离稳定流形程度**的综合度量——由八个可解释分量人工加权而成（锚点漂移 / 冲突密度 / 证据碎片 / 活跃间隔 / 价值衰减 / 锚定强度 + CPE 三维：回顾性衰退 / 策略漂移 / 泛化崩塌）。
+> 代码层函数名保留 `calculate()`（历史连续性）；文档 / 论文层一律以 **LEI** 指称，避免与热力学熵混淆。
+
+---
+
+## v0.8 反证轨 + 时间动力学（液态循环核心）
+
+液环 v0.8 从"静态结晶"升级为**自调节记忆动力学**：记忆不是对象，而是过程。
+
+### 反证轨（Contradiction Track）
+
+证据可标记与记忆的关系，打破"一致即真"：
+
+```python
+from liquid_loop import WorkspaceState
+
+state = WorkspaceState()
+a = state.add_anchor("用户偏好", "红还是蓝")
+state.add_evidence(a, "用户喜欢红色")          # support (默认)
+state.add_evidence(a, "用户喜欢红色")          # 2 次一致 -> 结晶, stability≈0.67
+mem = state.memories[0]
+state.add_evidence(a, "用户喜欢蓝色",
+                   relation="contradiction",    # 冲突证据
+                   target_memory_id=mem.id)     # 显式指向被反驳的记忆
+# -> mem.stability 降到 ≈0.40（一致增稳 / 冲突降稳）
+```
+
+稳定性公式：`stability = support / (support + 2·contradiction + 1)`。
+`contradiction_weight=2.0` 使单条冲突的降稳效力 ≈ 两条支持，直接对抗**群体幻觉固化**。
+
+### 时间动力学 `state.step(dt)`
+
+显式演化步（记忆随时间衰减 / 被新证据强化）：
+
+```python
+# 无新支持证据时，时间推进使稳定性衰减
+state.step(dt=10, decay_rate=0.05)
+# M(t+1) = M(t) + reinforcement − decay − contradiction_penalty
+```
+
+- 每条证据权重按 `(1−decay_rate)^dt` 衰减（无强化则价值流失，下限 0.05）
+- 记忆在**自上次 step 以来获得新 support** 时恢复到固有稳定性（强化）；否则时间衰减且不超过固有上限
+
+### 实验验证（examples/experiments/，全部 PASS）
+
+| 实验 | 问题 | 结论 |
+|------|------|------|
+| **E2 错误记忆恢复** | 能否主动遗忘错误并恢复？ | 80%错误+20%真实 → 反证轨使错误 stability 0.67→0.30、正确升至 0.69 主导 ✅ |
+| **E3 多 Agent 冲突** | mesh v2 能否形成稳定共享认知？ | A support / B contradiction / C noise → 核心 claim 进入受争议稳定区(0.40)，噪声隔离 ✅ |
+| **E1 长期漂移** | 1000 轮随机注入是否收敛？ | 300 轮压测 → 48 记忆(≤池×3)、plateau、LEI GREEN、avg_stab 0.80 ✅ |
+
+```bash
+python3 examples/experiments/run_all.py   # 生成 REPORT_v0.8.json
+```
+
 ---
 
 ## 快速开始
@@ -93,7 +151,7 @@ pip install liquid-loop
 
 ### 3 分钟上手
 ```python
-from liquid_loop import WorkspaceState, load, save, calculate_entropy
+from liquid_loop import WorkspaceState, load, save, calculate
 
 # 1. 创建/加载工作区
 state = WorkspaceState()  # 或 load(Path("."))
@@ -111,7 +169,7 @@ for m in state.memories:
     print(f"结晶: {m.content[:50]}... (置信度={m.confidence:.2f})")
 
 # 5. 监控认知健康
-entropy = calculate_entropy(state)
+entropy = calculate(state)
 print(f"熵值: {entropy:.4f} → {'🟢GREEN' if entropy < 0.3 else '🟡YELLOW' if entropy < 0.6 else '🔴RED'}")
 
 # 6. 持久化
@@ -167,6 +225,26 @@ print(health["CCI"], health["consensus_crystals"])
 
 ---
 
+## 定位：Self-Regulating Persistent Memory Dynamics
+
+液环的本质不是"AI 意识"，而是一套 **agent 系统的自调节持久记忆动力学（Self-Regulating Persistent Memory Dynamics for Agent Systems）**。`AuditChain + LEI(Entropy) + Memory decay` 三者组合形成闭环，使记忆从"外部管理"转向"内部自组织"：
+
+```
+   Input Evidence
+        ↓
+   Memory State  ←──────────────┐
+        ↓                        │
+   LEI Evaluation (八维熵)        │
+        ↓                        │
+   Decay / Reinforcement ────────┘
+        ↓
+   AuditChain (SHA256 链式追溯)
+```
+
+这比单独的 memory store 更接近一个可被实验检验的**动态系统**：输入驱动状态、熵评估稳定性、衰减/强化回流状态、审计链保证来源可信。
+
+---
+
 ## 架构对比
 
 ```
@@ -213,7 +291,7 @@ liquid-loop/
 │   ├── __init__.py      # 公共 API 导出
 │   ├── workspace.py     # 核心数据模型 + AuditChain + auto_classify + decay
 │   ├── storage.py       # JSON 持久化 + 审计链写入
-│   ├── entropy.py       # 四维熵值计算
+│   ├── entropy.py       # 八维熵值计算（含 CPE 三维）
 │   ├── mesh/            # MESH v2 多智能体共识协议集成（validate_evidence / compute_cci / ...）
 │   └── cli.py           # Click CLI (11 命令)
 ├── examples/
@@ -240,12 +318,16 @@ pytest -v
 
 ## 路线图
 
-- [ ] 语义一致性结晶（嵌入相似度替代精确匹配）
 - [x] 多 Agent 液环耦合（`liquid_loop.mesh` v2 共识协议，2026-07-15 落地）
-- [ ] LX 扩展：世界模型预测纳入液环
+- [x] **[v0.8] 反证轨（Evidence Graph）**：Evidence 分 support / contradiction，一致增稳、冲突降稳，驱动 memory stability score（不再"一致即真"）
+- [x] **[v0.8] 显式时间动力学**：`M(t+1) = M(t) + reinforcement − decay − contradiction_penalty`，让记忆成为"过程"而非"对象"（真正的液态循环）
+- [x] **[v0.8] 三实验全 PASS**：E2 错误记忆恢复 → E3 多 agent 冲突 → E1 长期漂移（见上节）
+- [ ] **[v0.9 优化项]**：`_detect_conflicts` 由每证据 O(g²) 两两扫描改为增量/采样（大规模高频写入性能，非正确性）
 - [ ] LoCoMo / LongMemEval 基准对比
 - [ ] 边缘端部署优化（<50KB）
 
+> 零向量是液环的硬约束：一致性判定永不引入 embedding / 相似度（这正是液环要替代的方案）。
+
 ---
 
 ## 许可证

{liquid_loop-0.7.0 → liquid_loop-0.8.0}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "liquid-loop"
-version = "0.7.0"
+version = "0.8.0"
 description = "Self-Organizing Cognitive Memory for AI Agents — Liquid Loop theory implementation"
 readme = "README.md"
 license = {text = "MIT"}