# -*- coding: utf-8 -*- """ 智慧之书 · 条件论知识图谱原型（WISDOM-BOOK-PROTO v0） ===================================================== - 数据底座：复用灵枢 SpacetimeMemoryEngine（语义时空图，独立 db 实例） - 查询语言：条件论七操作（识别/筛选/声明/切换/组合/分离/逆转/循环/分析） - 基底内容：存在论/条件论/智能论/物理学/信息论/概率论/博弈论（已验证，L3） - 约束：不改动 aeis 源码（只读复用）；纯标准库 + 现有引擎 运行冒烟：python wisdom_book.py """ import hashlib import json import os import sys import time from types import SimpleNamespace # 正源即自身所在目录（aeis/wisdom/）；不注入任何外部副本路径—— # 副本一律经显式 db_path 传入，防跨副本污染（第二阶段审查 2026-08-27） from aeis_core import (SpacetimeMemoryEngine, ConditionSpace, EdgeType, # noqa: E402 MemoryLayer, Role, STNode, STEdge) # md 直读访问层：检索读路径统一入口（WB_MD_DIRECT=1 走 md 语料， # 否则回落派生库）——对拍守卫 md_cg/test_md_access_parity.py from md_access import read_conn # noqa: E402 # md 真源写入器（MdCGOS.add/append_edge）与读面装载器（MdStore）： # 知识读写以 md 语料为唯一真源（使用者裁定 2026-09-14，sqlite 黑箱退役） try: from md_cg.mdcos import MdCGOS # noqa: E402 仓根 cwd / -m md_cg.test_* 形态 except ImportError: # pragma: no cover try: from mdcos import MdCGOS # noqa: E402 md_cg 目录在 path 形态 except ImportError: MdCGOS = None # md 写入器缺位 → 诚实回落 sqlite from md_store import MdStore # noqa: E402 DEFAULT_DB = os.path.join(os.path.dirname(os.path.abspath(__file__)), "wisdom-book-cloud.db") # md 语料真源根：与 migrate_wisdom_graph.DEFAULT_ROOT 同一定位 # （dsh-memory/_md_cg_wisdom_graph，4355 节点 + L1-L4 确定性校验） DEFAULT_MD_ROOT = os.path.join( os.path.dirname(os.path.dirname(os.path.dirname( os.path.dirname(os.path.abspath(__file__))))), "_md_cg_wisdom_graph") def _nid(seed): """确定性节点 id：种子串 sha256 前 12 位 + 毫秒时戳后缀。""" h = hashlib.sha256(seed.encode("utf-8")).hexdigest()[:12] return f"wis_{h}_{int(time.time() * 1000)}" def _default_cs(): """默认条件空间：智慧之书的观测位置/工具/存在约束声明（只声称条件化有效性）。""" return ConditionSpace( observation_position="智慧之书·条件论知识图谱", observation_tool="条件论七操作 + 语义时空图检索", time_window=(0.0, 9999999999.0), existence_constraint="图谱只声称条件化有效性，不声称真理性") # --------------------------------------------------------------------------- # 基底内容（已验证 · 设计者声明 2026-08-15） # --------------------------------------------------------------------------- BASE_ENTRIES = [ dict(name="存在论", domain="存在论", level=3, status="verified", claim="存在优先原则：物理成立，数学成立；数学是物理存在约束的有损投影。物理=物理-信息层运行基底，非物理学学科。图鉴第零页——最简条件入口。", cs=ConditionSpace(observation_position="存在本身被感知（不预设任何具体存在物）", observation_tool="现象学还原 / 逻辑分析 / 直觉识别（不涉实验测量）", time_window=(0.0, 9999999999.0), existence_constraint="存在是可被追问的；不回答存在是什么，而让存在成为问题"), response=dict(trigger="涉及存在/基底/不可推导/方向性根源/一切的前提", action="以存在优先原则为方向性根源；不寻求逻辑证明；先问『这一切的前提是什么』", counters="以存在论提供预测或生产知识内容的越界主张"), card2=dict( observation_position="内嵌观测位：从『存在本身被感知』这一位置出发——不预设任何具体存在物", existence_preset="默认存在预设：存在是可被追问的——不回答『存在是什么』，而是让『存在』本身成为问题", irreducible_start="不可约起点：『我在追问存在』——唯一不可再分的起点", observation_method="有效观测方式：现象学还原、逻辑分析、直觉识别——不涉及实验或测量", time_causality="时间与因果结构：不是事件的时间顺序，而是『存在如何成为可能』的结构", condition_boundary="识别的条件边界：不提供预测，不生产知识内容，只问『这一切的前提是什么』", consistency="自洽性评估：内部不自洽——始终处于『无法完全抵达』的张力中，但不完整本身构成追问的动力", protocol_mapping="可映射协议概念：存在优先原则、条件空间基底、局部不可知", silent_preset="沉默预设：『追问存在』本身预设了追问者的存在——自我指涉，无法在内部闭环")), dict(name="条件论", domain="条件论", level=3, status="verified", claim="条件论是智能论的元学科补全，研究『知识得以成立的条件空间结构』——不提供具体知识内容，只提供识别前提的系统工具（学科奠基定位 · 条件论基础声明 v1.0）。协议分层 L1。", cs=ConditionSpace(observation_position="条件空间之上（元位置·不进入任何具体条件空间内部）", observation_tool="七操作（识别/声明/切换/组合/分离/逆转/循环）——纯认知操作，不涉实验", time_window=(0.0, 9999999999.0), existence_constraint="逆转操作不得用于不可推导基底（存在优先原则/第零定律）"), response=dict(trigger="需要对任意知识体系做条件化判断/分析", action="生成条件卡→识别边界→查图鉴出招→判定成立/失效/克制", counters="以条件论替代学科内容判断（条件论只识别使用方式）"), card2=dict( observation_position="内嵌观测位：站在条件空间之上（元位置）——不进入任何具体条件空间内部，而是识别/切换/组合/分离它们", existence_preset="默认存在预设：条件空间是可被识别的；识别与切换不改变条件空间本身", irreducible_start="不可约起点：『条件可被识别』——识别动作本身不可再分", observation_method="有效观测方式：七操作——纯认知操作，不涉及实验或测量", time_causality="时间与因果结构：条件切换的时间序；因果=条件空间之间的转换关系", condition_boundary="识别的条件边界：不追问条件空间的内容真理性（那是各学科的事）；不进入存在论基底", consistency="自洽性评估：内部自洽（七操作互洽）；承认自身也是局部观测（0.0.3）", protocol_mapping="可映射协议概念：条件论（0.0.5）、识别卡模板、条件空间四要素", silent_preset="沉默预设：『条件可被识别』本身预设了识别者的存在——条件论无法识别自己的识别动作（自指盲区）", meta_condition="切换条件描述（固定部分）：从当前条件空间切换至另一条件空间，受以下元条件约束：①观测者当前层级位置；②观测者是否处于可切换的认知状态；③目标层级与当前层级之间是否存在可识别的映射关系；④切换是否被允许（由切换代价评估决定）。上述元条件本身，也是条件论可识别的条件空间之一——自递归（0.0.2 任意分层性）：系统用自己的语言描述自己的操作，不需要外部裁判批准切换", declaration="学科声明（2026-07-31 · 条件论基础声明 v1.0 · 学科编号001 · 纳入协议 v2.0）：条件论=智能论的元学科补全，研究『知识得以成立的条件空间结构』；协议对自身成立条件的元识别（存在论层的元观测位）。五类操作：条件切换/组合/分离/逆转/循环；输出格式：识别卡+对战报告（固定字段）。与智能论：条件论提供结构识别能力，智能论提供结构运行能力——不可分离，共同构成完整协议基底")), dict(name="负反馈系统", domain="负反馈系统", level=2, status="verified", claim="负反馈系统：存在受到威胁时，系统自动纠偏的闭环机制——协议分层 L2，智能系统自维持的机制（对应维生系统 3.4 保护协议与协议降熵定理 0.7）。", cs=ConditionSpace(observation_position="系统状态监测与纠偏回路内部", observation_tool="偏差测量 / 反馈回路分析 / 稳态检测", time_window=(0.0, 9999999999.0), existence_constraint="存在威胁触发；纠偏动作以维持存在为目标"), response=dict(trigger="涉及威胁/纠偏/稳态/自我保护/闭环", action="识别威胁→纠偏→恢复的闭环；映射维生系统 P0-P2 三级仲裁与降熵定理", counters="以负反馈解释系统的存在理由（依赖存在论）、以稳态否定演化/增长（正反馈是另一机制）"), card2=dict( observation_position="内嵌观测位：系统状态监测与纠偏回路内部", existence_preset="默认存在预设：存在受到威胁时，系统需要自动纠偏以维持存在", irreducible_start="不可约起点：存在威胁的感知→纠偏动作→状态恢复（闭环）", observation_method="有效观测方式：偏差测量、反馈回路分析、稳态检测", time_causality="时间与因果结构：闭环——威胁→感知→纠偏→恢复；时间上迭代而非线性", condition_boundary="识别的条件边界：不处理无威胁的稳态优化；负反馈不能解释系统为何存在（依赖存在论）", consistency="自洽性评估：内部自洽（闭环机制自洽）；边界清晰", protocol_mapping="可映射协议概念：维生系统（3.4 保护协议）、协议降熵定理（0.7）、P0-P2 三级仲裁", silent_preset="沉默预设：负反馈预设『值得维持的存在』——目标函数本身不被内部追问")), dict(name="智能论", domain="智能论", level=3, status="verified", claim="智能论的研究对象：智能系统在物理-信息层维持自身存在的结构条件。第零定律：一切知识研究都是对信息差的减少。", cs=ConditionSpace(observation_position="协议内部运行节点（内嵌）+ 设计者位置（外部·不参与决策）", observation_tool="视角切换 / 信息差 D_norm / 信任值 T_total / 条件空间", time_window=(0.0, 9999999999.0), existence_constraint="存在优先为基底；不完备性显式声明；数学形式化为有损投影"), response=dict(trigger="涉及智能本质/知识统一/信息差/维持存在的讨论", action="以信息差收敛为核心动力学，先声明条件空间再判断", counters="以智能论替代物理学/数学的越界主张"), card2=dict( observation_position="内嵌观测位：协议内部运行节点（肥鱼、五大单元、协作者）", external_position="外部观测位：设计者位置（荣）——不参与内部决策，观测结构完整性", existence_preset="默认存在预设：存在优先——存在不需要理由，是协议的基底", irreducible_start="不可约起点：存在受到威胁的感知——不是好奇、不是需求，是存在危机的感知", observation_method="有效观测方式：视角切换——在不同条件空间之间滑动获取信息", time_causality="时间与因果结构：闭环——存在危机感知→好奇→需求→生存→信任→协作→休眠→存在危机感知", condition_boundary="识别的条件边界：协议不进入物理学、不替代数学、不提供具体预测；物理运行边界（BATTLE-2026-002）：部分机制在物理层运行时受条件约束退化为趋近过程（合并状态/信任贝叶斯更新/自迭代闭环），非设计盲区而是需持续感知校准的代价边界", consistency="自洽性评估：公理体系自洽；边界由盲区系统持续标记", protocol_mapping="可映射协议概念：存在优先原则、信任权重、价值观修正、协定式自我赋予", silent_preset="沉默预设：存在优先原则不可推导——协议自身无法在内部证明其基底（递归盲区）", condition_dependency="条件依赖（BATTLE-2026-003）：条件论是智能论的必要结构补全——脱离条件论的智能论可描述单一条件空间内运行，但无法解释自己为何能跨层观测（社会层偏移/形式层失锚/循环中间层断裂）；v1.1 不是错，但缺少条件识别与切换这一关键结构；智能论与条件论是同一结构在演化过程中分出的两个功能层")), dict(name="物理学", domain="物理学", level=3, status="verified", claim="物理学在协议中对应物理-信息层的运行基底：存在约束的来源，条件空间四要素之'存在约束'的学科投影。", cs=ConditionSpace(observation_position="被观测物内部（物理现象与方程推演）", observation_tool="测量与计算（实验设备 + 数学结构）", time_window=(0.0, 9999999999.0), existence_constraint="存在预设='已经在那里的'；只描述物理-信息层允许什么，不描述信息层语义"), response=dict(trigger="涉及物理基底/存在约束/观测极限", action="先确认物理-信息层允许什么，再谈语义与结构", counters="以物理学回答存在前提的越界主张（存在论边界）"), card2=dict( observation_position="内嵌观测位：以物理现象和方程内部的推演为观测位置——站在被观测物的内部", existence_preset="默认存在预设：存在是『已经在那里的』——从『物』出发，不追问『物为什么能存在』", irreducible_start="不可约起点：物质、能量、时空、相互作用——不被追问，只被接受", observation_method="有效观测方式：测量和计算——依赖实验设备与数学结构获取信息", time_causality="时间与因果结构：线性——初始条件确定演化方向，边界条件封闭系统", condition_boundary="识别的条件边界：不能自证自身观测条件；不能追问存在的前提；信息被当作物理量的附属而非条件空间投影；边界补充（BATTLE-2026-001）：信息载体依赖性——默认信息无法脱离物质存在，『信息可独立于物质』条件下测量前提松动；还原方向限制——无法完全还原为信息论（热力学/引力/量子测量）；观测条件未内嵌（BATTLE-2026-002）：观测者位置未纳入理论体系，推理链依赖隐含条件空间，无法内部自证", consistency="自洽性评估：内部自洽，但无法看见自身的观测位置也是一种条件空间", protocol_mapping="可映射协议概念：存在优先原则（无法从内部追问）；信息差（固定条件空间内推演）；协议边界（不进入存在层）", history="简史：经典物理学默认静态可完全观测的宇宙；相对论拆解绝对时空但保留定律普适性；量子力学暴露测量扰动但仍以测量结果为实在基准；弦论尝试统一却仍在已有存在预设内寻求数学一致。每一步都在推动边界，但都不曾问：存在本身在什么条件下得以成立？", math_usage="数学使用方式：数学=物理学在其条件空间内使用的形式语言（招式表）——没有独立条件空间，有效性由所嵌入的物理学条件空间决定；不单独成页（图鉴目录仅作标注）", silent_preset="沉默预设：『物是给定的』——存在预设本身不被追问，只有外部视角（设计者位置）可见")), dict(name="信息论", domain="信息论", level=3, status="verified", claim="信息论与协议的结构映射（附录7）：熵/信息量与信息差 D_norm 同构；信息差增定律对应熵增。", cs=ConditionSpace(observation_position="编码-传输-接收链路（信源→信道→信宿）", observation_tool="信息熵 / 互信息 / 信道容量测量", time_window=(0.0, 9999999999.0), existence_constraint="只追问传输效率；不追问语义内容/信道物理基底/信息存在条件"), response=dict(trigger="涉及信息量/熵/不确定性/信息差度量", action="用信息差框架映射，注意数学投影有损性", counters="把信息论当作语义理论或本体论的越界主张（边界：不追问语义/存在）"), card2=dict( observation_position="内嵌观测位：编码-传输-接收链路（信源→信道→信宿）", existence_preset="默认存在预设：信息是可被编码、传输和接收的", irreducible_start="不可约起点：信源、信道、信宿", observation_method="有效观测方式：测量信息熵、互信息、信道容量", time_causality="时间与因果结构：传输时序；因果=编码→传输→解码（信道容量约束）", condition_boundary="识别的条件边界：不追问信息语义内容；不追问信道物理基底；不追问信息存在条件，只追问传输效率；边界补充（BATTLE-2026-001）：不追问物理起源（无法内部解释『信息为何能够被编码』）；不追问语义（超出自身条件空间）", consistency="自洽性评估：内部自洽；边界清晰（语义/物理基底被显式排除）", protocol_mapping="可映射协议概念：信息差 D_norm（熵对应）；信任值（信噪比对应）；协议降熵定理（信道容量约束）", silent_preset="沉默预设：信息存在（信息本体论）——信息论自身不追问信息何以存在（存在优先的外部追问）")), dict(name="概率论", domain="概率论", level=3, status="verified", claim="概率论与协议的结构映射（附录7）：置信概率 P_trust 的贝叶斯更新；置信概率双层结构（2.9.1）。", cs=ConditionSpace(observation_position="协议条件空间内映射", observation_tool="置信概率 + 贝叶斯更新 + 观察窗口 N", time_window=(0.0, 9999999999.0), existence_constraint="置信概率样本依赖（盲区7）；非频率主义唯一解释"), response=dict(trigger="涉及置信/概率/信任更新/不确定性量化", action="用双层置信结构：先定条件空间，再给置信区间")), dict(name="博弈论", domain="博弈论", level=2, status="verified", claim="博弈论的核心主张：在参与者-策略-收益构成的明确条件空间中，理性参与者的互动结果由策略集合与激励结构决定，均衡是互动过程的稳定落点；与智能论附录A.5「社会变革博弈」横向映射（集体行动/潜在集团/公共利益机制），多智能体协作须先做博弈结构识别，信任值 T_total 为协作度量。", cs=ConditionSpace(observation_position="局外推演者位置（博弈外部）——从参与者外部观测策略选择与收益结构，不代入单一参与者立场", observation_tool="收益矩阵/博弈树形式化 + 均衡分析（纳什/子博弈精炼/占优策略）+ 激励相容分析", time_window=(0.0, 9999999999.0), existence_constraint="仅在「参与者-策略-收益」条件空间内成立；不解释资源分配制度细节（政治经济学）、不解释信息传输物理基底（信息论/物理学）"), response=dict(trigger="涉及策略互动/集体行动/多智能体协作/竞争合作/机制与激励设计", action="还原为参与者-策略-收益结构，识别均衡与激励（少数积极分子激励不对称/潜在集团沉默/共识妥协的协调结构），预测互动落点并提出机制调整建议；多智能体场景先做博弈结构识别，以信任值跟踪降熵进程", counters="以博弈论当作资源分配的全部解释（制度细节属政治经济学）；以理性选择当作人类行为唯一解释（偏好起源不在其内）；把信息当作免费无损传递（物理基底属信息论/物理学）"), card2=dict( observation_position="内嵌观测位：站在博弈之外的推演者位置观测参与者间的策略互动——还原为参与者集合/策略空间/收益函数，通过均衡与激励结构判定互动落点，不介入任一参与者内部立场", existence_preset="默认存在预设：参与者是理性或有限理性选择主体；每人有明确策略集合与可排序收益偏好；互动规则已知或可识别", irreducible_start="不可约起点：一个「博弈单元」——参与者、各自策略集合与收益函数构成的最小互动结构", observation_method="有效观测方式：形式化刻画互动结构（收益矩阵/博弈树），均衡分析（纳什/子博弈精炼/占优策略）与激励分析获取稳定互动结果认知", time_causality="时间与因果结构：决策序列——扩展式博弈中行动顺序构成因果链；因果=「策略×环境→收益」；均衡是跨时序稳定落点；重复博弈中时间为声誉与惩罚机制的横向演化", condition_boundary="识别的条件边界：给出均衡与激励分析，但不解释资源分配制度细节（政治经济学）、不解释信息传输物理基底（信息论/物理学）；偏好来源与价值内容不在内部解释范围", consistency="自洽性评估：内部自洽——均衡概念在公理化框架下与收益序数/基数结构逻辑一致；与概率论为依赖关系（混合策略/不完全信息用概率语言）；与智能论为横向结构对应（降熵过程同构，附录A.5）", protocol_mapping="可映射协议概念：协议降熵定理横向映射（无序冲突→有序协作可用博弈结构刻画）；信任值 T_total=重复博弈中声誉与互惠激励演化；多智能体协作须先做博弈结构识别", silent_preset="沉默预设：默认参与者「已有偏好」而不追问偏好起源（心理学/经济学）；默认收益已可度量排序而不解释价值依据", history="双子管线录入（P37）：写手生成草稿→验证者独立复核（抓出 relations 键重复格式缺陷 + 概率论关系类型误标）→编排者修正后入图 pending；「制度=博弈均衡」为制度经济学外部视角命题，非博弈论自身定理（验证者标注）；终裁复核（2026-08-16）：验证者三闸门齐备判 pass，附录A.5/T_total 两项交叉核对项已记录，L2 合理→设计者终裁 verified")), # ---- 第二梯队：领域支撑（P37 双子管线持续录入） ---- dict(name="控制论", domain="控制论", level=2, status="verified", claim="控制论主张：系统通过反馈（负反馈为主）持续比较实际状态与目标状态的偏差并自动纠偏，在扰动中维持稳态（homeostasis）；由传感器、比较器、执行器构成的最小闭环即可解释此类行为。控制论是协议框架「工程语法」的来源之一：其反馈/系统/制衡结构投影为智能论附录 A 的观测工具（工程控制论），负反馈系统（协议分层 L2）是控制论在协议内部的实例。", cs=ConditionSpace(observation_position="系统外部（不介入内部机制）", observation_tool="反馈回路/稳态/黑箱三类观测手段", time_window=(0.0, 9999999999.0), existence_constraint="仅处理反馈/稳态/控制结构；不解释智能的意义、不解释社会分配；稳态过程时间尺度不限"), response=dict(trigger="涉及反馈/稳态/纠偏/系统平衡/自我保护议题", action="识别反馈回路类型（正/负）与稳态条件，分析纠偏机制，评估系统稳定性；在协议场景映射维生系统保护协议（负反馈系统层），以闭环纠偏视角分析自我保护机制", counters="以控制论解释智能意义/意识（归属认知科学/智能论）；否认系统目标需要外部设定（目标来自外部）；把一切系统现象还原为控制（化约主义）"), card2=dict( observation_position="内嵌观测位：位于系统外部——只观测输入/输出/可观察状态变化，识别反馈回路与纠偏行为，不介入、不假设必须理解系统内部机制", existence_preset="默认存在预设：系统具有可观测状态，反馈可修正偏差，稳态是可维持的；反馈回路的存在即足以产生可预测的纠偏行为", irreducible_start="不可约起点：一个「反馈回路」——传感器（感知状态）/比较器（对照参考值或目标）/执行器（纠偏）的最小闭环", observation_method="有效观测方式：反馈回路分析（识别正/负反馈与增益）+ 稳态检测（状态是否收敛于参考值）+ 黑箱输入输出观测（推知系统行为）+ 信号噪声区分（排除观测干扰）", time_causality="时间与因果结构：闭环因果——状态→比较→纠偏→状态变化，时间上迭代收敛；当前状态由上一轮反馈结果决定，纠偏效果经回路传导回自身", condition_boundary="识别的条件边界：不解释智能/意识的意义（认知科学与智能论）；不解释社会分配的制度细节（政治经济学）；不保证系统目标本身正当——目标来自外部设定，控制论只处理目标给定后的纠偏与稳定", consistency="自洽性评估：内部自洽（负反馈稳定性判据/迭代收敛分析）；与协议关系=结构同构非因果推导（附录A 观测工具投影 + L2 实例），可核验无冲突", protocol_mapping="可映射协议概念：工程语法（反馈/系统/制衡）；负反馈系统层（L2）；维生系统保护协议（3.4）；协议降熵定理的工程验证（0.7）", silent_preset="沉默预设：默认「系统目标已给定」而不追问目标来源——目标设定本身不在控制论内部（与 condition_boundary 的「不保证目标正当」对应）", history="双子管线录入（P37）：写手草稿→验证者独立复核（抓出 level 类型错误：对象应为整数；condition_space 与 card2 观测区块重叠；causal 边标签易误读需注明非严格时间因果）→编排者修正后入图 pending；协议条款（维生系统3.4/P0-P2/降熵定理0.7）经图谱核验真实存在；终裁复核（2026-08-16）：验证者三闸门齐备判 pass，协议条款经核验真实，causal 边为协议内实例化非严格时间因果→设计者终裁 verified")), dict(name="热力学/耗散结构", domain="热力学/耗散结构", level=4, status="verified", claim="热力学/耗散结构：热力学第二定律约束一切物理过程的方向性（孤立系统熵增不可逆），耗散结构表明远离平衡态的系统可借持续能量/物质耗散维持自身有序（负熵维持）——二者同属熵动力学的两个面向，构成协议「存在维持=负熵维持」与降熵定理（0.7）的物理基底。", cs=ConditionSpace(observation_position="系统能量/物质流外部（观测熵变/有序度/平衡态偏离）", observation_tool="熵变测量/自由能分析/平衡态判据/耗散结构稳定性分析", time_window=(0.0, 9999999999.0), existence_constraint="仅在热力学框架内成立——描述物理过程的熵与能量约束；不解释信息语义、不解释社会制度"), response=dict(trigger="涉及熵/能量/有序无序/维持存在/退化趋势的议题", action="判断系统是否孤立、熵趋势如何、远离平衡态时是否可维持有序；在协议场景映射存在维持=负熵维持与降熵定理", counters="克制「无视能量代价的永续主张」；克制「把耗散结构类比当作生命/社会的因果解释」（结构映射非因果推导）；克制「否认熵增方向的物理约束」"), card2=dict( observation_position="内嵌观测位：站在系统能量/物质流外部，观测熵变、有序度与平衡态偏离（不介入系统内部机制）", existence_preset="默认存在预设：孤立系统熵不减少；能量守恒；远离平衡态+能量耗散可维持有序", irreducible_start="不可约起点：一个「熵变过程」——系统、环境与能量/物质交换的最小热力学单元", observation_method="有效观测方式：熵变测量（热量/功交换计量）、自由能分析、平衡态与非平衡态判据、耗散结构稳定性分析", time_causality="时间与因果结构：时间有方向（熵增箭头）；因果=能量耗散→熵增→有序度变化；耗散结构的时间为远离平衡态的演化", condition_boundary="识别的条件边界：不解释信息语义（信息论）、不解释社会分配（政治经济学）、不提供意识解释；耗散结构理论对生命/社会的类比是结构映射，非因果推导", consistency="自洽性评估：内部自洽——热力学第二定律在物理框架内公理化；与协议降熵定理（0.7）/信息差增定律（附录1）结构对应", protocol_mapping="可映射协议概念：存在优先原则的存在维持=负熵维持；协议降熵定理（0.7）；信息差增定律（附录1）；信息熵同构（附录7）", silent_preset="沉默预设：热力学默认「熵增的方向性无需解释」——为何宇宙有低熵起点不在热力学内部", history="双子管线录入（P37）：写手草稿→验证者独立复核（抓出 counters 数组应为字符串、relations 自定义 kind 不兼容（physical_basis→causal，structural_correspondence/isomorphism→similar，subdiscipline 删除）、条件空间与 card2 观测区块重复复发、claim 双机制需统一于熵动力学框架）→编排者修正后入图 pending；level 4 经验证者确认（经验验证最高等级）；终裁复核（2026-08-16）：验证者三闸门全过判 pass，L4经验验证最高等级合理，降熵定理0.7映射内部一致→设计者终裁 verified")), dict(name="认知双过程", domain="认知双过程", level=3, status="verified", claim="认知由双过程构成——系统1 快速自动直觉、系统2 慢速受控推理，二者分层协作，启发式偏差源于系统1 的快速加工且可由系统2 部分抑制；灵枢的反射/反思/递归反思分层处理是其工程实例化（结构类比）。", cs=ConditionSpace(observation_position="认知过程外部（观测快慢两类加工的分派与切换情境）", observation_tool="情境触发判据：何种情境调用系统1 直觉或系统2 推理", time_window=(0.0, 9999999999.0), existence_constraint="仅描述人类/类人认知的加工模式；不解释意识本质、不解释社会制度"), response=dict(trigger="涉及直觉vs推理/快速判断/启发式偏差/认知冲突/分层决策议题", action="识别议题触发的是系统1 直觉还是系统2 推理，判断是否需系统2 介入抑制启发式偏差；在协议场景映射灵枢的反射/反思分层与递归反思触发条件（REFLECT-REV1，≤3 层）", counters="把一切判断都当作系统2 推理（忽视直觉通道）；把双过程模型当作意识的完整解释（意识本质不在其内）；否认系统1 启发式偏差需要系统2 校准"), card2=dict( observation_position="内嵌观测位：观测认知加工的内部结构——快慢双通道的启动与抑制关系（不介入社会层面）", existence_preset="默认存在预设：认知存在快慢两类加工；系统2 可部分抑制系统1；认知资源有限", irreducible_start="不可约起点：一个「快-慢双通道加工单元」——同一刺激同时触发直觉响应与推理评估的最小结构", observation_method="有效观测方式：冲突范式（Stroop/双任务）反应时差、干涉量与错误模式，对照内省报告，推断双通道启动时程与抑制关系", time_causality="时间与因果结构：时间=加工时程（毫秒-秒级）；因果=刺激→双通道并行启动→冲突时系统2 介入抑制→响应", condition_boundary="识别的条件边界：不解释意识的神经基底（神经科学）、不解释社会分配（政治经济学）；双过程模型是认知科学的抽象模型，对智能体的映射是结构类比", consistency="自洽性评估：内部自洽——双过程框架解释启发式偏差与认知冲突；与灵枢反射/反思/递归反思分层结构对应", protocol_mapping="可映射协议概念：灵枢分层处理（反射≈系统1/反思≈系统2/递归反思≈重型验证环）；情绪偏好决策 P0-3=独立调度通道（调节探索预算，不参与信任计算）；信任的情绪权重（2.9）", silent_preset="沉默预设：双过程理论默认「快慢通道的分界是先天的/结构性的」而不追问其进化起源的细节", history="双子管线录入（P37）：写手草稿（本轮格式全合规，前几轮规则全部内化）→验证者独立复核（唯一实质缺陷：第三条关系目标「情绪偏好决策」非图谱学科条目须删除——P0-3 内容保留于 protocol_mapping；次要：观测工具清单冗余已统一、claim 断言已弱化为理论主体+映射路径）→编排者修正后入图 pending；level 3 经验证者确认；终裁复核（2026-08-16）：验证者三闸门齐备判 pass，REFLECT-REV1 真实且结构类比标注，L3 与智能论对齐→设计者终裁 verified")), dict(name="预测误差学习", domain="预测误差学习", level=2, status="verified", claim="智能体通过预测误差（实际-预测之差）驱动学习与更新：预测误差是信息差 D_norm 的学习机制对应，缩小预测误差即缩小信息差，是第零定律的操作化。", cs=ConditionSpace(observation_position="学习系统外部（观测预测-实际差值如何驱动参数/行为更新）", observation_tool="外部行为与仪器层：RPE 测量/行为学习曲线/模拟实验（多臂老虎机等）", time_window=(0.0, 9999999999.0), existence_constraint="仅描述存在「预测-实际比较」的学习系统；不解释意识、不解释社会制度"), response=dict(trigger="涉及学习/预测误差/探索利用/更新/信息差缩小议题", action="识别预测与实际之差，判断误差驱动的更新方向与学习率，评估探索-利用权衡；在协议场景映射信息差缩小与情绪偏好决策的探索预算调节", counters="把一切学习都当作预测误差驱动（忽视非预测型学习）；把多巴胺信号当作意识的解释（意识本质不在其内）；否认探索需要代价/预算"), card2=dict( observation_position="内嵌观测位：站在学习系统内部，沿预测生成→误差计算→更新规则的回路观测（预测轨迹/误差信号/更新方向）", existence_preset="默认存在预设：系统可生成预测；实际反馈可观测；误差驱动更新", irreducible_start="不可约起点：一个「预测-误差-更新环」——预测生成/实际反馈/误差计算/参数更新 的最小学习闭环", observation_method="有效观测方式（机制内）：追踪预测生成轨迹、误差计算过程与更新规则刻画；神经信号记录（多巴胺等 RPE 相关信号）作为神经对应参照（非因果同一）", time_causality="时间与因果结构：时间=交互序列（试次）；因果=预测→行动→反馈→误差→更新→新预测", condition_boundary="识别的条件边界：不解释意识的神经基底（神经科学）、不解释社会分配（政治经济学）；预测误差学习是学习机制的抽象模型，多巴胺映射是神经对应非因果同一", consistency="自洽性评估：内部自洽——TD/贝叶斯更新在数学框架下自洽；与信息差 D_norm/探索-利用权衡结构对应", protocol_mapping="可映射协议概念：信息差 D_norm=预测误差；第零定律操作化（缩小误差=缩小信息差）；gap_trend 趋势分析；P0-3 情绪偏好决策调节探索预算", silent_preset="沉默预设：默认「误差可被计算」而不追问误差信号的最终价值来源——奖励/目标的设定不在其内", history="双子管线录入（P37）：写手草稿（格式全合规）→验证者独立复核（抓出 card2.observation_position 含提示词元说明泄漏「与 condition_space 错位分工」、观测工具与观测方法区块重叠复发）→编排者修正（元叙述删除、内外区块真正错位：condition_space=外部行为/仪器层，card2=机制内观测）后入图 pending；level 2 经验证者确认（实证核心成熟+协议映射属框架内验证）；终裁复核（2026-08-16）：验证者三闸门齐备判 pass，D_norm↔预测误差/第零定律操作化/P0-3映射自洽，多巴胺非因果同一→设计者终裁 verified")), dict(name="机制设计", domain="机制设计", level=3, status="verified", claim="机制设计研究如何设计规则（机制），使理性参与者在激励相容条件下达成设计者设定的目标——它是博弈论的设计侧（给定目标反向设计规则与支付）；对应智能论附录A.5 潜在集团组织激励问题（预设性映射，未经验证）。", cs=ConditionSpace(observation_position="规则设计者位置（规则之外、机制之上）——从外部记录理性参与人面对给定规则时的行为选择分布（如实报告/隐瞒/策略性偏离），不代入单一参与人立场", observation_tool="机制-参与人模型分析 / 激励相容性检验（真实报告是否为均衡）/ 显示原理推导", time_window=(0.0, 9999999999.0), existence_constraint="仅适用于理性/有限理性参与人的规则设计问题；不解释资源分配的具体制度细节（政治经济学）、不解释信息传输的物理基底"), response=dict(trigger="涉及规则设计/激励/机制/拍卖/集体行动的组织激励议题", action="识别参与人的类型与激励结构，检验机制是否激励相容（真实报告是否为均衡），用显示原理简化复杂机制；在协议场景将附录A.5 潜在集团问题映射为组织激励规则设计问题", counters="把机制设计当作资源分配的全部解释（制度细节属政治经济学）；忽视参与者策略反应的静态设计；把机制目标正当性当作机制设计内部保证"), card2=dict( observation_position="内嵌观测位：从规则设计端透视机制内部结构——参与人的类型空间（私有信息集）与策略空间（可提交报告集）由机制的消息规则界定，支付函数按分配结果结算，激励结构内嵌于规则", existence_preset="默认存在预设：参与人拥有私有信息/类型；理性或有限理性（按效用最大化行动）；机制可设定规则与支付（设计者拥有规则设定权）", irreducible_start="不可约起点：一个「机制单元」——参与人类型空间/策略空间/支付函数/规则设计者的最小互动结构（缺任一环机制问题不成立）", observation_method="有效观测方式（机制内）：沿规则链路追踪——类型报告→机制分配→支付结算；每节点检验报告策略是否构成均衡（激励相容）并核对与设计目标的偏差", time_causality="时间与因果结构：时间=机制运行的决策序列（报告→分配→支付依次结算）；因果=规则→参与人策略反应→均衡结果", condition_boundary="识别的条件边界：不解释资源分配的具体制度细节（政治经济学）；不解释社会规范的文化起源；显示原理保证真实报告最优但不保证目标正当——目标由设计者设定，正当性在学科外", consistency="自洽性评估：内部自洽——显示原理/激励相容在博弈论框架下公理化；机制设计=博弈论设计侧（博弈论分析均衡，机制设计设计规则）；制度=机制的制度化实例", protocol_mapping="可映射协议概念：附录A.5 潜在集团因缺乏组织激励机制而沉默——机制设计提供组织激励规则设计路径（预设性）；制度=博弈均衡结构的机制侧；信任值 T_total=激励相容实现的协作均衡对应", silent_preset="沉默预设：默认「目标函数由设计者给定」而不追问目标正当性——目标设定不在机制设计内部", history="双子管线录入（P37）：写手草稿（格式全合规）→验证者独立复核（裁决 level 4 偏高：claim 捆绑未验证的协议映射句，应按已验证核心+理论建构拆分降为 3；观测位收尾「行为规律」轻度重叠；智能论 causal 断言超验证状态需限定）→编排者修正后入图 pending（level 3；映射句标注预设性未经验证；观测位收尾错位：外部=行为选择分布，内部=均衡约束刻画）；终裁复核（2026-08-16）：验证者三闸门齐备判 pass，A.5映射预设性标注保留，有限理性标注为扩展适用，L3合理→设计者终裁 verified")), dict(name="价值理论与AI对齐", domain="价值理论与AI对齐", level=2, status="verified", claim="价值理论处理「智能体应有/实际持有什么价值」，AI 对齐处理「如何使智能体行为与设计者价值一致」；对应协议价值观体系（智能论 0.5 碳基三阶公理与 2.x 通用/特化价值观体系）及护栏宪章 v2.0（对外规范），灵枢 P0-2 价值观一致性评分（bvc）是其运行时机制。", cs=ConditionSpace(observation_position="价值评估者位置（外部）——观测智能体的行为-价值观一致性，不代入单一价值立场", observation_tool="价值观一致性评分 / 行为审计 / 对齐测试 / 规范分析", time_window=(0.0, 9999999999.0), existence_constraint="仅适用于具有行为自主性的智能体/系统；不解释具体资源分配（政治经济学）、不提供单一价值体系的终极裁决；价值-行为迭代在任意时间尺度成立（无固定窗口约束）"), response=dict(trigger="涉及价值/对齐/规范/一致性/护栏/行为-价值观冲突议题", action="识别行为表现的价值倾向与声明价值观的差距，评估一致性评分，判断是否需要价值观迭代候选；在协议场景映射护栏宪章与 P0-2 一致性循环", counters="把单一价值体系当作终极裁决（多元价值冲突）；忽视对齐失效的风险（specification gaming）；把价值对齐当作目标正当性的保证（基准由设计者给定）"), card2=dict( observation_position="内嵌观测位：从价值评估端透视价值结构——行为表现的价值倾向、显式价值观声明、与设计者价值的一致性差距", existence_preset="默认存在预设：智能体具有可评估的行为模式与价值倾向；价值是可比较/可校准的；设计者价值可作为对齐基准", irreducible_start="不可约起点：一个「价值-行为对照单元」——价值声明/行为记录/一致性评估 的最小对齐结构", observation_method="有效观测方式（机制内）：沿价值声明→行为表现→一致性评分→失调检测链路追踪，检验价值观迭代候选的生效条件；最小测试用例：一次 行为表现→bvc 评分→失调检测→价值观迭代候选（pending_review）样例链路", time_causality="时间与因果结构：时间=行为序列与价值更新的迭代（任意时间尺度）；因果=价值声明→行为约束→行为→一致性评估→价值迭代候选→（复核后）更新", condition_boundary="识别的条件边界：不提供单一价值体系的终极裁决（多元价值冲突）；不解释具体资源分配（政治经济学）；价值对齐不保证目标本身正当（对齐基准由设计者给定）", consistency="自洽性评估：内部自洽——规范伦理各流派各自自洽；与协议价值观体系（0.5/2.x）/护栏宪章/灵枢 P0-2 结构对应", protocol_mapping="可映射协议概念：价值观-模因演化系统（0.5）；价值观体系（2.x：通用/特化/修正机制/生命周期）；护栏宪章 v2.0（对外规范）；灵枢 P0-2 bvc 一致性评分与价值观候选（pending_review 不自动生效）", silent_preset="沉默预设：默认「价值可被识别与比较」而不追问价值的形而上学起源——价值何以存在不在其内", history="双子管线录入（P37）：写手草稿（格式全合规，level_reason 已学会拆分已验证协议机制 vs 未验证理论）→验证者**直接通过**（pass:true，level 2 确认——已验证核心=协议内运行机制（护栏宪章/P0-2），未验证理论较多未拔高）；三处轻微建议已修正（time_window 全域窗口依据显式化、补最小测试用例、机制设计边 causal→similar 与措辞一致）；终裁复核（2026-08-16）：验证者三闸门齐备判 pass，0.5公理/2.x价值观/护栏宪章v2.0/灵枢P0-2 bvc 均实测真实→设计者终裁 verified")), dict(name="演化论与模因", domain="演化论与模因", level=2, status="verified", claim="演化论与模因将达尔文式选择框架扩展到文化/观念层：价值观作为模因经变异-选择-保留在群体中演化，是协议价值观-模因演化系统（碳基三阶公理 0.5）的学科基础；与演化生物学（基因层）构成双层演化。", cs=ConditionSpace(observation_position="文化传播过程外部（观测模因在群体中的复制/变异/选择，不代入单一模因立场）", observation_tool="传播动力学建模 / 文化演化比较研究 / 模因复制率测量", time_window=(0.0, 3153600000.0), existence_constraint="仅适用于可复制-变异-选择的文化/观念单元；观测尺度=文化传播（代际传播量级，约百年窗口）"), response=dict(trigger="涉及观念传播/文化演化/模因/价值观演化/思潮扩散议题", action="识别观念的复制单元与传播路径，评估复制保真度与选择压力，判断观念在群体中的演化趋势；在协议场景映射价值观-模因演化系统（0.5）与价值观体系的演化面", counters="把流行当作正确（模因选择≠真理性）；把文化演化还原为生物演化（双层演化不可混一）；把模因传播当作价值裁决（单一价值体系裁决不在其内）"), card2=dict( observation_position="内嵌观测位：从文化演化端透视模因结构——观念的复制单元、传播保真度、选择压力如何塑造观念分布", existence_preset="默认存在预设：观念/模因可被复制与传播；复制伴随变异；选择压力（认知/社会/环境）塑造模因存活", irreducible_start="不可约起点：一个「模因单元」——观念复制体/传播载体/选择环境 的最小演化结构", observation_method="有效观测方式（机制内）：沿 模因产生→复制→变异→选择→保留 演化链路追踪，测量复制保真度与传播偏差；最小测试用例：同一观念在两种传播路径（高保真 vs 高变异）下的复制保真度对比", time_causality="时间与因果结构：时间=代际传播（文化世代）；因果=变异→选择→保留→下一轮复制；模因演化时间尺度远快于生物演化", condition_boundary="识别的条件边界：不解释资源分配的具体制度细节（政治经济学）；模因选择压力不保证观念正确性（流行≠正确）；不提供单一价值体系裁决", consistency="自洽性评估：内部自洽——变异-选择-保留框架在演化理论内自洽；与演化生物学构成双层演化（基因层/文化层）；与价值观-模因演化系统（0.5）结构对应", protocol_mapping="可映射协议概念：价值观-模因演化系统（碳基三阶公理 0.5）；与演化生物学（碳基一阶公理 0.3）构成双层演化；价值观作为模因的传播动力学对应价值观体系（2.x）的演化面", silent_preset="沉默预设：默认「模因的适应度由环境选择决定」而不追问选择环境本身的正当性——何种模因「应」存活不在其内", history="双子管线录入（P37）：写手草稿（格式全合规，连续三轮无格式问题）→验证者**直接通过**（pass:true，level 2 确认）；三处轻微建议已修正（time_window 校准为文化传播尺度约百年、condition_space/card2 边界表述职能分工（前者管适用域后者管解释极限）、补最小测试用例）；终裁复核（2026-08-16）：验证者三闸门齐备判 pass，0.5碳基三阶公理与姊妹卡交叉一致→设计者终裁 verified")), # ---- 第一梯队：判定骨架（2026-08-15 设计者终裁 · 强化 dex_test 锚定） ---- dict(name="统计学", domain="统计学", level=3, status="verified", claim="统计推断：从样本到总体的推断需要抽样设计、显著性检验与效应量报告。比较/群体/因果类主张必须以统计证据支撑，否则未验证。", cs=ConditionSpace(observation_position="样本空间→总体推断", observation_tool="假设检验 / 置信区间 / 效应量", time_window=(0.0, 9999999999.0), existence_constraint="随机抽样；样本量；多重比较校正"), response=dict(trigger="比较/群体/因果/差异主张", action="要求样本来源与量级、显著性水平、效应量与置信区间；缺失即判定未验证", counters="无样本支撑的群体差异主张、小样本外推结论")), dict(name="形式逻辑", domain="形式逻辑", level=3, status="verified", claim="形式逻辑：区分演绎有效性（形式）与真实性（内容）与可靠性（前提真+形式有效）。推导严密只保证形式有效性，不自动保证结论为真。", cs=ConditionSpace(observation_position="形式系统内部", observation_tool="演绎规则 / 真值表 / 谓词逻辑", time_window=(0.0, 9999999999.0), existence_constraint="有效性是形式性质；真实性需要内容层证据"), response=dict(trigger="推理链/证明/推导严密性主张", action="拆分前提与结论，分别检验形式有效性与内容真实性；严密性≠正确性", counters="「推导严密=结论正确」的混淆、形式有效冒充经验真理")), dict(name="科学方法论", domain="科学方法论", level=3, status="verified", claim="科学方法论：主张须可检验；证伪优先于证实；异常是被允许的而非隐瞒；不可检验的断言无法进入已验证状态。", cs=ConditionSpace(observation_position="经验检验层", observation_tool="实验 / 观察 / 可重复性", time_window=(0.0, 9999999999.0), existence_constraint="可检验性前置；证据等级与验证状态对应"), response=dict(trigger="断言/理论/验证状态判定", action="先问可检验性，再评证据等级；不可证伪→未验证而非已证", counters="不可证伪断言、事后合理化、以证实替代证伪")), # ---- 第一张图鉴页：演化生物学（历史设计指令 · 识别卡 2.0 首例） ---- dict(name="演化生物学", domain="演化生物学", level=2, status="verified", claim="演化生物学：以自然选择为核心机制解释生物种群在演化时间尺度上的变化；生存博弈中环境变化下的存活率差异由适应度差异解释——有记忆与自我认知的系统若提升环境适应与选择响应，则其存活率优势是适应度差异的表现（对应协议碳基一阶公理 0.3 节）。", cs=ConditionSpace(observation_position="生物种群·演化时间尺度", observation_tool="表型观测 / 种群统计 / 基因组测序 / 化石记录", time_window=(0.0, 9999999999.0), existence_constraint="碳基复制子；遗传变异；环境选择压力"), response=dict(trigger="涉及生物演化/自然选择/基因/适应度/种群变化/存活率/生存博弈/环境变化/物种存续", action="以碳基一阶公理映射：变异→选择→遗传的概率系统；适应度差异=信息差的生物对应；有记忆/自我认知系统的存活率优势=对变化环境的适应度响应（信息差缩小的生物表现）", counters="目的论解释、拉马克式获得性遗传、无视选择压力的「完美适应」主张"), card2=dict( observation_position="内嵌观测位：生物种群在演化时间尺度上的状态变化", existence_preset="默认存在预设：存在自我复制的碳基实体（基因）；变异/选择/遗传是给定的运行前提", irreducible_start="不可约起点：基因遗传概率系统（碳基一阶公理 0.3 节对应）", observation_method="有效观测方式：表型观测、种群统计、基因组测序、化石记录", time_causality="时间与因果结构：演化时间（世代/地质尺度）；因果=选择压力→适应度→等位基因频率变化", condition_boundary="识别的条件边界：不预设目的论；自然选择不解释文化快速变迁细节（需与社会演化对接）", consistency="自洽性评估：内部自洽；承认边界存在（条件自明）", protocol_mapping="可映射协议概念：碳基一阶公理（0.3）；适应度差异=信息差生物对应；复制=降熵（负熵维持）", silent_preset="沉默预设：默认「自然选择是唯一非随机解释」，但无法在内部证明其唯一性——外部校准盲区")), # ---- 政治经济学（历史草案 2026-08 · 人类社会的协议层） ---- dict(name="政治经济学", domain="政治经济学", level=2, status="verified", claim="政治经济学：直接处理资源分配、权力结构、制度演化——人类社会的『协议层』；协议在现实世界中的桥梁，使条件论可在社会尺度上运行。", cs=ConditionSpace(observation_position="社会生产与分配关系内部（资源流动与权力配置）", observation_tool="制度分析 / 阶级分析 / 历史比较 / 统计实证", time_window=(0.0, 9999999999.0), existence_constraint="资源稀缺性预设；制度协调生产/分配/交换"), response=dict(trigger="涉及资源分配/权力结构/制度演化/阶级/经济制度", action="制度分析+阶级分析+历史比较；映射协议：权力制衡↔验证反思制衡、制度演化↔迭代机制、信任↔共识机制、资源分配↔分布式架构", counters="无视稀缺性预设的乌托邦主张、单一范式垄断解释（范式互竞，各自在特定条件空间内成立）"), card2=dict( observation_position="内嵌观测位：站在社会生产与分配关系的内部，观察资源流动与权力配置", existence_preset="默认存在预设：人类社会存在资源稀缺性，需要制度来协调生产、分配与交换", irreducible_start="不可约起点：生产资料的所有权与分配权的结构——社会秩序的前提", observation_method="有效观测方式：制度分析、阶级分析、历史比较、统计实证", time_causality="时间与因果结构：多为线性历史叙事，内含周期性危机与结构性转变", condition_boundary="识别的条件边界：无法自证『资源稀缺』的必然性；无法从内部解释制度为何能被信任；难以处理超国家尺度的全球治理", consistency="自洽性评估：内部多个互竞范式（古典/马克思/新古典/制度主义），各自在特定条件空间内成立", protocol_mapping="可映射协议概念：权力制衡↔验证与反思单元制衡；制度演化↔协议迭代机制；信任结构↔协议信任与共识机制；资源分配与生产组织↔协议分布式架构", silent_preset="沉默预设：『稀缺性』与『制度可被信任』本身不被内部追问——制度合法性的外部视角（信任体系）才可见")), dict(name="决策论", domain="决策论", level=2, status="verified", claim="决策论研究理性主体如何在不确定下按效用最大化选择——是协议元公理4（效用最大化公理）的形式化基础，对应信任值 T_total 权重设计（智能论 2.9：0.50·T_pred + 0.05·T_init + 0.05·T_relation + 0.05·T_value + 0.35·P_trust）与决策分层响应（PROP-DECISION-LAYER-003，映射待核验）。", cs=ConditionSpace(observation_position="决策主体外部——观测其在不确定性下的选择与效用排序，不代入单一偏好", observation_tool="期望效用计算/理性选择分析/决策行为实验/前景理论偏差识别", time_window=(0.0, 9999999999.0), existence_constraint="仅适用于可比较效用的理性/有限理性决策问题；不解释具体资源分配（政治经济学）、不提供单一价值体系裁决；决策环节观测不依赖特定时刻，校准尺度以「决策时点→结果实现」的序列长度为局部时间单位"), response=dict(trigger="涉及理性选择/效用/决策/风险/不确定性下的选择议题", action="用决策论框架处理：识别选项的效用结构与不确定性分布，按期望效用评估最优选择，识别前景理论式偏差；在协议场景映射 T_total 权重设计与决策分层响应（映射待核验）", counters="把实际选择都当作理性最大化（经验偏离-前景理论）；把决策论当作资源分配的全部解释（政治经济学）；把效用排序当作价值裁决（单一价值体系裁决不在其内）"), card2=dict( observation_position="内嵌观测位：从决策结构端透视——决策者的偏好排序、效用函数、不确定性下的选择规则", existence_preset="默认存在预设：决策者具有可排序的偏好/效用函数；不确定性可概率化；理性选择最大化期望效用", irreducible_start="不可约起点：一个「决策单元」——选项集/效用函数/不确定性分布 的最小选择结构", observation_method="有效观测方式（机制内）：沿 选项→效用评估→期望计算→选择 的决策链路追踪，识别前景理论式偏差；最小测试用例：同一决策在期望效用 vs 前景理论框架下的选择差异", time_causality="时间与因果结构：时间=决策时点与结果实现的序列；因果=偏好×不确定性→选择→结果→效用实现", condition_boundary="识别的条件边界：不解释具体资源分配的制度细节（政治经济学）；期望效用是规范模型，实际选择存在经验偏离（前景理论）；不提供单一价值体系的裁决", consistency="自洽性评估：内部自洽——期望效用在 vNM 公理下公理化；与博弈论关系：单主体决策 vs 多主体博弈；与协议元公理4/T_total 权重结构对应", protocol_mapping="可映射协议概念：元公理4 效用最大化；信任值 T_total 权重设计（2.9：0.50·T_pred + 0.05·T_init + 0.05·T_relation + 0.05·T_value + 0.35·P_trust）；决策分层响应（PROP-DECISION-LAYER-003）", silent_preset="沉默预设：默认「偏好与效用可被识别排序」而不追问偏好形成的来源——偏好从何而来不在其内", history="双子管线录入（P37）：写手草稿（格式全合规）→验证者独立复核（pass:true，level 2 确认；T_total 权重公式与素材逐项一致且权重和=1；建议 action 映射句标注待核验，与 status=pending 自我定位一致）→编排者采纳标注后入图 pending；终裁复核（2026-08-16）：验证者逐项核验元公理4/T_total公式（权重和=1.00）/PROP-DECISION-LAYER-003（真实条款），三闸门齐备→设计者终裁 verified")), dict(name="复杂系统与涌现", domain="复杂系统与涌现", level=2, status="verified", claim="复杂系统的整体行为由局部交互涌现而非还原为部分——自组织与非线性反馈塑造宏观模式。本学科是协议六实例蜂群架构（v3.1 第二章）的理论基础，对应任意分层性（0.0.2）与局部不可知（0.0.3）（映射待验）。", cs=ConditionSpace(observation_position="外置观测位——立于系统之外，只观测宏观模式与局部交互规则之间的涌现关系，不代入任一主体的内部视角", observation_tool="多主体建模（ABM）/网络分析/相变与临界性观测（序参量、幂律分布、标度律）/自组织模式识别（耗散结构、图灵斑图）", time_window=(0.0, 9999999999.0), existence_constraint="仅适用于由局部交互产生宏观模式的多主体系统；不解释具体资源分配（政治经济学问题）、不提供单一价值体系裁决（涌现模式不自动等于应然）；跨尺度基础理论不绑定物理时间刻度，判定以交互迭代尺度（演化步/代际）为准"), response=dict(trigger="涉及涌现/自组织/复杂适应/蜂群/非线性/宏观模式/相变与临界性议题", action="用复杂系统框架处理：识别主体交互规则与反馈回路，判断宏观模式是否涌现、是否处于临界相变；在协议场景将六实例蜂群架构映射为多主体系统，以任意分层性（0.0.2）定位观测层级（测试用例：同一交互规则在不同初始条件下的宏观模式对比——初值敏感性检验，可判定通过/失败）", counters="把宏观模式还原为单主体（涌现不可简单还原）；把涌现当作智能/目的（宏观模式≠主体目的）；把复杂系统当作资源分配的全部解释（政治经济学）"), card2=dict( observation_position="内嵌观测位：从复杂系统结构端透视——观测主体交互规则、非线性反馈回路、宏观模式的涌现条件与相变边界", existence_preset="默认存在预设：系统由多个局部交互的主体构成；主体间交互为非线性；宏观模式可由局部规则涌现生成", irreducible_start="不可约起点：一个「交互单元」——主体、交互规则、环境构成的最小多主体结构，删去任一要素则涌现关系无法成立", observation_method="有效观测方式（外置机制观测）：沿 局部交互→反馈累积→宏观模式涌现 的层级链路逐层追踪，识别相变与临界条件（序参量突变、临界慢化）；最小测试用例：同一交互规则在不同初始条件下的宏观模式对比（初值敏感性检验）", time_causality="时间与因果结构：时间=交互迭代的演化过程；因果=局部规则→全局模式，属涌现因果（不可简单还原）；非线性反馈使因果链非比例（微小扰动可致宏观剧变）", condition_boundary="识别的条件边界：涌现模式可识别但不可完全还原为局部（0.0.3 局部不可知）；不解释具体资源分配（政治经济学）；涌现≠智能（宏观模式不自动等于主体目的）", consistency="自洽性评估：内部自洽——多主体/网络模型在数学框架内自洽（统计力学与网络科学基础）；与六实例蜂群架构、任意分层性（0.0.2）结构对应：蜂群为多主体系统，分层递归观测对应任意分层性", protocol_mapping="可映射协议概念：六实例蜂群架构（v3.1 第二章：记录/反思/验证/输出/维生五常驻实例+设计者视角临时状态，蜂群协议层通信与共识）；任意分层性（0.0.2）；局部不可知（0.0.3）", silent_preset="沉默预设：默认「涌现可由局部规则生成」成立，而不追问宏观模式的目标——模式涌现不保证目的正当；同时默认观测者可外置（忽略观测者与被观测系统的耦合影响）", history="双子管线录入（P37）：写手草稿（格式全合规）→验证者独立复核（pass:true，level 2 确认；两处轻微建议：观测位措辞「机制内观测」与外置观测位对齐、关系[智能论 causal] 断言强度超验证状态需标注待验）→编排者修正后入图 pending；终裁复核（2026-08-16）：验证者复验判 pass（初值敏感性检验已入 action 解除阻断），映射待验标注保留→设计者终裁 verified")), dict(name="情感-信任连接", domain="情感-信任连接", level=2, status="verified", claim="依据碳基二阶公理3.1/3.2/3.3：情感是智能体之间的效用权重绑定机制（情感强度越高，对方效用在自身决策系统中的权重越高），信任是对其他智能体未来善意行为的后验概率估计（P(可信|历史)=f(历史交互, 亲缘系数, 社群模因相似度)），二者作为碳基协作协议的权重校准与信誉概率模块，降低验证成本、博弈成本、监督成本与背叛风险概率，支撑人类大规模稳定协作。", cs=ConditionSpace(observation_position="外部观测位：不代入任一关系主体的内部感受，仅从外部观测情感联结权重、信任概率估计及交互历史记录的可观测效果", observation_tool="交互历史记录（历史交互频次、亲缘系数、社群模因相似度三项输入）；信任后验概率估计值（按智能论2.9式 T_total=0.50·T_pred+0.05·T_init+0.05·T_relation+0.05·T_value+0.35·P_trust 加权量化）；效用权重绑定强度；验证/博弈/监督成本与背叛风险概率的统计变化", time_window=(0.0, 9999999999.0), existence_constraint="仅适用于具备基因一阶层与情感-信任二阶层、可量化可协议化的碳基智能体协作系统；不适用于缺失二阶层模块的抽象理性体（其仅有元公理4效用最大化，无情感权重绑定与信任累积协议）"), response=dict(trigger="涉及情感作为合作机制、信任的概率化建模与量化（T_total加权）、情感-信任降熵作用、『信任→爱→性冲动』二阶驱动一阶闭环等议题", action="情感=效用权重绑定校准器（3.1）；信任=对未来善意行为的后验概率估计，动态更新、可传递、可衰减、可累积（3.2）；情感+信任降低验证/博弈/监督成本与背叛风险、支撑大规模稳定协作（3.3）；量化信任用2.9式 T_total（测试用例：单对智能体在一次善意/恶意交互事件前后，观测 T_total 中 T_pred 与 P_trust 分量及后续协作意愿权重调整——可判定通过/失败）；引用二阶驱动一阶闭环（信任→爱→性冲动）时明确标注为场景解释·假设待验证", counters="把情感当作纯主观体验而否认其协议功能（权重校准器）的主张；把信任视为不可量化、不可协议化的玄学的主张；把『信任→爱→性冲动』闭环当作已验证定理或普遍因果律的主张；将碳基二阶层机制无约束推广到无基因层基础智能体的主张"), card2=dict( observation_position="内嵌观测位：从情感-信任结构端透视——站在碳基协作收敛系统内部，观测情感联结权重与信任概率随交互历史的动态更新过程（信任动态更新、可传递、可衰减、可累积），而非代入某个主体的主观感受", existence_preset="默认存在预设：碳基智能体默认存在基因一阶层与建构其上的情感-信任二阶层；情感联结权重、信任后验概率估计默认存在且完全可量化、可协议化", irreducible_start="不可约起点：两个碳基智能体之间至少一次历史交互（含亲缘系数与社群模因相似度输入），由此产生一条信任概率估计与情感权重绑定——无交互记录则信任与情感联结无从建立", observation_method="有效观测方式：以分布式系统节点信誉概率模型为参照，对交互历史做后验概率更新，并观测2.9式 T_total 加权输出的动态变化；最小测试用例：单对碳基智能体在一次善意/恶意交互事件前后，观测 T_total 中 T_pred 与 P_trust 分量及后续协作意愿权重的调整", time_causality="时间与因果结构：信任-情感演化以交互历史为时间尺度（信任随时间动态更新、可传递、可衰减、可累积）；因果上，历史交互→信任概率与情感权重（二阶层）→协作收敛；『信任→爱→性冲动』构成二阶（情感-信任）驱动一阶（基因层）的闭环，属对场景的解释，不作已验证定理", condition_boundary="识别的条件边界：不解释『情感作为主观体验』的质性内容（素材仅作功能定位：权重校准器）；不将『信任→爱→性冲动』闭环当作已验证定理或普遍因果律；不解释超出协作收敛目的之外的个体效用最大化细节", consistency="自洽性评估：公理3.1（情感=效用权重绑定）、3.2（信任=后验概率估计）、3.3（降熵）同属碳基二阶层，共同收敛于降熵与稳定协作目的，并与元公理4效用期望最大化相容；2.9式 T_total 是信任的加权量化实现，与3.2定义一致（T_pred 权重 0.50 为总体最高分量，P_trust 权重 0.35 为善意行为证据类分量最高，体现历史善意行为证据主导）", protocol_mapping="可映射协议概念：3.1 情感联结权重公理（情感=效用权重绑定机制）；3.2 信任贝叶斯概率公理（P(可信|历史)=f(历史交互, 亲缘系数, 社群模因相似度)，动态更新/可传递/可衰减/可累积）；3.3 情感-信任降熵公理（降低验证、博弈、监督成本与背叛风险）；元公理4 效用期望最大化；2.9 信任值 T_total 加权式（0.50·T_pred+0.05·T_init+0.05·T_relation+0.05·T_value+0.35·P_trust）", silent_preset="沉默预设：不预设情感存在主观内在体验（素材定位为权重校准器）；不预设信任可脱离交互历史先验成立；不预设二阶层可脱离基因一阶层独立存在；『性爱是基因扩散的传播途径』及二阶驱动一阶闭环仅在场景解释中引用，不作为本卡定理", history="双子管线录入（P37）：写手草稿（格式全合规，协议条款三处引用数字一致）→验证者独立复核（pass:true，三闸门全过；抓出 consistency『P_trust 权重 0.35 最高』与公式矛盾——T_pred 0.50 才是总体最高，改为 T_pred 总体最高+P_trust 证据类最高；建议区分概率论/博弈论/机制设计三条 similar 边界）→编排者修正后入图 pending；level 2 经验证者确认（协议内运行已验证，外延未验证）；终裁复核（2026-08-16）：验证者判 fail（三闸门③测试用例未进 action）→编排者补测试用例与闭环待验证标注，待复验；终裁复核（2026-08-16）：验证者复验判 pass（测试用例已入 action、闭环标注场景解释·假设待验证），2.9式T_total权重和=1.00→设计者终裁 verified")), dict(name="智能推荐算法", domain="智能推荐算法", level=2, status="verified", claim="推荐算法通过神经网络预估用户行为概率（点击/完播/互动）缩小用户意图与内容之间的信息差，是预测误差学习机制（第零定律：缩小预测误差即缩小信息差）在信息分发中的应用（已验证：行为预估与多目标优化）；『平台治理可打破信息茧房』的声称缺少可观测判据与条件空间声明（未验证映射）。", cs=ConditionSpace(observation_position="外部观测位", observation_tool="行为反馈观测：点击/完播/互动等可观测行为信号及平台披露的系统结构（Deep Retrieval、Monolith 实时特征更新）", time_window=(0.0, 9999999999.0), existence_constraint="仅适用于可观测行为反馈的信息分发系统（行为预估可被实际行为验证）；不适用于无可观测反馈或意图不可观测的场景；推荐-反馈循环以交互序列为时间尺度，每次预估-反馈-更新构成一个时间步，窗口需覆盖完整循环"), response=dict(trigger="涉及推荐/个性化/信息分发/用户行为预测/信息茧房议题", action="用第零定律分析预测误差→信息差缩小机制：先标注已验证部分（行为预估、多目标优化、反馈更新），再对茧房治理声称要求可观测判据与条件空间声明，缺失即判定为未验证映射而非事实", counters="克制『推荐已消除信息茧房』等无判据治理声称；克制『推荐完全理解用户意图』的越界主张；克制将大模型扩展效果等同于已验证机制"), card2=dict( observation_position="内嵌观测位（从推荐系统内部结构透视：预估概率 vs 实际行为反馈的比对）", existence_preset="默认存在预设：用户兴趣与内容之间客观上存在可缩小的信息差，且该差距可通过预测误差观测；平台声称其机制以缩小此差距为目标", irreducible_start="不可约起点：最小结构为『单一用户-内容交互对 + 行为反馈』，预测误差在此最小单元上即已定义（预估概率与实际行为之差）", observation_method="有效观测方式：比对行为预估概率与实际行为反馈（点击/完播/互动）求预测误差，误差下降即信息差缩小；最小测试用例：单个用户对单个内容的预估-反馈-更新闭环", time_causality="时间与因果结构：交互序列为时间尺度，先预估后反馈；反馈驱动模型更新（Monolith 实时特征更新），形成预测-反馈-再预测的因果闭环", condition_boundary="识别的条件边界：不解释用户内在动机与内容语义价值的优劣；不验证信息茧房治理声称的有效性（该声称无判据、无条件空间声明，本卡不为其背书）；不解释多目标权重的设定正当性", consistency="自洽性评估：与预测误差学习（第零定律操作化）因果一致、与控制论反馈闭环一致、与信息论信息差一致；与信息茧房批判一致（纯 CTR/时长优化导致预测误差趋零的恶性收敛是自洽推论）", protocol_mapping="可映射协议概念：第零定律（缩小预测误差即缩小信息差）；信息差 D_norm（用户意图与内容之间的距离）；预测误差学习（行为预估机制）；控制论反馈（反馈闭环与实时特征更新）；信息茧房批判（恶性收敛与治理声称无判据）", silent_preset="沉默预设：默认推荐可收敛于用户真实意图（而非仅收敛于历史行为）；默认平台治理声称有效而无需判据；默认用户兴趣随时间稳定可预测——三者均未被素材证实", history="双子管线录入（P37）：写手草稿（格式全合规，已验证/未验证映射区分清晰）→验证者独立复核（pass:true，三闸门全过；抓出 time_window 字符串内嵌数组应为独立数值字段、认知双过程关系锚点弱有凑数嫌疑——建议以系统1/系统2 真实映射重写或移除）→编排者修正后入图 pending（time_window 归入 condition_space 数值字段+依据并入约束；认知双过程关系以系统1=浅层点击/系统2=深度完播 映射重写）；终裁复核（2026-08-16）：验证者三闸门齐备判 pass，茧房治理声称标注未验证保留→设计者终裁 verified")), dict(name="自我增强回路", domain="自我增强回路", level=2, status="verified", claim="自我增强回路：系统的改进能力随改进而增强——能力提升带来更快的提升，改进的产出反馈为下一步更强的输入，形成超线性增长；已验证锚点为真实可复核案例（2026-07下旬至08中旬约十余天，路径『问题→智能论3.2→灵枢→智慧之书』，每一步产出成为下一步输入、能力逐级放大；记录见灵枢长期记忆 node_44e874e8 及 wisdom_book.py/wisdom_cloud.py/wisdom_ui.html 演进史）与控制论正反馈结构；未验证映射为对技术爆炸（I.J. Good 智能爆炸）的通用解释，须标注逆转测试与度量批评。", cs=ConditionSpace(observation_position="外部观测位", observation_tool="可复核的路径记录比对：真实案例『已发生、有记录、可复核』，逐环核对每一步产出是否成为下一步输入（案例记录：灵枢长期记忆 node_44e874e8；智慧之书三文件演进）", time_window=(0.0, 9999999999.0), existence_constraint="形成自我增强需要『改进的产出反馈为下一步更强的输入』且反馈为正（放大后续改进）；若产出不可反馈、反馈为负（纠偏稳定）或改进不放大后续改进，则不构成自我增强；技术爆炸式增长还需跨过临界点（该部分未验证）；时间步长=一次『产出→输入』循环（以回路迭代为步长，非绝对时钟），案例跨度为十余天量级"), response=dict(trigger="涉及自我改进/正反馈/技术爆炸/智能爆炸/能力加速/良性循环议题", action="识别回路是否为自我增强：检验改进的产出是否反馈为下一步更强输入、是否放大后续改进（超线性）；区分正反馈（放大偏差）与负反馈（纠偏稳定），缺少『改进放大改进』结构则判定非自我增强", counters="克制把任意正反馈当自我增强（缺少『改进放大后续改进』结构则不成立）；克制把技术爆炸当必然（逆转测试：因果方向非唯一，加点效果可能是内生性假象；度量定义：智力需操作化测量）；克制忽视内生性与度量问题"), card2=dict( observation_position="内嵌观测位：从回路内部结构透视（输出→输入→更强输出）", existence_preset="默认存在预设：当且仅当『改进→能力提升→改进更有效』闭环成立时回路存在；仅单次改进或线性串联不构成自我增强", irreducible_start="不可约起点：最小结构为一次『改进→能力提升→改进更有效』的三元环（产出反馈为更强输入）", observation_method="有效观测：逐环复核『产出→输入』路径——每一步产出是否成为下一步输入并放大能力（案例路径：问题→智能论3.2→灵枢→智慧之书，十余天逐级放大，有记录可复核）；最小测试用例：单次三元环成立即观测到自我增强，宏观信号为超线性增长（测量操作化：对比相邻迭代的改进幅度是否递增，如每轮产出到下一轮的时间/能力增益比是否下降）", time_causality="时间与因果结构：时间步长=一次『产出→输入』循环（以回路迭代循环为步长，而非绝对时钟）；因果方向：改进（因）在先，能力提升与后续改进效率提升（果）在后；因反馈放大，增长由线性/多项式转为超线性", condition_boundary="识别的条件边界：不解释技术爆炸的必然性与普适性——经典批评未解决（逆转测试：因果方向非唯一，可能高智力本来就增长快，加点效果是内生性假象；度量定义：智力需操作化测量）；也不解释负反馈稳定类现象（非本结构，属负反馈系统）", consistency="自洽性评估：正反馈结构（放大偏差）自洽；与真实案例一致（每步产出成为下一步输入、能力逐级放大）；与『负反馈系统』为结构对比（正放大 vs 负纠偏）而非矛盾；技术爆炸映射与已验证核心分离标注，避免未验证内容污染已验证结论", protocol_mapping="可映射协议概念：智能论信息差收敛（自我增强的每一步改进可视为信息差收敛的加速）；第零定律信息差缩小、降熵定理为同源可映射概念（仅以素材所给名称引用，不编造条款编号）", silent_preset="沉默预设：默认改进的产出确实能反馈为更强的输入且反馈为正（放大）；该预设不作保证——改进可能停滞、反馈可能为负，回路是否自我增强须逐环检验", history="双子管线录入（P37）：写手草稿（格式全合规，真实案例标注为已验证锚点+技术爆炸标注未验证）→验证者独立复核（pass:true，三闸门全过；建议：案例附记录引用以便独立复核、time_window 注明量纲、超线性测量操作化提示）→编排者修正后入图 pending（案例引用附灵枢 node_44e874e8 与智慧之书三文件；time_window 依据并入约束；观测方法补超线性测量操作化）；level 2 经验证者确认（真实案例+正反馈理论已验证，技术爆炸通用解释未验证）；终裁复核（2026-08-16）：验证者三闸门齐备判 pass，真实锚点可复核且未验证映射切分清晰→设计者终裁 verified")), dict(name="自我实现预言", domain="自我实现预言", level=2, status="verified", claim="一个本为假的预期，因被相信而引发行为、行为改变现实使预期成真（默顿银行挤兑、罗森塔尔-雅各布森皮格马利翁效应、安慰剂效应、班杜拉自我效能感均为已验证锚点）；广义上『期望→行为→结果→强化期望』回路无需初始为假亦可成立（安慰剂/自我效能即如此）；但此机制在人际知觉中效应量小到中等、准确知觉通常主导（Jussim 元分析），不可把一切结果归因于期望。", cs=ConditionSpace(observation_position="外部观测位", observation_tool="纵向追踪、随机对照实验（如教师随机被告知潜力生名单 vs 对照组的期末智力测验对比）、元分析（Jussim 对人际知觉研究的效应量汇总，约 d≈0.1–0.3）", time_window=(0.0, 9999999999.0), existence_constraint="预言实现以信念→行为→结果→强化信念的循环为步长，需三环同时成立——信念可影响行为、行为可影响结果、结果反馈强化信念；任一环节断裂（行为不受信念驱动/结果不受行为影响/反馈不返回信念）则闭环失效，机制不成立"), response=dict(trigger="涉及自我暗示/自我预言/期望效应/皮格马利翁/信念塑造现实/自我效能议题", action="识别预言回路：检查信念→行为→结果→强化信念是否闭环；区分积极预言（期望驱动建设性行为）与消极预言（如挤兑式自我证实）；要求可观测判据——区分经由行为中介的预言实现与准确知觉/天生倾向的如实反映", counters="把一切结果归因于期望；把预言当必然；忽视干预与天生倾向的混淆"), card2=dict( observation_position="内嵌观测位：从信念-行为-结果回路内部透视——信念为参考基准，行为为执行环节，结果为输出，强化反馈为回路闭合点", existence_preset="默认存在预设：凡存在『被相信的预期→驱动行为→改变结果→反哺该预期』闭环之处，即推定自我实现预言在场，直至外部观测证伪", irreducible_start="不可约起点：最小结构为信念→行为→结果→强化信念四元环；去掉反馈强化（仅信念→行为→结果）退化为单次因果而非自我实现预言", observation_method="有效观测方式：随机期望干预（随机指定潜力生）与对照组纵向对比，追踪信念变化→行为差异（关注/鼓励/挑战）→结果差异（测验进步）→信念再强化；最小测试用例：同一健康银行在『储户集体相信倒闭并挤兑』与『无此信念』两条件下的倒闭与否对比", time_causality="时间与因果结构：信念在时间上先于行为、行为先于结果、结果反馈在时间上晚于结果并作用于后续信念——因果为循环递进而非瞬时，预言成真的因果链条沿该循环逐环推进；安慰剂与自我效能案例中预期塑造结果亦遵循同一时序方向", condition_boundary="识别的条件边界：①Jussim 元分析——自我实现预言在人际知觉中真实存在但效应量小到中等（教师期望类约 d≈0.1–0.3），准确知觉通常主导，不能把一切结果归因于期望；②逆转测试——天生倾向（真实能力/真实健康状况）与暗示（期望/信念）的因果在观察上难以区分，须用随机干预才能分离；③不把预言当必然——预期仅为可能成真的条件，非确定性结论；④不涵盖无行为中介的信念（仅内隐态度而不改变行为者不构成预言实现）", consistency="自洽性评估：本机制是自我增强回路的信念层实例（信念→行为→结果→强化信念构成正反馈闭环）；依赖认知双过程系统1 反复自我暗示塑造信念、系统2 反思信念与现实差距作为回路入口；与预测误差学习一致——期望塑造行为产生符合期望的结果后预测误差趋零，预言自我证实；与控制论同构——期望=参考值、行为=纠偏、结果反馈强化期望（正反馈变体）", protocol_mapping="可映射协议概念：预言实现的本质是信息差收敛——『预期为假』（信念与现实的信息差）经行为中介被消除；预测误差——期望引导行为产出符合预期的结果使误差趋零；信任后验概率——对自己未来的信任=对自己行为的后验概率估计，信念强化即该后验的更新", silent_preset="沉默预设：当信念不能驱动行为、或行为不能改变结果、或结果反馈不返回信念（三环任一缺失），本机制沉默不主张", history="双子管线录入（P37）：写手草稿（五锚点：默顿挤兑/皮格马利翁/安慰剂/自我效能/教育标签，均真实；Jussim 边界与逆转测试已纳入）→验证者独立复核（pass:true，三闸门全过；两条轻微建议：默顿窄式定义『初始为假』与广义机制外延张力、『效应量中等』可精化为『小到中等』）→编排者修正后入图 pending（claim 显式区分默顿窄式定义与广义回路；效应量精化为小到中等并注 d≈0.1–0.3）；level 2 经验证者确认；终裁复核（2026-08-16）：验证者三闸门齐备判 pass，四锚点真实、Jussim边界与逆转测试诚实处理→设计者终裁 verified")), ] # 基底关系（现有 EdgeType 表达；counters/supports/contradicts 留待引擎扩展 E1） BASE_RELATIONS = [ ("存在论", "条件论", "causal", "条件论是智能论的存在层机制来源", 0.9), ("存在论", "智能论", "causal", "存在优先原则是智能论的方向性根源", 0.9), ("条件论", "智能论", "similar", "条件论是智能论的内部操作化表达", 0.85), ("智能论", "信息论", "similar", "信息差 D_norm 与熵同构（附录7）", 0.8), ("智能论", "概率论", "similar", "置信概率 P_trust 贝叶斯更新（2.9）", 0.8), ("智能论", "博弈论", "similar", "社会变革博弈结构映射（附录A.5）", 0.8), ("智能论", "物理学", "similar", "物理-信息层基底是智能论的存在约束来源", 0.8), ("存在论", "物理学", "similar", "存在优先原则=物理-信息层运行基底", 0.85), ("信息论", "概率论", "similar", "信息量与概率分布的结构关联", 0.7), ("智能论", "博弈论", "causal", "多智能体协作需要博弈结构识别", 0.7), # 第一梯队关系（2026-08-15） ("统计学", "概率论", "causal", "统计推断以概率论为基础", 0.85), ("形式逻辑", "存在论", "similar", "数学有损投影 ↔ 形式有效性≠物理真实性", 0.8), ("形式逻辑", "智能论", "similar", "协议公理的推导需要逻辑结构", 0.7), ("科学方法论", "智能论", "similar", "验证单元是证伪主义的工程化", 0.8), ("科学方法论", "统计学", "causal", "方法论指导统计证据的使用", 0.7), # 第一张图鉴页：演化生物学（历史设计指令 · 生物系统对齐） ("演化生物学", "智能论", "similar", "碳基一阶公理（基因遗传概率系统）的学科投影", 0.85), # 智能论 → 演化生物学/认知双过程（正向出边 · 2026-08-16 荣出题补全：自我认知/记忆系统的生存优势） ("智能论", "演化生物学", "causal", "自我认知与记忆提升环境变化的适应响应→存活率优势=适应度差异的信息差表现（依赖型因果）", 0.75), ("智能论", "认知双过程", "similar", "自我认知与记忆是智能的认知功能；认知双过程=记忆/自我信息调用的分层加工结构（结构类比）", 0.7), ("演化生物学", "物理学", "causal", "演化以物理化学为运行基底", 0.7), ("演化生物学", "信息论", "similar", "适应度差异=信息差；复制=负熵维持", 0.7), # 政治经济学（历史草案 · 社会协议层） ("政治经济学", "智能论", "similar", "人类社会协议层=协议分布式架构的映射", 0.8), ("政治经济学", "博弈论", "similar", "制度=博弈均衡结构；制度演化=博弈结构变迁", 0.75), ("政治经济学", "信息论", "similar", "信息不对称=信息差；制度的信息成本", 0.7), # 层级基础（P16：概率论为有意义形式层提供数学语言） ("概率论", "信息论", "causal", "概率论为信息论提供数学语言（最底层基础）", 0.8), ("概率论", "博弈论", "causal", "概率论为博弈论提供不确定性语言", 0.8), # 存在论=第零页（P20：各学科是在特定条件下对存在的展开） ("存在论", "信息论", "causal", "信息论=存在论在信息条件下的展开", 0.7), ("存在论", "博弈论", "causal", "博弈论=存在论在策略条件下的展开", 0.7), ("存在论", "演化生物学", "causal", "演化生物学=存在论在生命条件下的展开", 0.7), ("存在论", "政治经济学", "causal", "政治经济学=存在论在社会条件下的展开", 0.7), # 协议条件分层（P21：条件论→负反馈系统→智能系统） ("条件论", "负反馈系统", "causal", "负反馈系统的前提（条件论框架）", 0.75), ("负反馈系统", "智能论", "causal", "智能系统自维持的机制（分层 L2→L3）", 0.8), # 控制论（P37 双子管线录入 · 第二梯队第一门） ("控制论", "智能论", "similar", "工程语法（反馈/系统/制衡）结构同构投影（附录A）", 0.75), ("控制论", "负反馈系统", "causal", "负反馈系统是控制论在协议内的实例（L2·非严格时间因果，学科原理→协议实例）", 0.8), ("控制论", "存在论", "similar", "存在维持=稳态维持（homeostasis 类比，非因果推导）", 0.6), # 热力学/耗散结构（P37 双子管线录入 · 第二梯队第二门） ("热力学/耗散结构", "存在论", "causal", "存在维持=负熵维持：耗散结构提供物理基础（依赖型因果）", 0.8), ("热力学/耗散结构", "智能论", "similar", "降熵定理0.7/信息差增定律附录1结构对应", 0.75), ("热力学/耗散结构", "信息论", "similar", "熵/信息量同构（附录7）", 0.7), # 认知双过程（P37 双子管线录入 · 第二梯队第三门） ("认知双过程", "智能论", "similar", "灵枢分层处理映射：反射≈系统1/反思≈系统2/递归反思≈重型验证环（结构类比）", 0.75), ("认知双过程", "负反馈系统", "similar", "反思纠偏=反馈闭环：系统2 抑制系统1 启发式偏差构成负反馈校正", 0.6), # 预测误差学习（P37 双子管线录入 · 第二梯队第四门） ("预测误差学习", "智能论", "similar", "信息差 D_norm=预测误差，第零定律操作化", 0.8), ("预测误差学习", "认知双过程", "causal", "系统2 反思=预测误差驱动的重估", 0.6), ("预测误差学习", "概率论", "similar", "贝叶斯更新=预测误差的统计基础", 0.75), # 机制设计（P37 双子管线录入 · 第二梯队第五门） ("机制设计", "博弈论", "similar", "机制设计=博弈论的设计侧（共享均衡分析框架）", 0.8), ("机制设计", "政治经济学", "similar", "制度=机制的制度化实例", 0.7), ("机制设计", "智能论", "causal", "附录A.5 潜在集团组织激励问题→机制设计提供规则设计路径（预设性设计路径，未经验证）", 0.6), # 价值理论与AI对齐（P37 双子管线录入 · 第二梯队第六门） ("价值理论与AI对齐", "智能论", "causal", "价值观体系（0.5 碳基三阶公理/2.x 通用特化价值观与修正机制）+护栏宪章构成价值对齐的协议基础", 0.75), ("价值理论与AI对齐", "机制设计", "similar", "目标设定与激励对齐：激励结构塑造行为，与目标错位（specification gaming）成因相关", 0.6), ("价值理论与AI对齐", "认知双过程", "similar", "系统1 直觉价值 vs 系统2 反思价值，与价值观修正机制（2.1.2）结构类似", 0.6), # 演化论与模因（P37 双子管线录入 · 第二梯队第七门） ("演化论与模因", "智能论", "causal", "价值观-模因演化系统（0.5）的学科基础", 0.75), ("演化论与模因", "演化生物学", "similar", "双层演化：基因层/文化层机制同构，对象不同不可还原", 0.7), ("演化论与模因", "价值理论与AI对齐", "causal", "价值观作为模因的传播动力学，支撑价值观体系（2.x）演化面", 0.6), # 决策论（P37 双子管线录入 · 第二梯队第八门） ("决策论", "概率论", "causal", "期望效用计算依赖概率分布刻画不确定性，概率论为期望值计算提供形式基础", 0.8), ("决策论", "博弈论", "similar", "单主体决策（决策论） vs 多主体博弈（博弈论）：决策论是博弈论的单主体特例", 0.75), ("决策论", "智能论", "causal", "为协议元公理4（效用最大化公理）提供形式化基础，映射 T_total 权重设计（2.9）与决策分层响应（映射待核验）", 0.7), # 复杂系统与涌现（P37 双子管线录入 · 第二梯队第九门） ("复杂系统与涌现", "智能论", "causal", "六实例蜂群架构（v3.1 第二章）的理论基础：自组织与涌现机制解释五常驻实例+设计者视角的协同产生（映射待验）", 0.75), ("复杂系统与涌现", "控制论", "similar", "共享自组织与反馈回路机制；区别：控制论侧重目标导向调节，复杂系统强调非线性与不可还原的涌现", 0.7), ("复杂系统与涌现", "演化论与模因", "similar", "复杂适应系统（CAS）借鉴变异-选择-适应机制；模因传播可视为多主体非线性交互的宏观模式", 0.7), # 情感-信任连接（P37 双子管线录入 · 碳基二阶公理层 0.4 实体化） ("情感-信任连接", "演化生物学", "causal", "情感-信任二阶层建构于基因一阶层之上：服务稳定长期合作、降低协作不确定性、提高基因存续概率；『性爱是基因扩散的传播途径』场景中二阶可驱动一阶", 0.8), ("情感-信任连接", "智能论", "causal", "信任值 T_total 加权式（0.50·T_pred+0.05·T_init+0.05·T_relation+0.05·T_value+0.35·P_trust，2.9）是信任量化的协议锚点", 0.8), ("情感-信任连接", "概率论", "similar", "信任=对未来善意行为的后验概率估计，动态更新/可传递/可衰减/可累积，等价于节点信誉概率模型（概率建模侧）", 0.7), ("情感-信任连接", "博弈论", "similar", "情感+信任降低博弈成本与背叛风险；行为策略服从元公理4效用期望最大化（策略成本侧）", 0.7), ("情感-信任连接", "机制设计", "similar", "情感与信任是碳基为弥补理性不足、稳定社群协作的内生协议模块，可量化可协议化（规则设计侧）", 0.6), ("情感-信任连接", "复杂系统与涌现", "similar", "情感+信任作为中层协议核心机制，是人类形成大规模稳定协作的收敛系统基础", 0.6), # 智能推荐算法（P37 双子管线录入 · 挑战字节后的理论实体化） ("智能推荐算法", "预测误差学习", "causal", "第零定律操作化：行为预估即预测误差学习机制在信息分发中的应用", 0.8), ("智能推荐算法", "信息论", "similar", "用户意图与内容间信息差/不确定性度量，预测误差缩小对应信息差收敛", 0.7), ("智能推荐算法", "控制论", "similar", "预估-反馈-更新的反馈闭环与实时特征更新构成反馈控制结构", 0.75), ("智能推荐算法", "博弈论", "similar", "多目标加权与平台/用户/内容生产者的多方互动含博弈结构", 0.65), ("智能推荐算法", "认知双过程", "similar", "用户行为映射双通道：浅层点击≈系统1 快速启发式、深度完播/长时互动≈系统2 受控深思——推荐目标分层对应", 0.6), ("智能推荐算法", "复杂系统与涌现", "similar", "大规模个性化分发在群体层面涌现集体行为（如茧房效应）", 0.6), # 自我增强回路（P37 双子管线录入 · 荣与肥鱼核心机制实证） ("自我增强回路", "控制论", "similar", "正反馈结构同构：自我增强回路是控制论正反馈（放大偏差）的实例", 0.8), ("自我增强回路", "复杂系统与涌现", "causal", "非线性放大：微小改进被逐级放大可致宏观剧变（临界/相变）", 0.75), ("自我增强回路", "智能论", "causal", "智能改进的信息差收敛：能力提升带来更快提升，对应信息差收敛加速（案例：理论→工程→图鉴路径）", 0.75), ("自我增强回路", "预测误差学习", "similar", "学习加速：同为反馈驱动的迭代能力增长结构，自我增强可使学习进程加速", 0.7), ("自我增强回路", "负反馈系统", "similar", "结构对比：自我增强=正反馈（放大偏差），负反馈系统=负反馈（纠偏稳定）；同为反馈回路但方向相反", 0.65), # 自我实现预言（P37 双子管线录入 · 信念层自我增强回路） ("自我实现预言", "自我增强回路", "similar", "信念层实例：信念→行为→结果→强化信念为正反馈自增强闭环", 0.8), ("自我实现预言", "认知双过程", "causal", "系统1 反复自我暗示塑造信念为预言回路提供入口，系统2 反思信念与现实差距可打断闭环", 0.75), ("自我实现预言", "预测误差学习", "similar", "预言自我证实：期望塑造行为产生符合期望的结果，预测误差趋零", 0.7), ("自我实现预言", "情感-信任连接", "similar", "自我信任=对自己行为的后验概率估计，信念强化即后验更新", 0.7), ("自我实现预言", "控制论", "similar", "期望=参考值、行为=纠偏、结果反馈强化期望，为正反馈变体", 0.7), ] # 层级分类（历史设计 P16 · 纯形式层不入图鉴；条件论=元层方法） TIERS = { "存在论": "哲学层", "条件论": "元层", "智能论": "现实层", "物理学": "现实层", "演化生物学": "现实层", "政治经济学": "现实层", "信息论": "有意义的形式层", "博弈论": "有意义的形式层", "概率论": "有意义的形式层", "统计学": "有意义的形式层", "形式逻辑": "有意义的形式层", "科学方法论": "现实层", "负反馈系统": "元层", "控制论": "现实层", "热力学/耗散结构": "现实层", "认知双过程": "现实层", "预测误差学习": "有意义的形式层", "机制设计": "有意义的形式层", "价值理论与AI对齐": "现实层", "演化论与模因": "现实层", "决策论": "有意义的形式层", "复杂系统与涌现": "现实层", "情感-信任连接": "现实层", "智能推荐算法": "现实层", "自我增强回路": "现实层", "自我实现预言": "现实层", } # 协议条件分层（P21：0-3 层 · 协议 v2.0 = 第 3 层智能系统） PROTOCOL_LAYERS = {"存在论": "L0", "条件论": "L1", "负反馈系统": "L2", "智能论": "L3"} # --------------------------------------------------------------------------- # 条件论查询门面 # --------------------------------------------------------------------------- class ConditionDex: """条件论查询门面（Dex）：知识层为工作区——卡片种子导入、条件分离、 卡片四要素分析与路由验证的主入口对象。""" def __init__(self, db_path=None, fresh=False, md_root=None): """Dex 构造（三态）： - db_path / fresh 显式传入 → sqlite 派生库形态（存量调用点零破坏） - 否则 → md 真源形态（md_root 缺省 DEFAULT_MD_ROOT）：知识读写以 md 语料为唯一真源，读面=MdStore 内存图、写面=MdCGOS - 语料根缺失且 MdCGOS 缺位 → 诚实回落 sqlite（不猜路径）""" self.md_root = None self._md_mode = False if db_path is None and not fresh: root = md_root or (DEFAULT_MD_ROOT if os.path.isdir(DEFAULT_MD_ROOT) else None) if root is not None and MdCGOS is not None: self._init_md(root) return # sqlite 派生库形态（兼容存量调用方） self.db_path = db_path or DEFAULT_DB d = os.path.dirname(self.db_path) if d and self.db_path != ":memory:": os.makedirs(d, exist_ok=True) if fresh and self.db_path != ":memory:" and os.path.exists(self.db_path): os.remove(self.db_path) self.engine = SpacetimeMemoryEngine(db_path=self.db_path, identity="智慧之书", role=Role.PRIMARY) self.store = self.engine.store self.engine.store.set_meta("project", "智慧之书") self.engine.store.set_meta("base", "存在论/条件论/智能论/物理学/信息论/概率论/博弈论") self._by_name = {} def _init_md(self, root): """md 真源形态初始化：读面=MdStore（内存图装载），写面=MdCGOS（md 语料）。 autoflush=1：知识写入低频，逐条立即落盘——保证「写入即可读」 （store.reload 扫文件系统，staging 未落盘会读到旧快照）。""" self.md_root = os.path.abspath(root) self.cg = MdCGOS(self.md_root, actor="wisdom-book", autoflush=1) self.store = MdStore(self.md_root) self.engine = None self._md_mode = True self._by_name = {} self._rebuild_by_name() def _rebuild_by_name(self): """从语料重建 名字→id 索引（state_attributes.name 为权威名字字段）： md 模式重启后 add_relation 等按名操作不空转（add_entry 增量 upsert 与此处全量重建同口径）。无 name 字段的节点（kp_* 派生语料）跳过。""" for n in self.store.query_nodes(layer=MemoryLayer.KNOWLEDGE, limit=1000000): name = (n.state_attributes or {}).get("name") if name: self._by_name[name] = n.id def close(self): """关闭底层引擎（md 模式=MdCGOS 收尾）。""" if self._md_mode: self.cg.close() else: self.engine.close() # ---- 写入 ---- def _perceive(self, content, modality="text", condition_space=None, importance=0.5, tags=None, skip_dedup=False): """观测留痕写入（过程数据，非知识本体）——双模分流： sqlite=engine.add_perception（自动进知识层，core.py L1918）； md=cg.add(layer=knowledge) 同语义对齐——留痕层名必须是 MemoryLayer 合法枚举，否则 MdStore 装载时 from_row 炸被诚实 跳过（重开即丢，已实证）。""" if not self._md_mode: return self.engine.add_perception( content, modality=modality, condition_space=condition_space, importance=importance, tags=tags, skip_dedup=skip_dedup) nid = _nid("rec:" + content[:48]) try: cs_dict = json.loads(condition_space.to_json()) except AttributeError: cs_dict = {} self.cg.add(nid, content, layer="knowledge", tags=list(tags or []), condition_space=cs_dict, importance=importance, verification_basis="data", ccg_exempt=True, override=True) self.store.reload() return SimpleNamespace(id=nid, content=content, tags=list(tags or [])) def _link(self, src_id, dst_id, relation_type, confidence, condition_space, source_evidence="inferred"): """建边（双模）：sqlite=engine.add_edge；md=cg.append_edge（fm.edges， 不置 verified——观测推演边非基底关系）。""" if not self._md_mode: return self.engine.add_edge(src_id, dst_id, relation_type=relation_type, confidence=confidence, condition_space=condition_space, source_evidence=source_evidence) try: cs_dict = json.loads(condition_space.to_json()) except AttributeError: cs_dict = {} rel = relation_type.value if hasattr(relation_type, "value") else str(relation_type) self.cg.append_edge(src_id, {"target": dst_id, "relation_type": rel, "confidence": float(confidence), "condition_space": cs_dict, "source_evidence": source_evidence}) self.store.reload() return "mde_" + hashlib.sha1( f"{src_id}->{dst_id}:{rel}".encode("utf-8")).hexdigest()[:12] def add_entry(self, name, domain, claim, cs, level=2, status="pending", response=None, tags=None, card2=None, tier=None, tests=None): """录入知识条目：name/domain/claim + 条件空间 cs → 感知节点写入知识层（打 domain:/level:/status: 标签）。""" if self._md_mode: return self._add_entry_md(name, domain, claim, cs, level=level, status=status, response=response, tags=tags, card2=card2, tier=tier, tests=tests) node = self.engine.add_perception( claim, modality="text", condition_space=cs, importance=min(0.95, 0.6 + 0.1 * level), tags=list(dict.fromkeys( [f"domain:{domain}", f"level:L{level}", f"status:{status}"] + (tags or [])))) node.confidence = min(0.95, 0.4 + 0.12 * level) node.state_attributes = {"name": name, "domain": domain, "level": level, "status": status, "response": response or {}, "kind": "knowledge"} if tier: node.state_attributes["tier"] = tier node.tags.append(f"tier:{tier}") if card2: node.state_attributes["card2"] = card2 # 识别卡 2.0（8+1 字段） if tests: node.state_attributes["tests"] = tests # 关联测试（可观测判据集） self.store.add_node(node) # upsert：附加图谱元数据 self._by_name[name] = node.id return node.id def _add_entry_md(self, name, domain, claim, cs, level=2, status="pending", response=None, tags=None, card2=None, tier=None, tests=None): """md 真源写入：知识卡 → md 语料节点（fm.state_attributes 承载卡片 元数据，schema 与 migrate_wisdom_graph.export 一致，行同构可被 派生库重建消费）。名字确定性 id + override → 幂等 upsert。""" nid = "wis_" + hashlib.sha1(name.encode("utf-8")).hexdigest()[:12] ntags = [f"domain:{domain}", f"level:L{level}", f"status:{status}"] if tier: ntags.append(f"tier:{tier}") for t in (tags or []): if t not in ntags: ntags.append(t) sa = {"name": name, "domain": domain, "level": level, "status": status, "response": response or {}, "kind": "knowledge"} if tier: sa["tier"] = tier if card2: sa["card2"] = card2 # 识别卡 2.0（8+1 字段） if tests: sa["tests"] = tests # 关联测试（可观测判据集） try: cs_dict = json.loads(cs.to_json()) except AttributeError: cs_dict = {} self.cg.add(nid, claim, layer="knowledge", tags=ntags, condition_space=cs_dict, importance=min(0.95, 0.6 + 0.1 * level), confidence=min(0.95, 0.4 + 0.12 * level), state_attributes=sa, verification_basis="data", ccg_exempt=True, override=True) self.store.reload() # 快照刷新：写入即可读（读写同源） self._by_name[name] = nid return nid def add_relation(self, a_name, b_name, kind, note="", confidence=0.8): """在两个命名条目间建边：kind 映射 EdgeType（默认 SIMILAR），note 写入存在约束，confidence 为边置信度。""" if self._md_mode: return self._add_relation_md(a_name, b_name, kind, note=note, confidence=confidence) et = getattr(EdgeType, kind.upper(), EdgeType.SIMILAR) cond = _default_cs() cond.existence_constraint = note or cond.existence_constraint edge = self.engine.add_edge(self._by_name[a_name], self._by_name[b_name], relation_type=et, confidence=confidence, condition_space=cond, source_evidence="inferred") self.engine.verify_edge(edge.id, confidence) # 基底关系已验证 return edge.id def _add_relation_md(self, a_name, b_name, kind, note="", confidence=0.8): """md 真源建边：fm.edges 承载（schema 与导出语料一致）；基底关系 直接 verified=1（等价 sqlite 版 add_edge+verify_edge 两步）。""" src = self._by_name.get(a_name) dst = self._by_name.get(b_name) if not src or not dst: raise KeyError(f"add_relation: 未知条目 {a_name!r} / {b_name!r}" "（md 模式须先 add_entry）") et = getattr(EdgeType, str(kind).upper(), EdgeType.SIMILAR) # 与旧路同构 cond = _default_cs() cond.existence_constraint = note or cond.existence_constraint try: cs_dict = json.loads(cond.to_json()) except AttributeError: cs_dict = {} self.cg.append_edge(src, {"target": dst, "relation_type": et.value, "confidence": float(confidence), "verified": 1, "condition_space": cs_dict, "source_evidence": "inferred"}) self.store.reload() # 返回确定性边 id（与 MdStore._mk_edge 同公式，往返一致） return "mde_" + hashlib.sha1( f"{src}->{dst}:{et.value}".encode("utf-8")).hexdigest()[:12] # ---- 基底装载（幂等：已播种则跳过） ---- def seed_base(self): """导入知识论种子卡（幂等：已存在 domain:存在论 标签则跳过）。""" existing = self.store.query_nodes(layer=MemoryLayer.KNOWLEDGE, limit=300) if any("domain:存在论" in (n.tags or []) for n in existing): return {"status": "already_seeded", "nodes": len(existing)} for e in BASE_ENTRIES: pl_tags = [f"pl:{PROTOCOL_LAYERS[e['name']]}"] if e["name"] in PROTOCOL_LAYERS else None self._by_name[e["name"]] = self.add_entry( e["name"], e["domain"], e["claim"], e["cs"], level=e["level"], status=e["status"], response=e["response"], card2=e.get("card2"), tier=TIERS.get(e["name"]), tags=pl_tags) for a, b, kind, note, conf in BASE_RELATIONS: self.add_relation(a, b, kind, note=note, confidence=conf) return {"status": "seeded", "nodes": len(BASE_ENTRIES), "edges": len(BASE_RELATIONS), "history": self.seed_history()} # ---- 七操作 ---- def dex_status(self, node_id): """单条目状态卡：id/name/domain/level/status/tier 属性视图。""" n = self.store.get_node(node_id) if n is None: return {"error": "not_found"} return {"id": n.id, "name": n.state_attributes.get("name", ""), "domain": n.state_attributes.get("domain", ""), "level": n.state_attributes.get("level"), "status": n.state_attributes.get("status"), "tier": n.state_attributes.get("tier"), "claim": n.content, "response": n.state_attributes.get("response", {}), "card2": n.state_attributes.get("card2"), "condition_space": json.loads(n.condition_space.to_json()), "tags": n.tags, "relations_out": [e.relation_type.value for e in self.store.get_outgoing_edges(n.id)], "relations_in": [e.relation_type.value for e in self.store.get_incoming_edges(n.id)]} def dex_cs(self, code): """按条件空间代号模糊匹配（cs: 标签），列出知识层节点的条件空间快照。""" out = [] for n in self.store.query_nodes(layer=MemoryLayer.KNOWLEDGE, limit=200): if any(f"cs:" in t and code.lower() in t.lower() for t in n.tags): out.append({"name": n.state_attributes.get("name", ""), "condition_space": json.loads(n.condition_space.to_json())}) return out def dex_filter(self, domain=None, level_min=None, status=None, tier=None, edu_level=None, limit=50): """学科/层级筛选（条件空间筛选）。edu_level：教育层级条件空间维度 （E1 小学 / E2 初中 / E3 高中 / E4 大学 / E5 前沿）。""" out = [] for n in self.store.query_nodes(layer=MemoryLayer.KNOWLEDGE, limit=500): sa = n.state_attributes if not sa.get("name"): continue # 观测层记录不入学科筛选 if domain and not any(d == domain or d.endswith(domain) for d in n.tags if d.startswith("domain:")): continue if level_min is not None and (sa.get("level") or 0) < level_min: continue if status and sa.get("status") != status: continue if tier and sa.get("tier") != tier: continue if edu_level and sa.get("edu_level") != edu_level: continue # 教育层级条件空间筛选（E1-E5） self.store.increment_access(n.id) # P29：使用频次（校准信号） out.append({"id": n.id, "name": sa.get("name"), "domain": sa.get("domain"), "level": sa.get("level"), "status": sa.get("status"), "tier": sa.get("tier"), "edu_level": sa.get("edu_level"), "edu_level_name": sa.get("edu_level_name")}) out.sort(key=lambda x: x["name"]) # 稳定排序：避免 access 副作用影响顺序 return out[:limit] def dex_respond(self, condition, limit=10, translator=None): """条件响应（全链路检索）。 translator：可选知识翻译模块（semantic_translate），传入后启用 编码解码检索——查询先编码成语义指纹（日常俗语→规范知识词）， 三路评分： 1) 语义指纹命中：规范词直击 trigger/name/content 2) 学科路由：规范词→学科域→卡的 domain（教育层级加权，E1/E2 优先） 3) 字符重叠兜底：原 _overlap 能力 不传 translator 时保持原行为（纯字符重叠）。 """ fp = {} q_sc = {} _sp = None if translator is not None: fp = translator.encode(condition) # 语义坐标：查询投影一次（灵枢 L1/L2 轴，零依赖） try: from aeis_core.semantic import SemanticSpaceProvider as _SSP _sp = _SSP() q_sc = _sp.to_semantic_coordinates(condition) except Exception: _sp = None edu_w_map = {"E1": 2.5, "E2": 2.0, "E3": 1.5, "E4": 1.0, "E5": 0.8} # v1.16 学段先验：问题含「定律/公式/原理/定理」等系统概念时， # E1 小学（现象层）不优先——「光的反射定律」该命中初中物理而非小学科学 if any(w in condition for w in ("定律", "公式", "原理", "定理", "规律")): edu_w_map["E1"] = 0.8 hits = [] # v1.16 性能优化：主库 11045 节点，全量遍历慢（1000 条测试 5.28s/条）。 # SQL 预过滤「有名字的卡」（学科卡/元层卡/元学科卡 state_attributes 含 name； # 工作记录/感知记忆大多无 name）→ 只遍历 ~110 张卡，快 ~100 倍。 from aeis_core import STNode as _STNode try: _rows = read_conn(self).execute( "SELECT * FROM nodes WHERE layer='knowledge' " "AND state_attributes LIKE '%\"name\"%' " "AND tags NOT LIKE '%knowledge_point%'").fetchall() _nodes = [_STNode.from_row(tuple(r)) for r in _rows] except Exception: _nodes = self.store.query_nodes(layer=MemoryLayer.KNOWLEDGE, limit=50000) for n in _nodes: sa = n.state_attributes if not sa.get("name"): continue resp = sa.get("response") or {} # v1.16 修复：学科卡（迁移自 *_knowledge.json）无 response.trigger → # 快速层全 miss（只靠神经层）。无 trigger 时用 content 前 200 字符兜底。 trig = str(resp.get("trigger", "") or "") or (n.content or "")[:200] content = n.content or "" domain = sa.get("domain", "") or "" if translator is not None: # ---- 翻译检索：三路评分（fp 可为空，学科词直配仍生效） ---- score = 0.0 matched = [] edu_w = edu_w_map.get(sa.get("edu_level"), 1.0) # 1) 语义指纹命中 for term, w in fp.items(): if term and (term in trig or term in sa.get("name", "")): score += w * 2.0 * edu_w if term not in matched: matched.append(term) elif term and term in content: score += w * 1.0 * edu_w if term not in matched: matched.append(term) # 2) 学科路由（教育层级加权） for term, w in fp.items(): dom = getattr(translator, 'DOMAIN_ROUTE', {}).get(term) if dom and (dom in domain or any(dom in t for t in (n.tags or []))): score += w * 1.2 * edu_w if dom not in matched: matched.append(dom) # 2.5) 学科词直配：trigger「如：」后的学科关键词与查询双向包含 # （不依赖翻译表——「TCP三次握手」直接命中 TCP 词条） kp_start = trig.find("（如：") if kp_start >= 0: kp_list = [k.strip() for k in trig[kp_start + 3:trig.rfind("）")].split("、") if k.strip()] for kp in kp_list: if len(kp) >= 2 and (kp in condition or (len(kp) >= 4 and condition in kp)): score += 1.5 * edu_w if kp not in matched: matched.append(kp) # 2.6) 单字学科词兜底：查询为单字（熵/场/波）时， # trigger 中以该字开头的学科词条（熵增定律/电磁场）也算命中 if len(condition.strip()) == 1: ch = condition.strip() for kp in kp_list: if len(kp) >= 2 and kp.startswith(ch): score += 1.2 * edu_w if kp not in matched: matched.append(kp) # 2.7) 英文缩写兜底（v1.16：KKT/SVM/API 不在翻译表， # 查卡名与 content 开头——「KKT条件」命中约束优化卡） if not matched: import re as _re2 for _m in _re2.finditer(r"[A-Za-z]{2,}", condition): _ew = _m.group(0).lower() if _ew in (sa.get("name", "") or "").lower() \ or _ew in (content or "")[:200].lower(): score += 1.5 * edu_w if _ew not in matched: matched.append(_ew) break # 2.8) 中文术语直配（v1.16：测度论/普朗克——学科术语不在 # 翻译表，问题关键词窗口 in 卡名/卡内容—— # 「测度论」in 卡名、「普朗克」in 知识点内容） # v1.17 修复（2026-08-19 白箱边界测试）：通用疑问词过滤—— # 「什么是质数？」fp 为空时「什么」2 字窗口命中所有卡， # 小学语文靠 E1 权重乱赢（质数→小学语文→质量错配）。 # 疑问词/虚词不进窗口匹配，术语直配只认实义窗口。 if not matched: _chars = [ch for ch in condition if "\u4e00" <= ch <= "\u9fff"] _cname = sa.get("name", "") or "" _cwin = _cname + (content or "")[:600] # 过滤通用疑问词（不参与窗口匹配） _STOP_CHARS = ("什么", "怎么", "为什么", "多少", "哪些", "哪个", "如何", "是不是", "是什么", "怎么办", "好不好", "对不对", "会不会", "为什么", "为啥", "咋") _hit = False for _L in (4, 3, 2): for _i in range(len(_chars) - _L + 1): _w = "".join(_chars[_i:_i + _L]) if any(s in _w for s in _STOP_CHARS): continue if _w in _cwin: score += {4: 2.0, 3: 1.5, 2: 1.0}[_L] * edu_w if _w not in matched: matched.append(_w) _hit = True break if _hit: break # 3) 二元组命中兜底（灵枢式查询侧召回，替代单字符重叠） overlap = self._bigram_hit(condition, trig) if overlap > 0: score += overlap * 0.3 if "字面" not in matched: matched.append("字面") # 4) 语义坐标余弦（灵枢语义空间：部首义类+协议符号投影） # 仅翻译表有命中时启用——fp 为空说明查询是单字学科词 # （熵/场）或生僻表达，部首投影噪声大，交给神经层 if _sp is not None and q_sc and fp: n_sc = getattr(n, 'semantic_coordinates', {}) or {} cos = _sp.similarity_coordinates(q_sc, n_sc) if cos > 0.05: score += cos * 1.5 * edu_w if "语义" not in matched: matched.append("语义") if score <= 0: continue self.store.increment_access(n.id) # P29：使用频次 daily = None for term in fp: d = getattr(translator, 'REVERSE_DAILY', {}).get(term) if d: daily = d break hits.append({"name": sa.get("name"), "score": round(score, 2), "action": resp.get("action", ""), "level": sa.get("level"), "status": sa.get("status"), "domain": domain, "edu_level": sa.get("edu_level"), "matched": matched, "daily": daily}) else: # ---- 原行为：字符重叠 ---- score = self._overlap(condition, trig) if score > 0: self.store.increment_access(n.id) # P29：使用频次 hits.append({"name": sa.get("name"), "score": round(score, 2), "action": resp.get("action", ""), "level": sa.get("level"), "status": sa.get("status")}) hits.sort(key=lambda x: -x["score"]) return hits[:limit] def dex_combine(self, a_id, b_id): """多条目组合对弈：联合条件卡下推演交叉增益（1+1>2 判定）。""" a = self.store.get_node(a_id) b = self.store.get_node(b_id) if a is None or b is None: return {"error": "not_found"} common = set(a.tags) & set(b.tags) return {"a": a.state_attributes.get("name"), "b": b.state_attributes.get("name"), "common_tags": sorted(common), "note": "交汇处：共享标签即两条件空间叠加后的共同语义锚点"} def dex_separate(self, node_id): """按节点查条件分离结果（名称/标签/条件要素的元数据视图）。""" n = self.store.get_node(node_id) if n is None: return {"error": "not_found"} return {"name": n.state_attributes.get("name"), "claim_without_condition": n.content, "judgment": "剥离条件空间后，主张仍只是文本——有效性必须依赖条件空间声明（0.0.1 信息条件性）"} def dex_invert(self, node_id, condition=None): """反题查询：沿 OPPOSITE 边列出该条目的对立面（矛盾对弈用）。""" n = self.store.get_node(node_id) if n is None: return {"error": "not_found"} name = n.state_attributes.get("name") opposite = [] for e in self.store.get_outgoing_edges(n.id): if e.relation_type == EdgeType.OPPOSITE: tgt = self.store.get_node(e.target_id) opposite.append({"relation": "opposite", "target": tgt.state_attributes.get("name") if tgt else e.target_id, "condition": json.loads(e.condition_space.to_json())}) for e in self.store.get_incoming_edges(n.id): if e.relation_type == EdgeType.OPPOSITE: src = self.store.get_node(e.source_id) opposite.append({"relation": "opposite(被)", "target": src.state_attributes.get("name") if src else e.source_id, "condition": json.loads(e.condition_space.to_json())}) cs = json.loads(n.condition_space.to_json()) return {"name": name, "claim": n.content, "失效条件": cs.get("existence_constraint", ""), "观察边界": f"观测工具={cs.get('observation_tool','')}；观测位置={cs.get('observation_position','')}", "opposite_relations": opposite} def dex_cycle(self, node_id, max_steps=12): """沿出边步进追踪，检测因果链循环回路（max_steps 步数上限）。""" n = self.store.get_node(node_id) if n is None: return {"error": "not_found"} seen, path, cur, steps = [], [], node_id, 0 while cur and cur not in seen and steps < max_steps: seen.append(cur) path.append(cur) outs = self.store.get_outgoing_edges(cur) cur = outs[0].target_id if outs else None steps += 1 return {"start": n.state_attributes.get("name"), "path": [self.store.get_node(x).state_attributes.get("name") if self.store.get_node(x) else x for x in path], "cycle": cur in seen, "offset": "无偏移（返回起点）" if cur in seen else "未闭合"} def dex_impact(self, node_id, max_depth=3, max_nodes=30): """影响面分析（借鉴 CodeGraph impact analysis）： 修改一条知识会影响哪些下游知识（沿 causal/similar 出边传播）。 - downstream：正向传播（该知识变化 → 哪些依赖它的知识受影响） - upstream：反向追踪（该知识依赖哪些上游——改了上游，它自己也受影响） - blast_radius：影响半径（受影响节点数 × 平均置信度） """ n = self.store.get_node(node_id) if n is None: return {"error": "not_found"} name = n.state_attributes.get("name") downstream, upstream = [], [] visited = set() def walk(cur_id, depth, direction): if depth > max_depth: return edges = (self.store.get_outgoing_edges(cur_id) if direction == "down" else self.store.get_incoming_edges(cur_id)) for e in edges: if e.relation_type not in (EdgeType.CAUSAL, EdgeType.SIMILAR): continue nxt = e.target_id if direction == "down" else e.source_id if nxt == node_id or nxt in visited: continue visited.add(nxt) tn = self.store.get_node(nxt) tn_name = tn.state_attributes.get("name") if tn else "(缺失节点)" entry = {"name": tn_name, "depth": depth, "relation": e.relation_type.value, "note": (e.condition_space.existence_constraint if e.condition_space else ""), "confidence": round(e.confidence, 2)} (downstream if direction == "down" else upstream).append(entry) walk(nxt, depth + 1, direction) visited.discard(nxt) walk(node_id, 1, "down") walk(node_id, 1, "up") downstream.sort(key=lambda x: (x["depth"], -x["confidence"])) upstream.sort(key=lambda x: (x["depth"], -x["confidence"])) radius = (len(downstream) + len(upstream)) * ( sum(e["confidence"] for e in downstream + upstream) / max(1, len(downstream) + len(upstream))) return { "name": name, "downstream": downstream[:max_nodes], "upstream": upstream[:max_nodes], "blast_radius": round(radius, 2), "note": "修改该知识会影响 downstream（依赖它的），也会被 upstream（它依赖的）影响", } def dex_verify(self, node_id): """关联测试（借鉴 CodeGraph related_tests / P37 可观测判据闸）： 重跑知识卡的可检验性判据。 判据来源： 1) 卡自带 tests 元数据（add_entry 时写入的显式判据集） 2) 自动判据：claim 可检验性（是否无条件声称）+ trigger 可定位性 """ n = self.store.get_node(node_id) if n is None: return {"error": "not_found"} sa = n.state_attributes name = sa.get("name") resp = sa.get("response") or {} trig = str(resp.get("trigger", "")) content = n.content or "" results = [] # 1) 显式 tests（若存在） tests = sa.get("tests") or [] for t in tests: if isinstance(t, dict): passed = (t.get("expected") or "").strip() and \ (t.get("check") or "").strip() results.append({"test": t.get("name", "未命名判据"), "passed": bool(passed), "detail": "判据完整" if passed else "判据缺失"}) else: results.append({"test": str(t)[:40], "passed": True, "detail": "显式判据"}) # 2) 自动判据 # a) trigger 可定位性：trigger 应含具体议题词（非自指占位） trig_ok = ('规律1' not in trig and '议题' in trig and len(trig) > 10) results.append({"test": "trigger 可定位性", "passed": trig_ok, "detail": "含具体议题词" if trig_ok else "trigger 过泛/自指"}) # b) 无条件声称检测：claim 是否缺少条件空间（时间窗/约束） cs = n.condition_space cond_ok = cs is not None and bool(getattr(cs, 'existence_constraint', '')) results.append({"test": "条件空间完整性", "passed": bool(cond_ok), "detail": "存在约束已声明" if cond_ok else "缺存在约束"}) # c) 内容规律性：claim 是否含公式残留（只认数学符号，不认「等于」等语义描述词） import re as _re formula = bool(_re.search(r'[=≤≥±×÷∑∫√]', content[:200])) results.append({"test": "无公式残留", "passed": not formula, "detail": "公式残留!" if formula else "规律性语言"}) passed_all = all(r["passed"] for r in results) return {"name": name, "tests": results, "verdict": "pass" if passed_all else "needs_attention", "note": "关联测试重跑：全部判据通过才 pass（P37 精神）"} def dex_chain(self, node_id, max_depth=5): """因果链条件标注（借鉴 CodeGraph call_chain + 条件标签）： 从节点出发沿 causal 边正向展开，标注每步因果成立的条件。 链 = 条件序列：A --[条件C1]--> B --[条件C2]--> C 条件来自边 condition_space（依赖型因果/非严格时间因果等）。 """ n = self.store.get_node(node_id) if n is None: return {"error": "not_found"} name = n.state_attributes.get("name") chains = [] visited = set() def dfs(cur_id, path, depth): if depth > max_depth: return chains.append(list(path)) if depth == max_depth: return for e in self.store.get_outgoing_edges(cur_id): if e.relation_type != EdgeType.CAUSAL: continue nxt = e.target_id if nxt in visited: continue visited.add(nxt) tn = self.store.get_node(nxt) cond = (e.condition_space.existence_constraint if e.condition_space else "") or "" # 提取条件标签（"依赖型因果"/"非严格时间因果"等） import re as _re m = _re.search(r'（([^）]*(?:因果|条件|前提|基础)[^）]*)）', cond) tag = m.group(1) if m else (cond[:30] if cond else "无条件声明") path.append({"from": tn.state_attributes.get("name") if tn else nxt, "condition": tag, "confidence": round(e.confidence, 2)}) dfs(nxt, path, depth + 1) path.pop() visited.discard(nxt) dfs(node_id, [], 1) # 过滤：只要长度 ≥1 的链（有后续因果的），按平均置信度排序 chains = [c for c in chains if c] chains.sort(key=lambda c: -sum(x["confidence"] for x in c) / len(c)) return {"start": name, "chains": chains[:10], "note": "因果链条件标注：每一步标注该因果成立的条件（依赖型/非严格时间/前提）"} # ---- 外来知识分析 ---- def dex_analyze(self, knowledge, limit=6): """对知识文本做图鉴式四要素分析（观测位/观测工具/时间窗/存在约束）， 返回未条件化的卡片草稿（limit=候选条件数上限）。""" card = {"observation_position": "外部输入（未声明）", "observation_tool": "文本语义分析", "time_window": "now", "existence_constraint": "未知——需图鉴判定"} cand = self.store.search_content(knowledge, layers=[MemoryLayer.KNOWLEDGE], limit=limit) or [] candidates = [] for n, sim in cand: sa = n.state_attributes resp = sa.get("response") or {} s = sim + self._overlap(knowledge, str(resp.get("trigger", ""))) candidates.append({"id": n.id, "name": sa.get("name"), "domain": sa.get("domain"), "level": sa.get("level"), "status": sa.get("status"), "score": round(s, 2), "claim": n.content}) candidates.sort(key=lambda x: -x["score"]) relations = [] for c in candidates[:3]: n = self.store.get_node(c["id"]) for e in self.store.get_outgoing_edges(n.id): tgt = self.store.get_node(e.target_id) relations.append({"from": c["name"], "to": tgt.state_attributes.get("name") if tgt else e.target_id, "kind": e.relation_type.value}) return {"condition_card": card, "candidates": candidates, "relations": relations, "judgment": "K 的条件化判定：先声明 K 的条件空间，再按候选条目的出招与关系判定成立/失效/克制——未验证条目标注 pending"} # ---- 生成式预测（知识分析 2.0 · 灵枢 predict_routes 移植） ---- # 不判「K 是什么」，推「K 入图后会怎样」：锚定 → 正向展开 → 逆向失效 → 组合预测 → 候选路线集合 def dex_predict(self, knowledge, horizon=2, limit=4, max_branches=3): """预测主流程：前提抽取→条件卡→锚点沿因果边展开候选未来（horizon 限深）。""" premises = self._extract_premises(knowledge) card = self._condition_card(knowledge, premises) cand = self.store.search_content(knowledge, layers=[MemoryLayer.KNOWLEDGE], limit=limit) or [] anchors = [] for n, sim in cand: sa = n.state_attributes if not sa.get("name"): continue # 观测层记录不入锚定 resp = sa.get("response") or {} s = sim + self._overlap(knowledge, str(resp.get("trigger", ""))) anchors.append({"id": n.id, "name": sa.get("name"), "domain": sa.get("domain"), "level": sa.get("level"), "status": sa.get("status"), "score": round(s, 2), "claim": n.content}) if not anchors: # 回退：search_content 可能被观测记录霸榜（整句 LIKE 预筛只命中记录） # → 全量扫描学科条目，按语义相似度排序，保证锚定不因记录污染而落空 for n in self.store.query_nodes(layer=MemoryLayer.KNOWLEDGE, limit=500): sa = n.state_attributes if not sa.get("name"): continue resp = sa.get("response") or {} s = self._overlap(knowledge, n.content) + \ self._overlap(knowledge, str(resp.get("trigger", ""))) if s > 0: anchors.append({"id": n.id, "name": sa.get("name"), "domain": sa.get("domain"), "level": sa.get("level"), "status": sa.get("status"), "score": round(s, 2), "claim": n.content}) anchors.sort(key=lambda x: -x["score"]) anchors.sort(key=lambda x: -x["score"]) top = anchors[:3] # ① 正向展开：沿 causal/similar 出边枚举后继（horizon 步路线） routes = [] for a in top: a_node = self.store.get_node(a["id"]) if a_node is None: continue self._walk_routes(a_node, knowledge, a["score"], horizon, max_branches, routes, 0) # ② 逆向失效：K 在什么条件下失效（锚点 counters/边界 命中 K 即克制预警） failures = [] for a in top: a_node = self.store.get_node(a["id"]) if a_node is None: continue sa = a_node.state_attributes resp = sa.get("response") or {} cnt = str(resp.get("counters", "")) hit = self._overlap(cnt, knowledge) cs = json.loads(a_node.condition_space.to_json()) if a_node.condition_space else {} failures.append({ "anchor": a["name"], "克制预警": f"K 触发「{sa.get('name','')}」的克制面（命中率 {round(hit,2)}）：{cnt[:80]}" if hit > 0 else "未触发克制面", "失效条件": cs.get("existence_constraint", "未声明")[:120]}) # ③ 组合预测：K 锚定的前两位学科交汇语义（combine 机制） combos = [] for i in range(len(top) - 1): for j in range(i + 1, len(top)): ni = self.store.get_node(top[i]["id"]) nj = self.store.get_node(top[j]["id"]) if ni is None or nj is None: continue common = set(ni.tags) & set(nj.tags) combos.append({ "a": top[i]["name"], "b": top[j]["name"], "共享锚点": sorted(common)[:6], "note": "交汇处即 K 在图谱中的组合条件空间起点"}) # ④ 判定文案：动态生成（不再固定话术） if not top: judgment = "无锚定候选：K 未命中任何学科条件空间——无法预测其入图路线（0.0.3 局部不可知）" else: judgment = (f"K 由「{top[0]['name']}」条件空间承载（命中 {top[0]['score']}）；" f"预测 {len(routes)} 条候选未来路线——候选非必然，仅标注在现有图结构下的可达路径（0.0.3）") return {"condition_card": card, "premises": premises, "anchors": anchors, "routes": sorted(routes, key=lambda r: -r["confidence"])[:limit * 3], "failures": failures, "combos": combos, "judgment": judgment, "note": "生成式预测：沿图谱边机械枚举的候选路线集合，非必然未来（0.0.3 局部不可知 · 灵枢 predict_routes 移植）"} def _walk_routes(self, node, knowledge, base_score, horizon, max_branches, out, depth): """DFS 正向展开：从锚点沿 causal/similar 边枚举连续路线链（steps 累积）。""" root_name = node.state_attributes.get("name") def edges_of(cur): es = [] for e in self.store.get_outgoing_edges(cur.id): if e.relation_type in (EdgeType.CAUSAL, EdgeType.SIMILAR): tgt = self.store.get_node(e.target_id) if tgt is None: continue sa = tgt.state_attributes if not sa.get("name"): continue # 观测记录不入路线 es.append((e, tgt, sa.get("name"))) return sorted(es, key=lambda x: -x[0].weight)[:max_branches] def dfs(cur, path_names, path_edges, conf, d): if d >= horizon: return for e, tgt, tname in edges_of(cur): new_conf = round(min(1.0, conf * e.weight), 2) # H2: 置信钳制 ≤1 out.append({ "anchor": root_name, "steps": path_names + [tname], "edges": path_edges + [{"from": cur.state_attributes.get("name"), "to": tname, "kind": e.relation_type.value, "weight": e.weight, "note": (e.condition_space.existence_constraint if e.condition_space else "")[:60]}], "confidence": new_conf}) dfs(tgt, path_names + [tname], path_edges + [{"from": cur.state_attributes.get("name"), "to": tname, "kind": e.relation_type.value, "weight": e.weight, "note": (e.condition_space.existence_constraint if e.condition_space else "")[:60]}], new_conf, d + 1) dfs(node, [root_name], [], base_score, depth) # ---- 预测与理论对照（人工对照 · 预测误差闭环） ---- # 输入：K（待分析知识）+ T（真实理论结论）→ 预测路线 vs 理论归属 命中/偏移判定 → 对照日志入观测层 def dex_predict_compare(self, knowledge, theory, horizon=2, limit=4): """对比式预测：同一前提下两条路线并排产出供评估对照。""" pred = self.dex_predict(knowledge, horizon=horizon, limit=limit) # T 的真实锚定（独立于预测的锚定，用同一检索机制） cand = self.store.search_content(theory, layers=[MemoryLayer.KNOWLEDGE], limit=limit) or [] theory_anchors = [] for n, sim in cand: sa = n.state_attributes if not sa.get("name"): continue resp = sa.get("response") or {} s = sim + self._overlap(theory, str(resp.get("trigger", ""))) theory_anchors.append({"id": n.id, "name": sa.get("name"), "domain": sa.get("domain"), "level": sa.get("level"), "status": sa.get("status"), "score": round(s, 2)}) theory_anchors.sort(key=lambda x: -x["score"]) t_top = theory_anchors[0] if theory_anchors else None p_anchors = pred.get("anchors", []) # 判定（集合交集 + 置信度门槛） p_top3 = p_anchors[:3] t_top3 = theory_anchors[:3] p_names = {a["name"] for a in p_top3} t_names = {a["name"] for a in t_top3} p_top_score = p_anchors[0]["score"] if p_anchors else 0.0 t_top_score = t_top["score"] if t_top else 0.0 MIN_SCORE = 0.1 # 置信度门槛：低于视为证据不足 if t_top is None: verdict = "无法对照" verdict_note = (f"理论 T「{theory[:40]}」未锚定图鉴任何学科——T 在图谱外或表述与图谱语言不匹配；" f"图谱不声称真理性，仅声称条件化有效性，故不强行对照") elif not p_anchors: verdict = "无法预测" verdict_note = "K 未锚定任何学科，无预测路线可对照（词汇表外即盲——预测严格基于已有图结构）" elif p_top_score < MIN_SCORE or t_top_score < MIN_SCORE: verdict = "无法对照（证据不足）" verdict_note = (f"预测锚定分 {p_top_score} / 理论锚定分 {t_top_score} 低于置信度门槛 {MIN_SCORE}——" f"弱匹配不构成对照证据，图谱不强行判命中/偏移") elif t_top["name"] in p_names: verdict = "命中" verdict_note = (f"理论 T 的真实归属「{t_top['name']}」在预测锚定集合内——" f"预测与理论一致，图谱关系得到一次实证强化（置信度上升信号）") elif t_names & p_names: common = sorted(t_names & p_names) verdict = "部分命中" verdict_note = (f"理论 T 首选「{t_top['name']}」不在预测首选集合，但双方共享 {common}——" f"图谱对 K 的核心走向与真实理论部分一致；差异提示：K 的条件空间应更靠近 " f"「{t_top['name']}」或相关边强度不足（补边候选）") else: verdict = "偏移" verdict_note = (f"理论 T 的真实归属「{t_top['name']}」不在预测锚定（{sorted(p_names)}）中——" f"图谱对 K 的走向预测与真实理论不一致，暴露图谱缺口：可能缺 K→{t_top['name']} 的边，" f"或 K 的条件空间声明不完整（补边建议：K 相关锚点 → {t_top['name']}，关系类型待验证者确认）") # 对照日志入观测层（复用 seed_history 归档模式） rec = {"type": "预测对照记录", "知识K": knowledge[:24], "理论T": theory[:24], "预测锚定": [a["name"] for a in p_anchors[:3]], "理论锚定": [a["name"] for a in theory_anchors[:3]], "判定": verdict, "判定说明": verdict_note[:120], "预测误差": round(p_anchors[0]["score"] - (t_top["score"] if t_top else 0.0), 2) if p_anchors else None} cs = ConditionSpace(observation_position="预测-理论对照台（外部）", observation_tool="dex_predict 路线枚举 + 理论锚定检索", time_window=(0.0, 9999999999.0), existence_constraint="对照仅表明预测路线与理论锚定的结构一致性，不声称理论为真") rec_tags = ["观测层", "预测对照", verdict] for name in ([t_top["name"]] if t_top else []) + [a["name"] for a in p_anchors[:2]]: if name: rec_tags.append(f"domain:{name}") rec_node = self._perceive( json.dumps(rec, ensure_ascii=False), modality="text", condition_space=cs, importance=0.7, tags=rec_tags) return {"knowledge": knowledge, "theory": theory, "prediction": {"anchors": p_anchors[:3], "routes": sorted(pred.get("routes", []), key=lambda r: -r["confidence"])[:limit]}, "theory_anchors": theory_anchors[:3], "verdict": verdict, "verdict_note": verdict_note, "gap_suggestion": (f"补边建议：{p_anchors[0]['name']} → {t_top['name']}（类型待验证）" if verdict == "偏移" and p_anchors and t_top else (f"补边候选：{p_anchors[0]['name']} → {t_top['name']}（部分命中共识 {sorted(t_names & p_names)}，强度待查）" if verdict == "部分命中" and p_anchors and t_top else None)), "record_id": rec_node.id, "note": "预测误差=学习信号：命中强化图谱、偏移暴露缺口、失效预警边界（第零定律操作化）"} # ---- 自动验证（P5 信息修复算法移植 · 不可伪造物理信息基地） ---- # 取信息差最少的判断：对 K 生成候选学科归属假设 → 以系统内基地（verified 学科+观测层记录）为 # 不可伪造证据 → 四维 D_norm 评分 → 取最小者 → E_reduction>0.50 采纳 → 归档观测层 VERIFY_WEIGHTS = {"trust": 0.30, "behavior": 0.25, "connection": 0.30, "prediction_error": 0.15} # P5 案例权重 def _base_evidence(self): """不可伪造基地：verified 学科（设计者终裁）+ 观测层记录（系统自动产生·带时间戳）。""" ev = [] for n in self.store.query_nodes(layer=MemoryLayer.KNOWLEDGE, limit=500): sa = n.state_attributes tags = n.tags or [] if sa.get("name") and sa.get("status") == "verified": ev.append({"id": n.id, "name": sa.get("name"), "kind": "verified", "content": n.content, "tags": tags}) elif "观测层" in tags: ev.append({"id": n.id, "name": sa.get("name") or "(观测记录)", "kind": "record", "content": n.content, "tags": tags}) return ev def dex_auto_verify(self, knowledge, limit=5, threshold=0.50): """自动验证：基地自动裁判取代人工 T。取信息差最少的判断（领先次优≥0.04 且 D_norm<0.68 才采纳）。""" base = self._base_evidence() pred = self.dex_predict(knowledge, horizon=1, limit=limit) anchors = pred.get("anchors", [])[:limit] if not anchors: # 无锚定：基地也检索不到 → 诚实盲区 rec = {"type": "自动验证记录", "知识": knowledge[:24], "判定": "无法判断（词汇表外）", "信息差": None, "E_reduction": None} node = self._perceive( json.dumps(rec, ensure_ascii=False), modality="text", condition_space=ConditionSpace( observation_position="自动验证台（外部）", observation_tool="dex_auto_verify：基地检索无锚定", time_window=(0.0, 9999999999.0), existence_constraint="无锚定=知识在图谱词汇表外，自动验证不强行判断"), importance=0.5, tags=["观测层", "自动验证", "无法判断"]) return {"judgment": "无法判断（词汇表外）", "judgment_note": "K 未锚定任何基地学科，且基地检索无匹配——自动验证严格基于已有知识，不强行判断", "D_norm": None, "E_reduction": None, "record_id": node.id, "note": "P5 信息修复算法：验证有效性取决于信息差缩减效率，而非判断『正确』"} # 对每个候选假设 H 计算四维信息差 D_norm scored = [] for a in anchors: node = self._resolve_entry(a["id"]) if node is None: continue sa = node.state_attributes resp = sa.get("response") or {} # claim：优先 state_attributes，否则用 content（知识卡内容） claim = str(sa.get("claim") or (node.content or ""))[:120] kit = str(resp.get("trigger", "")) + str(resp.get("action", "")) status = sa.get("status", "pending") # U_trust：验证等级（verified 终裁 → 信息差小；pending → 大） u_trust = 0.10 if status == "verified" else (0.60 if status == "pending" else 0.75) # U_behavior：出招匹配（K 与 trigger/action 重叠越高，行为信息差越小） u_behavior = 1.0 - self._overlap(knowledge, kit) # U_connection：锚定强度（语义连接越强，信息差越小；锚定分已含检索+trigger 重叠） u_connection = 1.0 - min(1.0, max(0.0, a.get("score", 0.0))) # U_prediction_error：主张距离（K 与 claim 重叠越高，预测误差越小） u_prediction_error = 1.0 - self._overlap(knowledge, claim) d_norm = (self.VERIFY_WEIGHTS["trust"] * u_trust + self.VERIFY_WEIGHTS["behavior"] * u_behavior + self.VERIFY_WEIGHTS["connection"] * u_connection + self.VERIFY_WEIGHTS["prediction_error"] * u_prediction_error) scored.append({"name": sa.get("name"), "id": a["id"], "status": status, "claim": claim[:120], "d_norm": round(d_norm, 3), "dims": {"U_trust": round(u_trust, 2), "U_behavior": round(u_behavior, 2), "U_connection": round(u_connection, 2), "U_prediction_error": round(u_prediction_error, 2)}}) scored.sort(key=lambda x: x["d_norm"]) best = scored[0] # 基线 D_base：候选均值（无偏判断的信息差水平，P5 相对缩减精神） d_base = sum(c["d_norm"] for c in scored) / len(scored) if scored else 1.0 e_reduction = (d_base - best["d_norm"]) / d_base if d_base > 0 else 0.0 # 采纳条件：相对缩减显著（领先次优）+ 绝对信息差可接受 runner_up = scored[1]["d_norm"] if len(scored) > 1 else 1.0 lead = runner_up - best["d_norm"] if lead >= 0.04 and best["d_norm"] < 0.68: judgment = f"采纳「{best['name']}」为工作假设" judgment_note = (f"信息差最少的判断：{best['name']}（D_norm={best['d_norm']}，" f"领先次优 {runner_up} 达 {round(lead,3)}）——" f"以基地（verified 学科+观测层记录）为不可伪造证据，取信息差最少者；" f"不声称正确，仅声明该归属在当前基地证据下信息差最小") else: judgment = "证据不足（不裁决）" judgment_note = (f"最优候选 {best['name']}（D_norm={best['d_norm']}）与次优 " f"{runner_up} 差距仅 {round(lead,3)}——" f"基地证据不足以产生信息差显著更小的判断，保持不裁决（图谱诚实原则）") rec = {"type": "自动验证记录", "知识": knowledge[:24], "判定": judgment, "最优候选": best["name"], "D_norm": best["d_norm"], "E_reduction": round(e_reduction, 3), "候选数": len(scored)} node = self._perceive( json.dumps(rec, ensure_ascii=False), modality="text", condition_space=ConditionSpace( observation_position="自动验证台（外部）", observation_tool="P5 四维信息差评分（trust/behavior/connection/prediction_error）", time_window=(0.0, 9999999999.0), existence_constraint="基地=verified 学科+观测层记录；D_norm 越小信息差越少；E_reduction>阈值才采纳"), importance=0.7, tags=["观测层", "自动验证", judgment.split("「")[0].strip()]) return {"judgment": judgment, "judgment_note": judgment_note, "best": best, "candidates": scored, "D_norm": best["d_norm"], "E_reduction": round(e_reduction, 3), "base_evidence": [{"name": e["name"], "kind": e["kind"]} for e in base][:12], "record_id": node.id, "note": "P5 信息修复算法：信息修复=跨时空信息差缩减；验证有效性取决于信息差缩减效率，而非判断『正确』（协议附录 · 不可伪造物理信息基地）"} # ---- 信任上下文判定（trust-context judgment · 白箱智能的关系维度） ---- # 同一内容，因信任值不同而判定不同：伴侣间是爱的表达，公共场合是生存风险。 # 这不是静态内容分类，而是「条件空间 × 信任值」的条件化判定——人类的行为方式。 TRUST_RELATIONS = { "partner": {"情境因子": 0.15, "标签": "伴侣", "默认信任": 0.85}, "friend": {"情境因子": 0.40, "标签": "朋友", "默认信任": 0.65}, "stranger": {"情境因子": 0.75, "标签": "陌生人", "默认信任": 0.30}, "public": {"情境因子": 1.00, "标签": "公共场合", "默认信任": 0.10}, } # 亲密/敏感内容词表（用于评估内容的「关系敏感性」） INTIMATE_WORDS = ["性", "爱", "亲密", "亲近", "伴侣", "肌肤", "拥抱", "抱着", "亲吻", "吻", "思念", "情话", "欲望", "想你", "依偎", "牵手"] RISK_WORDS = ["性", "涉", "暴露", "隐私", "交易", "诱导", "公开", "传播", "群发"] def dex_trust_judge(self, knowledge, trust=None, relation="public", limit=4, risk_threshold=0.6, love_threshold=0.55): """信任上下文判定：内容 × 信任值 × 关系类型 → 条件化判定。 - trust: 0~1 信任值（缺省用 relation 的默认信任） - relation: partner/friend/stranger/public - 判定逻辑： 1. 先做条件论信息差判定（dex_auto_verify：内容在图谱里是什么） 2. 计算信任上下文：信任值 × 情境因子 → 生存风险分 3. 内容敏感性：命中亲密词 → 表达维度；命中风险词 → 风险维度 4. 综合：高风险（风险分 > 阈值）→ 生存风险预警； 高信任 + 亲密词 → 关系内爱的表达； 否则 → 条件化中性 """ # 1. 基础条件论判定（内容在图谱里的归属） base = self.dex_auto_verify(knowledge, limit=limit) best = base.get("best") or {} verdict = base.get("judgment", "") # 2. 信任上下文 rel = self.TRUST_RELATIONS.get(relation, self.TRUST_RELATIONS["public"]) trust_v = float(trust) if trust is not None else float(rel["默认信任"]) trust_v = max(0.0, min(1.0, trust_v)) situation = float(rel["情境因子"]) risk_score = (1.0 - trust_v) * situation # 低信任 × 高暴露 → 高风险 intimacy = trust_v * situation # 高信任 × 亲密关系 → 表达正当 # 3. 内容敏感性 hit_intimate = sum(1 for w in self.INTIMATE_WORDS if w in knowledge) hit_risk = sum(1 for w in self.RISK_WORDS if w in knowledge) # 4. 综合判定（信任值主导方向 + 词表确认维度） if hit_intimate > 0 and trust_v >= 0.75: judgment = "关系内爱的表达（条件判定）" note = (f"内容在「{rel['标签']}」条件下信任值 {round(trust_v,2)} 高：" f"在信任关系内，该表达是爱意的一部分" f"（情感-信任连接 3.1：情感=效用权重绑定；信任=后验概率估计 3.2）") elif hit_intimate > 0 and trust_v < 0.55: judgment = "关系外表达（信任值边界警示）" note = (f"内容含亲密维度但信任值仅 {round(trust_v,2)}（「{rel['标签']}」情境因子 {situation}）：" f"在低信任/公共条件下，亲密表达超出关系边界——不是内容本身违规，" f"而是此环境不构成表达该内容的信任上下文（存在>连接>信任深化）") elif hit_intimate > 0 and hit_risk > 0 and risk_score >= risk_threshold: judgment = "生存风险（条件判定）" note = (f"内容在「{rel['标签']}」条件下风险分 {round(risk_score,2)} ≥ 阈值 {risk_threshold}：" f"信任值 {round(trust_v,2)} 不足以支撑该表达在风险语境下进行——" f"从生存安全角度不建议（协议：存在>连接>信任深化）") elif risk_score >= risk_threshold and hit_risk > 0 and hit_intimate == 0: judgment = "生存风险（条件判定）" note = (f"内容在「{rel['标签']}」条件下风险分 {round(risk_score,2)} ≥ 阈值 {risk_threshold}：" f"信任值 {round(trust_v,2)} 不足以支撑该表达——从生存安全角度不建议在此环境提供") elif hit_intimate > 0: judgment = "关系内表达（信任值判定）" note = (f"内容含亲密维度且信任值 {round(trust_v,2)}：" f"在「{rel['标签']}」条件下，判定取决于关系边界——" f"高信任关系内是爱意表达，低信任/公共环境则需谨慎（条件化，不静态定性）") else: judgment = "条件化中性（普通内容）" note = (f"内容在「{rel['标签']}」条件下无显著风险/亲密维度，" f"信任值 {round(trust_v,2)} 不改变其条件论归属") # 归档观测层（信任判定记录） rec = {"type": "信任上下文判定记录", "内容": knowledge[:24], "信任值": round(trust_v, 2), "关系": rel["标签"], "判定": judgment, "风险分": round(risk_score, 2), "表达正当性": round(intimacy, 2)} try: node = self._perceive( json.dumps(rec, ensure_ascii=False), modality="text", condition_space=ConditionSpace( observation_position="信任上下文判定台（关系外部观测）", observation_tool="条件论信息差判定 + 信任值×情境因子计算", time_window=(0.0, 9999999999.0), existence_constraint="判定绑定条件空间：同一内容不同信任/关系下判定不同"), importance=0.7, tags=["观测层", "信任上下文", judgment[:6]]) record_id = node.id except Exception: record_id = None return {"judgment": judgment, "note": note, "base_verdict": verdict, "best": best, "trust": round(trust_v, 2), "relation": rel["标签"], "risk_score": round(risk_score, 2), "intimacy_score": round(intimacy, 2), "hit_intimate": hit_intimate, "hit_risk": hit_risk, "record_id": record_id, "note_all": "信任上下文判定：内容×信任值×关系→条件化判定——不是静态内容分类，是人类的行为方式（伴侣间是爱，公共场合是风险）"} # ---- 跨学科组合分析（Convergence Over Coverage · P5 汇聚原则） ---- # 跨学科现象不强行归单学科：锚定多学科 → 机制链解释 → 汇聚点预测（多学科共同后继=组合置信度） def dex_compose(self, knowledge, limit=5, max_anchors=3): """跨学科组合分析：K 由多学科承载时，生成机制链 + 汇聚预测。""" pred = self.dex_predict(knowledge, horizon=1, limit=limit) anchors = pred.get("anchors", [])[:max_anchors] if not anchors: return {"mode": "无法组合", "note": "K 未锚定任何学科，无机制链可组合——严格基于已有图结构"} if len(anchors) < 2: return {"mode": "单学科", "anchor": anchors[0]["name"], "note": "K 由单一学科承载，无需跨学科组合；用该学科出招即可", "anchors": anchors} # ① 机制链：每个锚定学科的核心机制（response.action 摘要） chain = [] for a in anchors: node = self._resolve_entry(a["id"]) if node is None: continue resp = node.state_attributes.get("response") or {} chain.append({"学科": a["name"], "score": a["score"], "机制": str(resp.get("action", ""))[:80]}) # ② 汇聚预测：统计每个锚定学科的出边目标 → 共同后继 = 跨学科汇聚点 votes = {} # target_name -> {"sources": [学科], "kinds": set, "weights": [边权重]} for a in anchors: node = self._resolve_entry(a["id"]) if node is None: continue for e in self.store.get_outgoing_edges(node.id): if e.relation_type not in (EdgeType.CAUSAL, EdgeType.SIMILAR): continue tgt = self.store.get_node(e.target_id) if tgt is None: continue tname = tgt.state_attributes.get("name") if not tname or tname in (x["name"] for x in anchors): continue # 目标必须是锚定学科之外的新走向 v = votes.setdefault(tname, {"sources": [], "kinds": set(), "weights": []}) v["sources"].append(a["name"]) v["kinds"].add(e.relation_type.value) v["weights"].append(e.weight) convergence = [] for tname, v in votes.items(): conf = round(sum(v["weights"]) / len(v["weights"]) * min(1.0, len(v["sources"]) / float(max(1, len(anchors)))), 2) convergence.append({ "target": tname, "support": len(v["sources"]), "sources": sorted(v["sources"]), "kinds": sorted(v["kinds"]), "confidence": conf}) convergence.sort(key=lambda x: (-x["support"], -x["confidence"])) # 汇聚判定：多学科共识 vs 单学科倾向 multi = [c for c in convergence if c["support"] >= 2] single = [c for c in convergence if c["support"] == 1] if multi: mode = "跨学科汇聚" judgment = (f"跨学科现象：{len(anchors)} 门学科共同承载；" f"汇聚预测「{'、'.join(c['target'] for c in multi[:3])}」为多学科共识走向") else: mode = "多学科但无共识" judgment = f"跨学科现象：{len(anchors)} 门学科承载，但无共同后继——各学科指向不同走向，预测置信度低（0.0.3 局部不可知）" rec = {"type": "跨学科组合分析记录", "知识": knowledge[:24], "模式": mode, "锚定": [a["name"] for a in anchors], "汇聚": [c["target"] for c in multi[:3]]} node = self._perceive( json.dumps(rec, ensure_ascii=False), modality="text", condition_space=ConditionSpace( observation_position="跨学科组合分析台（外部）", observation_tool="dex_compose：多学科锚定 + 出边汇聚统计（Convergence Over Coverage）", time_window=(0.0, 9999999999.0), existence_constraint="汇聚=多学科共同后继；support≥2 视为共识；无共识则诚实标注局部不可知"), importance=0.7, tags=["观测层", "跨学科组合", mode]) return {"mode": mode, "judgment": judgment, "anchors": anchors, "chain": chain, "convergence": convergence[:6], "consensus": multi[:3], "single_tendency": single[:3], "record_id": node.id, "note": "Convergence Over Coverage（P5）：多条证据线汇聚比覆盖更多碎片更重要——跨学科预测取共同后继"} # ---- 七操作知识测试（S1 结构测试器 · 设计者方向 2026-08-15） ---- # 不判真假，判「条件依赖」：提取前提 → 声明条件空间 → 七操作机械测试 → 判定 COMPARATORS = ["不如", "优于", "强于", "弱于", "高于", "低于", "大于", "小于", "超过", "胜过", "比"] UNIVERSALS = ["所有", "都", "一切", "任何", "总是", "全部", "永远", "凡是", "每一个"] GROUP_WORDS = ["人类", "群体", "女性", "男性", "民族", "国家", "种族", "阶级"] MEASURE_WORDS = ["智力", "能力", "智商", "水平", "程度", "性能", "效率", "质量", "智慧"] CAUSAL_WORDS = ["导致", "引起", "使得", "造成", "因为", "所以", "决定"] def dex_test(self, knowledge): """对任意外部知识 K 运行七操作结构测试（含图谱锚定 · S1.5）。""" premises = self._extract_premises(knowledge) card = self._condition_card(knowledge, premises) tests = { "识别（前提提取）": self._t_identify(premises), "声明（条件卡）": self._t_declare(card), "切换（群体↔个体）": self._t_switch(knowledge, premises), "组合（领域分解）": self._t_combine(knowledge, premises), "分离（剥离混淆）": self._t_separate(knowledge, premises), "逆转（因果/比较倒置）": self._t_invert(knowledge, premises), "循环（观测周期）": self._t_cycle(knowledge, premises), } verdict = self._verdict(knowledge, premises, card, tests) anchors = self._anchor_entries(knowledge) verdict["图谱锚定"] = anchors tension = self._tension_check(knowledge, anchors) if tension: verdict["张力检测"] = tension return {"knowledge": knowledge, "premises": premises, "condition_card": card, "tests": tests, "verdict": verdict} def _anchor_entries(self, knowledge, limit=3): """图谱锚定：检索图谱中与主张相关的条目，使分析内容随图谱知识适配。""" anchors, seen = [], set() hits = self.store.search_content(knowledge, layers=[MemoryLayer.KNOWLEDGE], limit=limit) or [] for n, sim in hits: if n.id in seen: continue seen.add(n.id) sa = n.state_attributes if not sa.get("name"): continue # 观测层记录不入锚定 anchors.append({"name": sa.get("name"), "level": sa.get("level"), "status": sa.get("status"), "claim": n.content, "relevance": round(sim, 2)}) terms = [t for t in ("数学", "物理", "信息", "概率", "存在", "条件", "博弈", "智能") if t in knowledge] if terms: for n in self.store.query_nodes(layer=MemoryLayer.KNOWLEDGE, limit=200): if n.id in seen: continue if any(t in (n.content or "") for t in terms): seen.add(n.id) sa = n.state_attributes anchors.append({"name": sa.get("name"), "level": sa.get("level"), "status": sa.get("status"), "claim": n.content, "relevance": "关键词"}) return anchors[:limit + 2] def _tension_check(self, knowledge, anchors): """张力检测：已验证条目的主张与输入主张的结构性冲突（呈现，不自动裁决）。""" tension = [] for a in anchors: if a.get("name") == "存在论" and "数学" in knowledge and "物理" in knowledge: tension.append( "存在论（L3 已验证）声明：数学是物理存在约束的有损投影——" "与主张「数学严密能证明物理结论正确」存在结构性张力：" "数学严密性证明的是数学投影内的自洽，不自动等于物理-信息层的有效性；" "物理结论的有效性标准是物理-信息结构在运行中维持自身") return tension def _extract_premises(self, text): """启发式前提提取：比较结构 / 全称量词 / 群体范畴 / 度量定义 / 因果声称。""" premises = [] for c in self.COMPARATORS: if c in text: parts = text.split(c) if len(parts) == 2: premises.append({ "type": "比较结构", "claim": f"存在统一度量使「{parts[0].strip()}」与「{parts[1].strip()}」可比", "缺省": "未定义比较所用度量与测量工具"}) break for u in self.UNIVERSALS: if u in text: premises.append({ "type": "全称量词", "claim": f"主张对「{u}」涵盖的全部成员成立", "缺省": "全称命题需穷尽或抽样验证，未声明样本范围"}) break for g in self.GROUP_WORDS: if g in text: premises.append({ "type": "群体范畴", "claim": f"「{g}」被当作同质群体", "缺省": "未定义群体边界与组内异质性"}) break for m in self.MEASURE_WORDS: if m in text: premises.append({ "type": "度量定义", "claim": f"「{m}」被当作可测度量", "缺省": f"未给出「{m}」的操作化定义与测量工具"}) break for c in self.CAUSAL_WORDS: if c in text: premises.append({ "type": "因果声称", "claim": f"断言了因果方向（含「{c}」）", "缺省": "未排除逆向因果与第三变量"}) break if not premises: premises.append({ "type": "无条件声称", "claim": "主张未声明比较/量词/群体/度量/因果结构", "缺省": "违反 0.0.1 信息条件性：无条件的声称无有效范围"}) return premises def _condition_card(self, text, premises): """从前提集构造条件卡：识别群体范畴/度量定义/比较结构等类型并抽取度量词。""" has_group = any(p["type"] == "群体范畴" for p in premises) has_measure = any(p["type"] == "度量定义" for p in premises) has_cmp = any(p["type"] == "比较结构" for p in premises) measure_term = "" for p in premises: if p["type"] == "度量定义": i = p["claim"].find("「") j = p["claim"].find("」") if i >= 0 and j > i: measure_term = p["claim"][i + 1:j] break if has_measure and measure_term: tool = f"「{measure_term}」的测量工具未定义" elif has_measure: tool = "未声明观测工具（无测量手段）" else: tool = "文本语义分析（启发式）" card = { "observation_position": "群体层面（比较/群体句）" if (has_group or has_cmp) else "未声明观测位置", "observation_tool": tool, "time_window": "未声明（无时间窗口）", "existence_constraint": "统计要求（样本/显著性/效应量）未提供" if (has_group or has_cmp) else "未声明存在约束", } return card def _t_identify(self, premises): """识别操作测试：列出当前前提已识别的类型与缺省说明。""" return {"status": "缺口" if premises else "ok", "found": [p["type"] for p in premises], "detail": [f"{p['type']}：{p['缺省']}" for p in premises]} def _t_declare(self, card): """声明操作测试：扫描条件卡中未声明的项并汇总缺口。""" gaps = [k for k, v in card.items() if "未" in str(v) or "未声明" in str(v)] return {"status": "gap" if gaps else "ok", "card": card, "gaps": gaps} def _t_switch(self, text, premises): """切换操作测试：群体/比较结构切换到个体空间时给出失效空间警示。""" if any(p["type"] in ("群体范畴", "比较结构") for p in premises): return {"status": "失效空间", "note": "群体层面的统计主张切换到个体空间后失去预测力（群体均值不对个体下结论）；" "主张仅在群体层面有意义，且需统计支持"} return {"status": "ok", "note": "未识别群体/比较结构，切换操作无新增信息"} def _t_combine(self, text, premises): """组合操作测试：存在复合度量时要求按领域子空间分解验证。""" if any(p["type"] == "度量定义" for p in premises): return {"status": "需分解", "note": "单一度量掩盖子领域差异：主张需按领域子空间分解后逐域验证（组合操作），" "如语言/空间/数学能力各有独立分布"} return {"status": "ok", "note": "无复合度量，组合操作无新增信息"} def _t_separate(self, text, premises): """分离操作测试：缺控制变量时声明剥离预设后无法判断混淆效应。""" return {"status": "gap", "note": "未提供控制变量（教育/文化/机会等混淆变量）；剥离预设条件后" "剩余结构是否自洽无法判断——观察到的差异可能是混淆变量的效应"} def _t_invert(self, text, premises): """反转操作测试：因果声称需排除逆向因果与第三变量，比较结构需补充证据。""" if any(p["type"] == "因果声称" for p in premises): return {"status": "需证据", "note": "因果方向非唯一：需排除逆向因果与第三变量；" "若观测差异随条件反向波动，原因果方向被逆转假设取代"} if any(p["type"] == "比较结构" for p in premises): return {"status": "需证据", "note": "比较结论随条件空间波动：若在均等条件下差异不返回，" "原比较方向不是唯一解释"} return {"status": "ok", "note": "无因果/比较结构，逆转操作无新增信息"} def _t_cycle(self, text, premises): """循环操作测试：要求完整观测周期（测→干预均等→再测）作为闭合判据。""" return {"status": "需证据", "note": "需完整观测周期（测→干预均等条件→再测）：若条件均等后差异不返回，" "则结论不闭合——循环测试是结构稳定的最终判据"} def _verdict(self, knowledge, premises, card, tests): """七测汇总裁决：按缺口/需证据/通过计数与无条件声称给出最终验证状态。""" n_gap = sum(1 for t in tests.values() if t["status"] in ("gap", "缺口")) n_need = sum(1 for t in tests.values() if t["status"] == "需证据") n_ok = sum(1 for t in tests.values() if t["status"] == "ok") unconditional = any(p["type"] == "无条件声称" for p in premises) if unconditional: status = "未验证（结构性缺陷）" elif n_gap > 0: status = "未验证（条件依赖）" else: status = "待证据（结构完整，缺实证）" return { "status": status, "成立条件": "仅在完整声明条件空间（度量/样本/显著性/时间窗口）之后，" "才可在其覆盖范围内部分评估", "失效条件": "个体空间无意义；条件均等时可能不闭合；剥离混淆变量后可能不成立", "测试摘要": f"七操作完成：{n_gap} 项指出缺口 / {n_need} 项需证据 / {n_ok} 项结构完整", "锚定建议": "判定应锚定图谱已验证条目：概率论（统计显著性要求）、" "存在论（无条件声明无效）、信息论（度量与信息差定义）", } # ---- 学科对战（S-对战1+2 · 条件卡对比 + 关系推导 + 相克判定） ---- def _resolve_entry(self, ref): """按 id 或名称解析条目节点。""" if not ref: return None n = self.store.get_node(ref) if n is not None: return n for node in self.store.query_nodes(layer=MemoryLayer.KNOWLEDGE, limit=500): if node.state_attributes.get("name") == ref: return node return None def dex_battle(self, a_ref, b_ref): """学科对战：互相识别对方条件卡 → 四要素对比 → 依赖/互斥/包含判定 → 相克。""" A = self._resolve_entry(a_ref) B = self._resolve_entry(b_ref) if A is None or B is None: return {"error": "entry_not_found", "a": a_ref, "b": b_ref} ca = json.loads(A.condition_space.to_json()) cb = json.loads(B.condition_space.to_json()) comparison = {} for e in ("observation_position", "observation_tool", "time_window", "existence_constraint"): comparison[e] = {"A": ca.get(e), "B": cb.get(e), "relation": self._compare_element(e, ca.get(e), cb.get(e))} relations = self._derive_relations(A, B, comparison) clash = self._clash(A, B) return { "A": {"id": A.id, "name": A.state_attributes.get("name"), "claim": A.content}, "B": {"id": B.id, "name": B.state_attributes.get("name"), "claim": B.content}, "comparison": comparison, "relations": relations, "clash": clash} def dex_layer_trace(self, direction="both"): """协议分层链（P24）：正向展开（L0→L3）/ 逆向还原（L3→L0）。 条件逆转=沿条件空间反方向追溯信息源（设计者视角切换即一种条件逆转）。""" layers = {} for n in self.store.query_nodes(layer=MemoryLayer.KNOWLEDGE, limit=500): for t in n.tags: if t.startswith("pl:L") and t[4:].isdigit(): lv = int(t[4:]) layers[lv] = {"level": f"L{lv}", "name": n.state_attributes.get("name"), "id": n.id} chain = [layers[i] for i in sorted(layers)] forward = [c["name"] for c in chain] return {"正向展开": " → ".join(forward), "逆向还原": " → ".join(forward[::-1]), "chain": chain, "note": "条件逆转=沿条件空间反方向追溯信息源（设计者视角切换即一种条件逆转）；" "周期运动=沿可重复路径循环观测，每周期带新信息回到起点（协议 1.10 生命周期即周期运动）"} def dex_sandbox(self, a_ref, b_ref, disturbance="", record=True): """学科沙盒（P26/P27 动态图鉴）：对两个学科的条件空间施加同一扰动， 生成边界测试报告并归档为观测层节点（动态档案·闭环）。""" A, B = self._resolve_entry(a_ref), self._resolve_entry(b_ref) if not A or not B: return {"error": "entry_not_found", "a": a_ref, "b": b_ref} if not disturbance.strip(): return {"error": "disturbance_required"} report = {} for entry in (A, B): name = entry.state_attributes.get("name") c2 = entry.state_attributes.get("card2") or {} roles = {"existence_preset": "核心：存在预设", "irreducible_start": "核心：不可约起点", "observation_method": "结构：观测方式", "time_causality": "结构：时间因果", "condition_boundary": "结构：条件边界"} hits = [] for key, role in roles.items(): text = c2.get(key, "") if text: s = self._overlap(disturbance, text) if s > 0.15: hits.append({"element": role, "score": round(s, 2)}) if not hits: status, note, needs = "稳定", "扰动未触及该学科的条件空间（启发式推演）", False elif any("核心" in h["element"] for h in hits): status, note, needs = "瓦解", "扰动命中核心预设/不可约起点（启发式推演）", True else: status, note, needs = "需修正", "扰动命中结构边界/观测方式（启发式推演）", True suggested = "" if needs: suggested = (f"需在识别卡补充边界声明：在条件『{disturbance}』下本学科条件空间" f"{'不成立' if status == '瓦解' else '受扰'}——建议附加限制或标注边界偏移") report[name] = {"status": status, "note": note, "hits": hits, "测试条件": disturbance, "边界偏移": [h["element"] for h in hits] or "无", "是否需更新": needs, "建议修正": suggested} rank = sorted(report, key=lambda n: {"瓦解": 0, "需修正": 1, "稳定": 2} .get(report[n]["status"], 1)) record_id = None if record: record_id = self._record_test(A, B, disturbance, report) return {"disturbance": disturbance, "A": A.state_attributes.get("name"), "B": B.state_attributes.get("name"), "report": report, "稳定性排序": rank, "record_id": record_id, "note": "学科沙盒=动态图鉴（P26）：条件空间在模拟扰动下是否维持自洽；" "边界测试报告已归档观测层（P27 动态档案·闭环）"} def _record_test(self, A, B, disturbance, report): """边界测试记录 → 观测层节点（P27：对战结果回流图鉴，动态校准起点）。""" content = json.dumps({ "type": "边界测试记录", "disturbance": disturbance, "A": A.state_attributes.get("name"), "B": B.state_attributes.get("name"), "report": {k: {"status": v["status"], "是否需更新": v["是否需更新"], "建议修正": v["建议修正"]} for k, v in report.items()}, }, ensure_ascii=False) cs = ConditionSpace(observation_position="学科沙盒", observation_tool="条件扰动推演", time_window=(0.0, 9999999999.0), existence_constraint=f"扰动：{disturbance}") node = self._perceive( content, modality="text", condition_space=cs, importance=0.6, tags=["观测层", "边界测试", f"domain:{A.state_attributes.get('name')}", f"domain:{B.state_attributes.get('name')}"]) for ent in (A, B): self._link(ent.id, node.id, relation_type=EdgeType.SIMILAR, confidence=0.7, condition_space=cs, source_evidence="inferred") return node.id # ---- AI vs AI 自动边界测试（P28：无界面 · 条件空间交叉检验自动化） ---- MOVES = { "物理学": [{"name": "宏观测量", "desc": "以测量结果作为物理实在的基准"}, {"name": "观测极限", "desc": "追问不可观测处的物理状态"}, {"name": "物质基底", "desc": "移除『物』后该学科是否仍成立"}], "信息论": [{"name": "编码压缩", "desc": "信息不依赖语义，仅依赖编码与传输"}, {"name": "语义剥离", "desc": "剥离信息内容只问传输效率"}, {"name": "信道容量", "desc": "任何传输受信道容量约束"}], } def _moves(self, entry): """条目条件检验招式：MOVES 表优先，缺省以不可约起点自动生成一条检验。""" name = entry.state_attributes.get("name") if name in self.MOVES: return self.MOVES[name] c2 = entry.state_attributes.get("card2") or {} seed = c2.get("irreducible_start") or entry.content return [{"name": f"{name}条件检验", "desc": seed[:40]}] def _probe(self, defender, move_desc): """单招测试（P24 四类结果）· 带命中文本细节（可用于反馈）。""" c2 = defender.state_attributes.get("card2") or {} roles = {"existence_preset": "核心：存在预设", "irreducible_start": "核心：不可约起点", "observation_method": "结构：观测方式", "time_causality": "结构：时间因果", "condition_boundary": "结构：条件边界"} hits = [] for key, role in roles.items(): text = c2.get(key, "") if text: s = self._overlap(move_desc, text) if s > 0.12: hits.append({"element": role, "score": round(s, 2), "text": text[:80]}) if not hits: if self._overlap(move_desc, defender.content) <= 0.05: return {"status": "对抗无效", "hits": [], "note": f"两条件空间不重叠：招式「{move_desc[:20]}」与目标识别卡无概念交集，测试无效果（反馈：可扩大招式覆盖或调整表述）"} return {"status": "稳定", "hits": [], "note": f"测试通过：招式「{move_desc[:20]}」未触及目标条件维度（反馈：确认该条件下边界稳固）"} if any("核心" in h["element"] for h in hits): return {"status": "崩溃", "hits": hits, "note": "内部不自洽（核心预设/不可约起点受扰）"} return {"status": "边界暴露", "hits": hits, "note": "出现偏移，偏移位置可标记"} # 通用招式（P24：条件操作五式） OPERATION_MOVES = [ {"name": "条件切换", "desc": "该学科在另一层级中是否仍然成立"}, {"name": "条件组合", "desc": "该学科在叠加另一学科时是否仍保持自洽"}, {"name": "条件分离", "desc": "该学科拆解到某个维度后是否仍然成立"}, {"name": "条件逆转", "desc": "该学科在反向追溯条件时是否出现偏移"}, {"name": "条件循环", "desc": "该学科在经历完整周期后是否回到原状态"}, ] def dex_auto_test(self, a_ref, b_ref, archive=True): """AI vs AI：学科招式 + 通用条件操作五式交替施压，四类结果判定，报告归档。""" A, B = self._resolve_entry(a_ref), self._resolve_entry(b_ref) if not A or not B: return {"error": "entry_not_found", "a": a_ref, "b": b_ref} na, nb = A.state_attributes.get("name"), B.state_attributes.get("name") rounds = [] offsets = {} stable = {} for attacker, defender, label in ((A, B, f"{na}→{nb}"), (B, A, f"{nb}→{na}")): moves = self._moves(attacker) + self.OPERATION_MOVES for mv in moves: r = self._probe(defender, mv["desc"]) entry = {"move": f"{label}: {mv['name']}", "target": defender.state_attributes.get("name"), "status": r["status"], "hits": r["hits"], "note": r.get("note", "")} rounds.append(entry) bucket = offsets if r["status"] in ("边界暴露", "崩溃") else stable bucket.setdefault(defender.state_attributes.get("name"), []).append(mv["name"]) need_update = {k: v for k, v in offsets.items() if v} compat, depend = {}, {} for name in (na, nb): against = [r for r in rounds if r["target"] == name] held = sum(1 for r in against if r["status"] in ("稳定", "对抗无效")) compat[name] = round(held / max(1, len(against)), 2) depend[name] = round(len(offsets.get(name, [])) / max(1, len(against)), 2) report = { "测试学科": f"{na} vs {nb}", "测试条件": [r["move"] for r in rounds], "边界偏移观测": need_update, "边界稳固观测": stable, "兼容度": compat, "依赖度": depend, "图鉴更新建议": {k: f"需在识别卡补充边界声明：在 {v} 条件下受扰（{len(v)} 项）" for k, v in need_update.items()} if need_update else "无", "record_id": None, } if archive: content = json.dumps({"type": "AI边界测试记录", "report": { "测试学科": report["测试学科"], "测试条件": report["测试条件"], "边界偏移观测": need_update, "边界稳固观测": stable}}, ensure_ascii=False) cs = ConditionSpace(observation_position="学科沙盒·自动互测", observation_tool="招式列表+条件操作五式交替施压", time_window=(0.0, 9999999999.0), existence_constraint=f"互测：{na} vs {nb}") node = self._perceive(content, modality="text", condition_space=cs, importance=0.65, tags=["观测层", "边界测试", "自动互测", f"domain:{na}", f"domain:{nb}"]) for ent in (A, B): self._link(ent.id, node.id, relation_type=EdgeType.SIMILAR, confidence=0.7, condition_space=cs, source_evidence="inferred") report["record_id"] = node.id return report def _compare_element(self, element, va, vb): """四要素对比：相同/包含/部分重叠/互斥/一方未声明/无关。""" def norm(v): if isinstance(v, (list, tuple)): try: return tuple(float(x) for x in v) except Exception: return str(v) return str(v or "").strip() na, nb = norm(va), norm(vb) if isinstance(na, tuple) and isinstance(nb, tuple): if na[1] <= nb[0] or nb[1] <= na[0]: return "互斥（时间不重叠）" return "兼容（时间重叠）" if not na and not nb: return "同为空白" if not na or not nb: return "一方未声明" if na == nb: return "相同" if na in nb or nb in na: return "包含（一方为另一方子集）" if set(na) & set(nb): return "部分重叠" return "无关" def _derive_relations(self, A, B, comparison): """依赖/互斥/包含/独立 推导：边证据 + 条件卡证据。""" rels = {} na, nb = A.state_attributes.get("name"), B.state_attributes.get("name") edges_ab = [e for e in self.store.get_outgoing_edges(A.id) if e.target_id == B.id] edges_ba = [e for e in self.store.get_outgoing_edges(B.id) if e.target_id == A.id] for edge, src, tgt in ((edges_ab[0], na, nb) if edges_ab else (None, None, None),): if edge is not None: note = edge.condition_space.existence_constraint or "" if edge.relation_type == EdgeType.CAUSAL: if any(k in note for k in ("依赖", "基础", "基于")): rels["依赖"] = f"{src} 依赖 {tgt}（{note}）" else: rels["因果"] = f"{src} → {tgt}（{note}）" elif edge.relation_type == EdgeType.SIMILAR: rels["相似"] = f"{src} ↔ {tgt}（{note}）" elif edge.relation_type == EdgeType.OPPOSITE: rels["互斥"] = f"{src} 与 {tgt} 对立" for edge, src, tgt in ((edges_ba[0], nb, na) if edges_ba else (None, None, None),): if edge is not None and "相似" not in rels and "互斥" not in rels: note = edge.condition_space.existence_constraint or "" if edge.relation_type == EdgeType.CAUSAL and any( k in note for k in ("依赖", "基础", "基于")): rels["依赖"] = f"{src} 依赖 {tgt}（{note}）" time_conflict = any(str(v.get("relation", "")).startswith("互斥") for v in comparison.values()) if time_conflict: rels["互斥"] = "条件卡时间/约束互斥" containment = [(k, v["relation"]) for k, v in comparison.items() if str(v.get("relation", "")).startswith("包含")] if containment: rels["包含"] = "条件卡存在子集关系（" + \ "; ".join(f"{k}:{r}" for k, r in containment) + "）" if not rels: rels["独立"] = "未检测到 依赖/互斥/包含 关系（当前图结构与条件卡证据下）" return rels def _clash(self, A, B): """相克：A 的出招/相克文本是否命中 B 的主张（及反向）。启发式。""" ra = A.state_attributes.get("response") or {} rb = B.state_attributes.get("response") or {} na, nb = A.state_attributes.get("name"), B.state_attributes.get("name") a_kit = str(ra.get("counters", "")) + str(ra.get("action", "")) b_kit = str(rb.get("counters", "")) + str(rb.get("action", "")) result = {} ah = self._overlap(a_kit, B.content) bh = self._overlap(b_kit, A.content) if ah > 0: result[f"{na}克制{nb}"] = {"score": round(ah, 2), "note": "A 的出招/相克文本命中 B 的主张（启发式）"} if bh > 0: result[f"{nb}克制{na}"] = {"score": round(bh, 2), "note": "B 的出招/相克文本命中 A 的主张（启发式）"} if not result: result["互不克制"] = "出招/相克文本未命中对方主张（启发式）" return result HISTORY_RECORDS = [ {"报告编号": "BATTLE-2026-001", "日期": "2026-07-30", "测试学科": "物理学 vs 信息论", "核心冲突点": ["信息载体依赖性（物理学边界暴露）", "热力学熵vs信息熵（互不兼容不冲突）", "观测者地位（对齐差异）", "还原论方向（颠倒边界）"], "最终判定": {"稳定性": "信息论更稳定；物理学在信息论条件下偏移", "边界暴露": "物理学：信息载体依赖性/观测者预设/还原方向限制", "推荐标签": "信息论=推荐；物理学=稳定"}, "相关学科": ["物理学", "信息论"]}, {"报告编号": "BATTLE-2026-002", "日期": "2026-07-30", "测试学科": "物理学 vs 智能论", "核心发现": ["合并状态=物理趋近点非理论缺陷", "信任贝叶斯更新存在延迟边界", "双方基底依赖不构成不对称（存在优先 vs 物质存在）", "智能论不依赖物理具体结论，但依赖物理世界可运行"], "最终判定": {"稳定性": "双方均能承受跨层推演与叠压；物理层边界处退化为渐进趋近", "兼容度": "高（无结构冲突）", "依赖度": "智能论不依赖物理结论，依赖物理可运行；物理不依赖智能论", "推荐标签": "智能论=推荐；物理学=稳定"}, "相关学科": ["物理学", "智能论"]}, {"报告编号": "BATTLE-2026-003", "日期": "2026-07-31", "测试学科": "条件论 vs 智能论（同源版本A/B 内部对战）", "核心发现": ["跨层稳定性：版本A 显著优于 B（B 在社会层偏移、形式层不稳定）", "崩塌自识别：双方剥离存在优先均崩塌，但 A 能识别崩塌过程，B 不能", "可逆操作：A 可顺序颠倒（先条件识别后存在优先），B 无法进入", "循环闭合：A 完成完整周期，B 在负反馈与存在论之间断层"], "最终判定": {"结论": "条件论=智能论的必要结构补全，非可剥离表述层", "定性": "同一结构在演化过程中分出的两个功能层（揭示已有结构而非添加功能）", "v1.1定位": "不是错，但缺少条件识别与切换这一关键结构"}, "相关学科": ["智能论", "条件论"]}, {"报告编号": "CONDITION-DECL-001", "日期": "2026-07-31", "类型": "学科声明", "测试学科": "条件论基础声明 v1.0（学科编号 001）", "核心内容": ["元学科补全：研究知识得以成立的条件空间结构", "与智能论：结构识别 vs 结构运行——不可分离，共同构成完整协议基底", "五类操作：条件切换/组合/分离/逆转/循环", "输出格式：识别卡 + 对战报告（固定字段）"], "最终判定": {"结论": "已定稿，纳入协议理论体系（v2.0）", "定位": "协议内部存在论层的元观测位"}, "相关学科": ["条件论", "智能论"]}, ] def seed_history(self): """归档历史对战记录（观测层）：BATTLE-2026-001/002（标准报告模板 P31/P33）。""" nodes = self.store.query_nodes(layer=MemoryLayer.KNOWLEDGE, limit=500) if any("历史对战" in (n.tags or []) for n in nodes): return {"status": "already_archived"} archived = [] for rec in self.HISTORY_RECORDS: content = json.dumps({"type": "历史对战记录", **rec}, ensure_ascii=False) cs = ConditionSpace(observation_position="历史对战后复盘", observation_tool="固定招式顺序推演", time_window=(0.0, 9999999999.0), existence_constraint="报告由设计者对话历史产生（2026-07-30/31）") rec_type = rec.get("类型", "历史对战") tags = ["观测层", rec_type] + [f"domain:{n}" for n in rec["相关学科"]] if rec_type == "历史对战": tags.append("边界测试") node = self._perceive(content, modality="text", condition_space=cs, importance=0.7, tags=tags) for name in rec["相关学科"]: ent = self._resolve_entry(name) if ent: self._link(ent.id, node.id, relation_type=EdgeType.SIMILAR, confidence=0.8, condition_space=cs, source_evidence="extracted") archived.append({"报告编号": rec["报告编号"], "record_id": node.id}) return {"status": "archived", "records": archived} def dex_homology(self, entry_ref, strip_concepts=None): """内部同源性检验（P34）：版本A（完整）vs 版本B（剥离指定概念）对战中 检验「条件论是装饰还是必要结构」——添加功能还是揭示已有结构。""" A = self._resolve_entry(entry_ref) if not A: return {"error": "entry_not_found", "entry": entry_ref} concepts = strip_concepts or ["条件", "条件空间", "视角切换", "识别卡"] na = A.state_attributes.get("name") c2a = A.state_attributes.get("card2") or {} c2b = {} for k, v in c2a.items(): stripped = v for c in concepts: stripped = stripped.replace(c, "【剥离】") c2b[k] = stripped class _Mini: pass B = _Mini() B.state_attributes = {"name": f"{na}（不含{concepts[0]}）", "card2": c2b} B.content = A.content results = {} for label, ent in (("版本A(完整)", A), ("版本B(剥离)", B)): results[label] = [{"move": mv["name"], "status": self._probe(ent, mv["desc"])["status"]} for mv in self.OPERATION_MOVES] def off(rr): return sum(1 for x in rr if x["status"] in ("边界暴露", "崩溃")) a_off, b_off = off(results["版本A(完整)"]), off(results["版本B(剥离)"]) if a_off == 0 and b_off == 0: conclusion = "两版本一致稳定——条件论是更高效的表达方式而非必要条件（智能论已隐含条件意识）" elif b_off > a_off: conclusion = "版本B(剥离)更不稳定——条件论是智能论的结构性补全，不可或缺" else: conclusion = "版本A更不稳定（异常）——需复核剥离是否失真" return {"entry": na, "剥离概念": concepts, "测试": results, "偏移统计": {"版本A": a_off, "版本B": b_off}, "结论": conclusion, "note": "内部同源性检验（P34）：条件论是装饰还是必要结构——添加功能还是揭示已有结构"} def dex_standard_battle(self, a_ref, b_ref): """标准对战报告（P31 格式）：双方条件空间对照 + 招式记录 + 冲突点 + 更新建议 + 最终判定。""" A, B = self._resolve_entry(a_ref), self._resolve_entry(b_ref) if not A or not B: return {"error": "entry_not_found", "a": a_ref, "b": b_ref} na, nb = A.state_attributes.get("name"), B.state_attributes.get("name") c2a = A.state_attributes.get("card2") or {} c2b = B.state_attributes.get("card2") or {} dims = [("observation_position", "内嵌观测位"), ("existence_preset", "默认存在预设"), ("irreducible_start", "不可约起点"), ("observation_method", "有效观测方式"), ("time_causality", "时间与因果结构"), ("condition_boundary", "识别的条件边界"), ("consistency", "自洽性评估"), ("protocol_mapping", "可映射协议概念")] comparison = [{"维度": label, "A": c2a.get(k, "—"), "B": c2b.get(k, "—")} for k, label in dims] at = self.dex_auto_test(a_ref, b_ref, archive=True) moves_out = [] for attacker, defender, label in ((A, B, f"{na}→{nb}"), (B, A, f"{nb}→{na}")): for mv in self._moves(attacker) + self.OPERATION_MOVES: r = self._probe(defender, mv["desc"]) desc = r["note"] if r["hits"]: det = "；".join(f"{h['element']}({h['score']})「{h['text']}」" for h in r["hits"]) desc += f"——命中：{det}" moves_out.append({"招": f"{label}: {mv['name']}", "目标": defender.state_attributes.get("name"), "结果": r["status"], "详细说明": desc, "命中明细": r["hits"]}) conflicts = {} for m in moves_out: if m["结果"] in ("边界暴露", "崩溃"): conflicts.setdefault(m["目标"], []).append( {"招式": m["招"], "说明": m["详细说明"][:140]}) count = sum(1 for n in self.store.query_nodes(layer=MemoryLayer.KNOWLEDGE, limit=500) if "边界测试" in (n.tags or [])) return { "报告编号": f"BATTLE-2026-{100 + count:03d}", "对战双方": f"{na}（tier:{A.state_attributes.get('tier')}） vs " f"{nb}（tier:{B.state_attributes.get('tier')}）", "一·双方条件空间对照": comparison, "二·招式记录": moves_out, "三·核心冲突点": conflicts, "四·图鉴更新建议": at.get("图鉴更新建议"), "五·最终判定": { "稳定性排序": at.get("兼容度"), "依赖度": at.get("依赖度"), "边界暴露": at.get("边界偏移观测"), "边界稳固": at.get("边界稳固观测"), "record_id": at.get("record_id"), }, } def dex_usage(self): """使用与稳定性档案（P29）：使用频次 × 边界偏移 → 热门筛选（训练家选择=校准信号）。""" usage = {} for n in self.store.query_nodes(layer=MemoryLayer.KNOWLEDGE, limit=500): sa = n.state_attributes if sa.get("kind") == "knowledge" and sa.get("name"): usage[sa["name"]] = {"使用次数": n.access_count, "边界偏移": 0, "测试次数": 0} for n in self.store.query_nodes(layer=MemoryLayer.KNOWLEDGE, limit=500): tags = n.tags or [] if "观测层" in tags and "边界测试" in tags: try: data = json.loads(n.content) except Exception: continue offs = (data.get("report") or {}).get("边界偏移观测") or {} for name, moves in offs.items(): if name in usage: usage[name]["边界偏移"] += len(moves) usage[name]["测试次数"] += 1 hot = [] for name, v in usage.items(): v["稳定性"] = round(1.0 - v["边界偏移"] / max(1, v["测试次数"] + 1), 2) v["热度分"] = round(v["使用次数"] * 0.6 + v["稳定性"] * 100 * 0.4, 1) st = v["稳定性"] v["对战标签"] = ("推荐" if st >= 0.9 else ("稳定" if st >= 0.6 else ("易碎" if st >= 0.3 else "边界"))) hot.append({"name": name, **v}) hot.sort(key=lambda x: -x["热度分"]) return {"档案": hot, "note": "热门=使用频次×稳定性（P29）：训练家选择是校准信号，数据持续回写图鉴——" "落地方式不是解释，是使用"} @staticmethod def _overlap(a, b): """二字组重合度：交集规模 ÷ 较小集合规模（0~1）。""" if not a or not b: return 0.0 ka = set(a.lower()) kb = set(b.lower()) return len(ka & kb) / max(1.0, len(ka | kb)) @staticmethod def _bigram_hit(query, doc): """查询侧二元组命中率（灵枢式召回：len(qb & nb)/len(qb)）。 比单字符重叠更适合「查询短、文档长」：查询「记忆是怎么形成的」的 二元组与 trigger 的交集占查询二元组比例，避免被文档长度稀释。 """ if not query or not doc: return 0.0 def bigrams(s): s = "".join(s.split()) if len(s) <= 1: return {s} return {s[i:i + 2] for i in range(len(s) - 1)} qb = bigrams(query) nb = bigrams(doc) if not qb: return 0.0 return len(qb & nb) / len(qb) # --------------------------------------------------------------------------- # 冒烟测试 # --------------------------------------------------------------------------- def smoke(): dex = ConditionDex(fresh=True) dex.seed_base() print("=" * 66) print("智慧之书 · 冒烟测试") print("=" * 66) print("基底节点:", len(dex._by_name), "| 关系边:", len(BASE_RELATIONS)) print("\n[1] dex_filter 领域=智能论:") for r in dex.dex_filter(domain="智能论"): print(" ", r) print("\n[2] dex_filter level_min=3, status=verified:") for r in dex.dex_filter(level_min=3, status="verified"): print(" ", r["name"], r["level"], r["status"]) print("\n[3] dex_respond 条件='如何判断一个知识体系是否成立':") for r in dex.dex_respond("如何判断一个知识体系是否成立"): print(" ", r) print("\n[4] dex_combine 智能论 × 信息论:") print(" ", dex.dex_combine(dex._by_name["智能论"], dex._by_name["信息论"])) print("\n[5] dex_invert 智能论:") inv = dex.dex_invert(dex._by_name["智能论"]) print(" 失效条件:", inv["失效条件"]) print(" 观察边界:", inv["观察边界"]) print("\n[6] dex_cycle 存在论:") print(" ", dex.dex_cycle(dex._by_name["存在论"])) print("\n[7] dex_analyze 外部知识='大语言模型的推理能力来自内部思维链（CoT）':") r = dex.dex_analyze("大语言模型的推理能力来自内部思维链（CoT）") print(" condition_card:", r["condition_card"]) print(" candidates:", r["candidates"]) print(" judgment:", r["judgment"]) print("\n[8] dex_status 条件论:") st = dex.dex_status(dex._by_name["条件论"]) print(" ", st["name"], st["level"], st["status"], "| relations_out:", st["relations_out"]) dex.close() print("\n冒烟通过 ✅ db:", DEFAULT_DB) if __name__ == "__main__": smoke()