liquid-loop 0.7.1__tar.gz → 0.9.0__tar.gz

{liquid_loop-0.7.1 → liquid_loop-0.9.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: liquid-loop
-Version: 0.7.1
+Version: 0.9.0
 Summary: Self-Organizing Cognitive Memory for AI Agents — Liquid Loop theory implementation
 Author: fishbook0001
 Maintainer: fishbook0001
@@ -39,6 +39,8 @@ Dynamic: license-file
 
 # Liquid Loop
 
+![Liquid Loop Hero Banner](docs/assets/06-hero-banner.jpg)
+
 > **Self-Organizing Cognitive Memory for AI Agents** — Zero LLM dependency, pure Python implementation of the Liquid Loop theory.
 
 [![PyPI](https://img.shields.io/pypi/v/liquid-loop.svg)](https://pypi.org/project/liquid-loop/)
@@ -89,6 +91,58 @@ RED    (entropy ≥ 0.6)  — 需清理
 
 ---
 
+## 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
+```
+
+---
+
 ## 快速开始
 
 ### 安装
@@ -173,9 +227,17 @@ print(health["CCI"], health["consensus_crystals"])
 
 ---
 
-## 定位：Self-Regulating Persistent Memory Dynamics
+## 定位：Self-Regulating Memory State Evolution
+
+> **North-Star 公理（一切代码与论文围绕它校验）：**
+>
+> **Liquid Loop is not a memory storage mechanism; it is a self-regulating memory state evolution mechanism.**
+>
+> （液环不是一种记忆存储机制，而是一种自调节的记忆状态演化机制。）
+
+液环的本质不是"AI 意识 / 认知层"，而是一套 **agent 系统的自调节持久记忆动力学（Self-Regulating Persistent Memory Dynamics for Agent Systems）**。`AuditChain + LEI(Entropy) + Memory decay + Contradiction Track` 组合成闭环，使记忆从"外部管理"转向"内部自组织"。
 
-液环的本质不是"AI 意识"，而是一套 **agent 系统的自调节持久记忆动力学（Self-Regulating Persistent Memory Dynamics for Agent Systems）**。`AuditChain + LEI(Entropy) + Memory decay` 三者组合形成闭环，使记忆从"外部管理"转向"内部自组织"：
+**边界（防止退化为"智能记忆管理器"）**：记忆状态本身是一个**演化对象**，而非被管理的数据对象。市场已有的"记忆评分 / 自动删除 / 权重调整"范式把记忆当被管理的数据——液环要保护的是 **memory homeostasis（记忆稳态）**：记忆在变化环境中经 输入→吸收→凝聚→稳定→衰减→重构，自身维持一致性，而非被外部规则调度。
 
 ```
    Input Evidence
@@ -267,9 +329,11 @@ pytest -v
 ## 路线图
 
 - [x] 多 Agent 液环耦合（`liquid_loop.mesh` v2 共识协议，2026-07-15 落地）
-- [ ] **[v0.8] 反证轨（Evidence Graph）**：Evidence 分 support / contradiction，一致增稳、冲突降稳，驱动 memory stability score（不再"一致即真"）
-- [ ] **[v0.8] 显式时间动力学**：`M(t+1) = M(t) + reinforcement − decay − contradiction_penalty`，让记忆成为"过程"而非"对象"（真正的液态循环）
-- [ ] **[v0.8] 三实验**：E2 错误记忆恢复（核心）→ E3 多 agent 冲突（mesh 价值）→ E1 长期漂移（压力测试）
+- [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 长期漂移（见上节）
+- [x] **[v0.9] 冲突检测 O(g²)→O(d²)**：`_detect_conflicts` 按 content 去重后只对 distinct 内容求两两重叠（d≤g），overlap_cache 复用；语义更纯净（度量不同论点分歧），大规模高频写入性能提升（非正确性变更）
+- [x] **[v0.9] 液态算法正式落地**：时间动力学 / 反证轨 / 双轨成核在 v0.8 已实现并经 E1/E2/E3 三实验背书，v0.9 作为稳定版正式发布（README 顶部 Hero Banner 已上线）
 - [ ] LoCoMo / LongMemEval 基准对比
 - [ ] 边缘端部署优化（<50KB）
 

{liquid_loop-0.7.1 → liquid_loop-0.9.0}/README.md

@@ -1,5 +1,7 @@
 # Liquid Loop
 
+![Liquid Loop Hero Banner](docs/assets/06-hero-banner.jpg)
+
 > **Self-Organizing Cognitive Memory for AI Agents** — Zero LLM dependency, pure Python implementation of the Liquid Loop theory.
 
 [![PyPI](https://img.shields.io/pypi/v/liquid-loop.svg)](https://pypi.org/project/liquid-loop/)
@@ -50,6 +52,58 @@ RED    (entropy ≥ 0.6)  — 需清理
 
 ---
 
+## 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
+```
+
+---
+
 ## 快速开始
 
 ### 安装
@@ -134,9 +188,17 @@ print(health["CCI"], health["consensus_crystals"])
 
 ---
 
-## 定位：Self-Regulating Persistent Memory Dynamics
+## 定位：Self-Regulating Memory State Evolution
+
+> **North-Star 公理（一切代码与论文围绕它校验）：**
+>
+> **Liquid Loop is not a memory storage mechanism; it is a self-regulating memory state evolution mechanism.**
+>
+> （液环不是一种记忆存储机制，而是一种自调节的记忆状态演化机制。）
+
+液环的本质不是"AI 意识 / 认知层"，而是一套 **agent 系统的自调节持久记忆动力学（Self-Regulating Persistent Memory Dynamics for Agent Systems）**。`AuditChain + LEI(Entropy) + Memory decay + Contradiction Track` 组合成闭环，使记忆从"外部管理"转向"内部自组织"。
 
-液环的本质不是"AI 意识"，而是一套 **agent 系统的自调节持久记忆动力学（Self-Regulating Persistent Memory Dynamics for Agent Systems）**。`AuditChain + LEI(Entropy) + Memory decay` 三者组合形成闭环，使记忆从"外部管理"转向"内部自组织"：
+**边界（防止退化为"智能记忆管理器"）**：记忆状态本身是一个**演化对象**，而非被管理的数据对象。市场已有的"记忆评分 / 自动删除 / 权重调整"范式把记忆当被管理的数据——液环要保护的是 **memory homeostasis（记忆稳态）**：记忆在变化环境中经 输入→吸收→凝聚→稳定→衰减→重构，自身维持一致性，而非被外部规则调度。
 
 ```
    Input Evidence
@@ -228,9 +290,11 @@ pytest -v
 ## 路线图
 
 - [x] 多 Agent 液环耦合（`liquid_loop.mesh` v2 共识协议，2026-07-15 落地）
-- [ ] **[v0.8] 反证轨（Evidence Graph）**：Evidence 分 support / contradiction，一致增稳、冲突降稳，驱动 memory stability score（不再"一致即真"）
-- [ ] **[v0.8] 显式时间动力学**：`M(t+1) = M(t) + reinforcement − decay − contradiction_penalty`，让记忆成为"过程"而非"对象"（真正的液态循环）
-- [ ] **[v0.8] 三实验**：E2 错误记忆恢复（核心）→ E3 多 agent 冲突（mesh 价值）→ E1 长期漂移（压力测试）
+- [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 长期漂移（见上节）
+- [x] **[v0.9] 冲突检测 O(g²)→O(d²)**：`_detect_conflicts` 按 content 去重后只对 distinct 内容求两两重叠（d≤g），overlap_cache 复用；语义更纯净（度量不同论点分歧），大规模高频写入性能提升（非正确性变更）
+- [x] **[v0.9] 液态算法正式落地**：时间动力学 / 反证轨 / 双轨成核在 v0.8 已实现并经 E1/E2/E3 三实验背书，v0.9 作为稳定版正式发布（README 顶部 Hero Banner 已上线）
 - [ ] LoCoMo / LongMemEval 基准对比
 - [ ] 边缘端部署优化（<50KB）
 

{liquid_loop-0.7.1 → liquid_loop-0.9.0}/liquid_loop/__init__.py

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

{liquid_loop-0.7.1 → liquid_loop-0.9.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
@@ -249,16 +256,15 @@ class WorkspaceState:
         return a
 
     def add_evidence(self, anchor, content: str, quality: float = 1.0, agent_id: str = "",
-                     dedup: bool = False) -> Optional[Evidence]:
+                     dedup: bool = False, relation: str = "support",
+                     target_memory_id: str = "") -> Optional[Evidence]:
         """向指定锚点添加一条证据。
 
         anchor 参数兼容：锚点名称(str) | 锚点ID(str) | Anchor对象
         agent_id：多智能体共用写入者标识（缺省空=legacy/单实例）
-        dedup：幂等去重开关（默认 False）。
-            - False（默认，核心语义）：同内容可重复写入——"≥2 条一致证据自动结晶"依赖此行为
-              （README quickstart / 双轨成核 / 理论定义）。
-            - True（mesh/API 层显式启用）：同锚点+同内容+同 agent 已存在则复用，防网络重试/高频喂入膨胀。
-              幂等应由 mesh/API 层按需开启，核心模型默认不吞掉"重复观察"这一结晶信号。
+        dedup：幂等去重开关（默认 False，核心语义允许重复写入以触发结晶）。
+        relation：反证轨关系 "support"(一致, 默认) | "contradiction"(冲突) —— 见 v0.8 反证轨。
+        target_memory_id：relation="contradiction" 时可选显式指向被反驳的 memory。
         """
         target = None
         if isinstance(anchor, Anchor):
@@ -278,6 +284,7 @@ class WorkspaceState:
         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)
@@ -287,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()
@@ -389,7 +397,11 @@ class WorkspaceState:
         阈值从环境变量 LIQUID_CONFLICT_THRESHOLD 读取（默认 0.2）。
         复用 CPE 泛化防线思路：证据间平均关键词重叠 < threshold 且 >= 3 条 -> 潜在冲突/漂移。
         保守处理：只标记'需人工确认'，不武断判相反（避免过度工程化误报）。
-        使用 overlap_cache 避免重复计算。
+
+        性能（v0.9）：原 O(g²) 全量成对扫描。相同 content 的两条证据重叠恒为 1.0，
+        对"内容分歧度"无信息量，故先按 content 去重为 distinct 集，只对 distinct 内容
+        求两两重叠 -> O(d²)（d = distinct content 数 ≤ g）。overlap_cache 复用。
+        语义更纯净：度量"不同论点间的分歧"，重复写入不再稀释冲突信号。
         """
         import os
         conflict_threshold = float(os.environ.get('LIQUID_CONFLICT_THRESHOLD', '0.2'))
@@ -397,11 +409,20 @@ class WorkspaceState:
         group = [e for e in self.evidences if e.anchor_id == anchor_id]
         if len(group) < 3:
             return
+        # ── O(g²) -> O(d²)：content 去重，相同 content 对的重叠恒为 1.0 不参与分歧度量 ──
+        distinct: list = []
+        seen: set = set()
+        for e in group:
+            if e.content and e.content not in seen:
+                seen.add(e.content)
+                distinct.append(e.content)
+        n = len(distinct)
+        if n < 2:
+            return
         overlaps = []
-        for i in range(len(group)):
-            for j in range(i + 1, len(group)):
-                if group[i].content and group[j].content:
-                    overlaps.append(_keyword_overlap(group[i].content, group[j].content, self.overlap_cache))
+        for i in range(n):
+            for j in range(i + 1, n):
+                overlaps.append(_keyword_overlap(distinct[i], distinct[j], self.overlap_cache))
         if not overlaps:
             return
         avg = sum(overlaps) / len(overlaps)
@@ -441,6 +462,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.1 → liquid_loop-0.9.0}/liquid_loop.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: liquid-loop
-Version: 0.7.1
+Version: 0.9.0
 Summary: Self-Organizing Cognitive Memory for AI Agents — Liquid Loop theory implementation
 Author: fishbook0001
 Maintainer: fishbook0001
@@ -39,6 +39,8 @@ Dynamic: license-file
 
 # Liquid Loop
 
+![Liquid Loop Hero Banner](docs/assets/06-hero-banner.jpg)
+
 > **Self-Organizing Cognitive Memory for AI Agents** — Zero LLM dependency, pure Python implementation of the Liquid Loop theory.
 
 [![PyPI](https://img.shields.io/pypi/v/liquid-loop.svg)](https://pypi.org/project/liquid-loop/)
@@ -89,6 +91,58 @@ RED    (entropy ≥ 0.6)  — 需清理
 
 ---
 
+## 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
+```
+
+---
+
 ## 快速开始
 
 ### 安装
@@ -173,9 +227,17 @@ print(health["CCI"], health["consensus_crystals"])
 
 ---
 
-## 定位：Self-Regulating Persistent Memory Dynamics
+## 定位：Self-Regulating Memory State Evolution
+
+> **North-Star 公理（一切代码与论文围绕它校验）：**
+>
+> **Liquid Loop is not a memory storage mechanism; it is a self-regulating memory state evolution mechanism.**
+>
+> （液环不是一种记忆存储机制，而是一种自调节的记忆状态演化机制。）
+
+液环的本质不是"AI 意识 / 认知层"，而是一套 **agent 系统的自调节持久记忆动力学（Self-Regulating Persistent Memory Dynamics for Agent Systems）**。`AuditChain + LEI(Entropy) + Memory decay + Contradiction Track` 组合成闭环，使记忆从"外部管理"转向"内部自组织"。
 
-液环的本质不是"AI 意识"，而是一套 **agent 系统的自调节持久记忆动力学（Self-Regulating Persistent Memory Dynamics for Agent Systems）**。`AuditChain + LEI(Entropy) + Memory decay` 三者组合形成闭环，使记忆从"外部管理"转向"内部自组织"：
+**边界（防止退化为"智能记忆管理器"）**：记忆状态本身是一个**演化对象**，而非被管理的数据对象。市场已有的"记忆评分 / 自动删除 / 权重调整"范式把记忆当被管理的数据——液环要保护的是 **memory homeostasis（记忆稳态）**：记忆在变化环境中经 输入→吸收→凝聚→稳定→衰减→重构，自身维持一致性，而非被外部规则调度。
 
 ```
    Input Evidence
@@ -267,9 +329,11 @@ pytest -v
 ## 路线图
 
 - [x] 多 Agent 液环耦合（`liquid_loop.mesh` v2 共识协议，2026-07-15 落地）
-- [ ] **[v0.8] 反证轨（Evidence Graph）**：Evidence 分 support / contradiction，一致增稳、冲突降稳，驱动 memory stability score（不再"一致即真"）
-- [ ] **[v0.8] 显式时间动力学**：`M(t+1) = M(t) + reinforcement − decay − contradiction_penalty`，让记忆成为"过程"而非"对象"（真正的液态循环）
-- [ ] **[v0.8] 三实验**：E2 错误记忆恢复（核心）→ E3 多 agent 冲突（mesh 价值）→ E1 长期漂移（压力测试）
+- [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 长期漂移（见上节）
+- [x] **[v0.9] 冲突检测 O(g²)→O(d²)**：`_detect_conflicts` 按 content 去重后只对 distinct 内容求两两重叠（d≤g），overlap_cache 复用；语义更纯净（度量不同论点分歧），大规模高频写入性能提升（非正确性变更）
+- [x] **[v0.9] 液态算法正式落地**：时间动力学 / 反证轨 / 双轨成核在 v0.8 已实现并经 E1/E2/E3 三实验背书，v0.9 作为稳定版正式发布（README 顶部 Hero Banner 已上线）
 - [ ] LoCoMo / LongMemEval 基准对比
 - [ ] 边缘端部署优化（<50KB）
 

{liquid_loop-0.7.1 → liquid_loop-0.9.0}/pyproject.toml

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