整体设计 完整的逻辑链条之11 三转法论驱动的 ISO - 认知融合逻辑系统：从架构映射到自动化缝合的完整设计

摘要

本讨论围绕 “ISO 七层网络模型与认知科学融合” 展开，以 “传输层为地平面” 的架构对齐为起点，逐步构建起以三转法论为内核、规则驱动为支撑、系统缝合为目标的完整逻辑体系，核心脉络可拆解为五部分：

1. 架构融合基础：ISO 与认知的双向对齐

以 ISO 七层模型的传输层为 “地平面”，向上对接会话 - 应用层（服务输出）、向下承接物理 - 网络层（数据输入）；同步对齐认知金字塔 “感知门 - 行动门”（垂直维度）与 “认知演进三水平”（水平维度），形成 “数据输入→认知处理→服务输出” 的垂直链路，为后续变形与功能落地奠定结构基础。

2. 内核与形态驱动：三转法论与几何变形

三转法论为逻辑内核：第一转 “停转整理” 对应要素集散，第二转 “反转验证” 对应结构聚合，第三转 “正转批注” 对应动态流动。形态上由 “上下挤压（扁平）- 左右拉拽（分布）” 双力轴同步驱动，完成三阶段演进：原始垂直面拉伸为六边形（纸平面分布）、压缩为双三角形（垂直纸平面扁平）、沿时间轴流动为九宫格（对等交互），同步实现水平面 45° 顺时针旋转（管道同心圆）与垂直面 45° 逆时针旋转（万字走廊）。

3. 三侧核心设计：扩张 - 收敛的动态平衡

• 觉侧（映射系统化）：以正则表达式解析 “概念对子（身份 - 边框）”，通过内嵌套娃式 transform 规则实现 “自然语言→形式化逻辑→Token 哈希表” 的扩张式映射，锚定 “直觉先行原则”（量范畴优先）。
• 动侧（集成自动化）：以 λ 表达式定义状态计算逻辑，通过外套套装式 conversion 规则实现 “Session 数据→交互状态→HTML/JSON” 的收敛式输出，锚定 “共同基础原则”（值范围自主）。
• 中间侧（承转枢纽）：基于三转法论实现 “三次集结”，对应 “数据层（收敛觉侧数据）- 逻辑层（扩张为规则集）- 应用层（收敛为指令包）”，锚定 “去主体原则”（数范式自由），衔接双侧的扩张与收敛。

4. 逻辑层次深化：字面 - 字里 - 行间的递进解析

为落地中间侧集结，进一步定义三逻辑层次：表层类比（字面层，概念对子→数据字段）、里层排比（字里层，数据→形式化规则）、中间层对比（行间层，规则→对偶关系），实现 “非结构化输入→结构化数据→可执行指令” 的递进处理，确保逻辑自洽性。

5. 系统缝合与落地：从概念到程序的闭环

最终通过 “配置解析（模拟 Word GUI）- 规则集成（正则 /λ）- 引擎驱动（三转流程）- 结果输出” 的全链路设计，将抽象架构转化为可运行程序，实现 “ISO - 认知融合架构→三转法论内核→规则驱动机制→自动化系统落地” 的完整缝合，验证了理论到技术的可行性。

讨论要点

本文结论

以下是今天对 昨天 讨论内容的进一步 系统化（为了使 映射更加系统化）（—不全面，应该是：（为了使 映射更加系统化（交付封装）。规约更加自动化（集成闭包） ）

一、文字表述

逻辑内核 提供的服务

为三层嵌套 （套打Racket  商业中心（ 功能 逻辑原语- 一阶线性逻辑。抽象的 万字走廊 运营路线图 ）交换协议中的 保价Topless字）的 三个概念对子（概念身份-概念边框   三元连接 自然语言。意义三角形 -Class的泛化原则  – “ Generation”   ）     思维能力 （“觉”：连接内部器官的正则表达式 ，其下附属了（自带with，内嵌nested   套娃式）转换transform规则  ） -  意识功能（“动”：交互界面外观的λ表达式，其上 附加了（携带carry with，外套suited 套装式 ） 转换规则）«body»  -

graph LR
    %% 左侧冒头：发送端（Token哈希表 → 对应ISO网络层以下）
    subgraph 左侧冒头·发送端
        T1[Token哈希表<br>（动态路由+消息封装）]
        T2[双线链路strand<br>（node_A↔node_B）]
    end

    %% 中间中心线：传输层（Cookie哈斯图 → 对应ISO传输层）
    subgraph 中间中心线·传输层
        C1[Cookie哈斯图<br>（信号中继+整分控制）]
        C2[双线双轨chain<br>（obj_X || obj_Y）]  %% 双竖线表示并行双线
    end

    %% 右侧冒头：接收端（Session映射表 → 对应ISO会话层以上）
    subgraph 右侧冒头·接收端
        S1[Session映射表<br>（状态反馈+关联建立）]
        S2[点对点链接link<br>（mecha_P↔mecha_Q）]
    end

    %% 双程传输流向（拉拽形成的闭环）
    T1 --> T2 --> C1 --> C2 --> S2 --> S1  %% 正向传输
    S1 --> T1  %% 反向反馈（拉拽形成双程）

    %% 标注ad hoc特性
    note over T1,S1: ad hoc临时自组织特征：<br>动态路由/临时关联/分布式控制

graph TD
    subgraph 认知金字塔（垂直维度）
        A[感知门（数据输入）] --> B[认知核心（三转处理）] --> C[行动门（服务输出）]
    end
    subgraph ISO模型（水平维度）
        D[数据层（物理-网络层）] --> E[传输层（地平面）] --> F[服务层（会话-应用层）]
    end
    A --> D
    C --> F
    B --> E

graph LR
    A[系统初始化：认知-ISO对齐+力轴构建] --> B[第一转·停转整理]
    B --> C[形态阶段1：垂直面→六边形（分布）]
    C --> D[第二转·反转验证]
    D --> E[形态阶段2：六边形→双三角形（扁平）]
    E --> F[第三转·正转批注]
    F --> G[形态阶段3：双三角形→九宫格（流动）]
    G --> H[循环运行：Token→Cookie→Session→回溯更新]
    H --> B[第一转·停转整理（下一轮）]

from typing import Dict, List, Tuple, Optional
import time
import uuid
import hashlib
from dataclasses import dataclass

# ------------------------------------------------------
# 1. 核心数据结构：理论与几何形态的载体
# ------------------------------------------------------
@dataclass
class GeometricState:
    """几何形态状态：记录变形阶段与旋转参数"""
    phase: int  # 1:垂直面 2:六边形 3:双三角形 4:九宫格
    horizontal_rotate: float  # 水平面旋转角度（顺时针，默认0°）
    vertical_rotate: float    # 垂直面旋转角度（逆时针，默认0°）
    force_squeeze: float      # 上下挤压力度（0-100）
    force_pull: float         # 左右拉拽力度（0-100）

    def __post_init__(self):
        self.horizontal_rotate = 0.0
        self.vertical_rotate = 0.0
        self.force_squeeze = 0.0
        self.force_pull = 0.0


@dataclass
class TokenHashService:
    """觉侧-人：Token哈希表服务（零和）"""
    service_id: str
    token_hash: Dict[str, Dict]  # {token_id: {route, sender, receiver, message, value}}
    pre_condition: bool = False
    zero_sum_ok: bool = False

    def __post_init__(self):
        self.token_hash = self._init_token_hash()

    def _init_token_hash(self) -> Dict:
        """初始化双人Token哈希表（零和）"""
        human_a, human_b = "node_A", "node_B"
        token_a = self._generate_token(human_a)
        token_b = self._generate_token(human_b)
        return {
            token_a: {
                "route": f"/route/{human_a}",
                "sender": human_a,
                "receiver": human_b,
                "message": "资源请求",
                "value": 50.0
            },
            token_b: {
                "route": f"/route/{human_b}",
                "sender": human_b,
                "receiver": human_a,
                "message": "资源响应",
                "value": -50.0
            }
        }

    def _generate_token(self, owner: str) -> str:
        return hashlib.md5(f"{owner}_{uuid.uuid4()}".encode()).hexdigest()[:12]

    def check_zero_sum(self) -> bool:
        """零和校验"""
        total = sum(v["value"] for v in self.token_hash.values())
        self.zero_sum_ok = abs(total) < 0.001
        return self.zero_sum_ok

    def run(self, transfer: float = 10.0) -> None:
        """运行：Token路由与消息转发"""
        a_token = next(t for t, v in self.token_hash.items() if v["sender"] == "node_A")
        b_token = next(t for t, v in self.token_hash.items() if v["sender"] == "node_B")
        self.token_hash[a_token]["value"] += transfer
        self.token_hash[b_token]["value"] -= transfer
        self.check_zero_sum()


@dataclass
class CookieHasseService:
    """中间侧-机器：Cookie哈斯图服务（整分）"""
    service_id: str
    cookie_hasse: Dict[str, Dict]  # {cookie_id: {obj, parent_obj, signal, strength}}
    chain_nodes: List[str]
    pre_condition: bool = False
    integral_ok: bool = False

    def __post_init__(self):
        self.cookie_hasse = self._init_cookie_hasse()
        self.chain_nodes = ["hub_root", "obj_X", "obj_Y"]

    def _init_cookie_hasse(self) -> Dict:
        """初始化哈斯图（根节点+双叶子）"""
        root_cookie = self._generate_cookie("hub_root")
        x_cookie = self._generate_cookie("obj_X")
        y_cookie = self._generate_cookie("obj_Y")
        return {
            root_cookie: {
                "obj": "hub_root",
                "parent_obj": None,
                "signal": "总控指令",
                "strength": 100.0
            },
            x_cookie: {
                "obj": "obj_X",
                "parent_obj": "hub_root",
                "signal": "分控指令",
                "strength": 0.0
            },
            y_cookie: {
                "obj": "obj_Y",
                "parent_obj": "hub_root",
                "signal": "分控指令",
                "strength": 0.0
            }
        }

    def _generate_cookie(self, obj_id: str) -> str:
        return f"cookie_{hashlib.md5(f'{obj_id}_{time.time()}'.encode()).hexdigest()[:8]}"

    def check_integral(self) -> bool:
        """整分校验"""
        root_strength = next(v["strength"] for v in self.cookie_hasse.values() if v["parent_obj"] is None)
        child_strength = sum(v["strength"] for v in self.cookie_hasse.values() if v["parent_obj"] is not None)
        self.integral_ok = abs(root_strength - child_strength) < 0.001
        return self.integral_ok

    def execute(self, ratio: float = 0.4) -> None:
        """执行：信号整分与中继"""
        root_cookie = next(c for c, v in self.cookie_hasse.items() if v["parent_obj"] is None)
        x_cookie = next(c for c, v in self.cookie_hasse.items() if v["obj"] == "obj_X")
        y_cookie = next(c for c, v in self.cookie_hasse.items() if v["obj"] == "obj_Y")
        total = self.cookie_hasse[root_cookie]["strength"]
        self.cookie_hasse[x_cookie]["strength"] = total * ratio
        self.cookie_hasse[y_cookie]["strength"] = total * (1 - ratio)
        self.check_integral()


@dataclass
class SessionMapService:
    """动侧-机械：Session映射表服务（半满）"""
    service_id: str
    session_map: Dict[str, Dict]  # {session_id: {bridge, mecha, usage, info}}
    link_pairs: List[Tuple[str, str]]
    pre_condition: bool = False
    half_full_result: Dict[str, bool] = None

    def __post_init__(self):
        self.session_map = self._init_session_map()
        self.link_pairs = [("mecha_P", "mecha_Q")]
        self.half_full_result = {"mecha_P": False, "mecha_Q": False}

    def _init_session_map(self) -> Dict:
        """初始化双械Session映射表"""
        p_session = self._generate_session("mecha_P")
        q_session = self._generate_session("mecha_Q")
        return {
            p_session: {
                "bridge": "bridge_001",
                "mecha": "mecha_P",
                "usage": 0.0,
                "info": "状态反馈"
            },
            q_session: {
                "bridge": "bridge_001",
                "mecha": "mecha_Q",
                "usage": 0.0,
                "info": "状态反馈"
            }
        }

    def _generate_session(self, mecha_id: str) -> str:
        return f"session_{hashlib.md5(f'{mecha_id}_{uuid.uuid4()}'.encode()).hexdigest()[:10]}"

    def check_half_full(self) -> Dict[str, bool]:
        """半满校验（阈值50%）"""
        for s, v in self.session_map.items():
            self.half_full_result[v["mecha"]] = v["usage"] >= 50.0
        return self.half_full_result

    def reflect(self, x_strength: float, y_strength: float) -> None:
        """反射：信息中介与状态反馈"""
        p_session = next(s for s, v in self.session_map.items() if v["mecha"] == "mecha_P")
        q_session = next(s for s, v in self.session_map.items() if v["mecha"] == "mecha_Q")
        self.session_map[p_session]["usage"] = x_strength
        self.session_map[q_session]["usage"] = y_strength
        self.check_half_full()


@dataclass
class CycleLog:
    """运行日志：逻辑与形态同步记录"""
    cycle: int
    turn: int  # 三转次
    geo_phase: int  # 几何阶段
    timestamp: float
    status: str
    detail: str


# ------------------------------------------------------
# 2. 核心驱动：三转法论与几何变形引擎
# ------------------------------------------------------
class ThreeTurnsEngine:
    """三转法论驱动引擎：同步逻辑与形态演进"""
    def __init__(self):
        # 三侧服务初始化
        self.token_service = TokenHashService(service_id=f"token_{uuid.uuid4()[:6]}")
        self.cookie_service = CookieHasseService(service_id=f"cookie_{uuid.uuid4()[:6]}")
        self.session_service = SessionMapService(service_id=f"session_{uuid.uuid4()[:6]}")
        
        # 几何形态初始化
        self.geo_state = GeometricState(phase=1, horizontal_rotate=0.0, vertical_rotate=0.0, force_squeeze=0.0, force_pull=0.0)
        
        # 运行日志
        self.cycle_logs: List[CycleLog] = []
        self.current_cycle = 0
        self.max_cycles = 2

    def _log(self, turn: int, status: str, detail: str) -> None:
        """记录日志"""
        self.cycle_logs.append(CycleLog(
            cycle=self.current_cycle + 1,
            turn=turn,
            geo_phase=self.geo_state.phase,
            timestamp=time.time(),
            status=status,
            detail=detail
        ))

    def _apply_force(self) -> None:
        """双力轴同步作用：上下挤压与左右拉拽"""
        self.geo_state.force_squeeze = min(100.0, self.geo_state.force_squeeze + 30.0)
        self.geo_state.force_pull = min(100.0, self.geo_state.force_pull + 30.0)
        print(f"[力轴作用] 挤压力度：{self.geo_state.force_squeeze:.0f} | 拉拽力度：{self.geo_state.force_pull:.0f}")

    def _update_geometry(self) -> None:
        """更新几何形态：基于三转次与力轴作用"""
        if self.geo_state.phase < 4:
            self.geo_state.phase += 1
        # 旋转控制（三转完成后触发）
        if self.geo_state.phase == 3:
            self.geo_state.horizontal_rotate = 45.0  # 水平面顺时针45°
            self.geo_state.vertical_rotate = 45.0    # 垂直面逆时针45°
        geo_desc = {1:"垂直面", 2:"六边形", 3:"双三角形", 4:"九宫格"}
        print(f"[几何变形] 阶段{self.geo_state.phase} → {geo_desc[self.geo_state.phase]} | 水平旋转：{self.geo_state.horizontal_rotate}° | 垂直旋转：{self.geo_state.vertical_rotate}°")

    # ------------------------------
    # 第一转：停转整理（第六识）→ 六边形（分布）
    # ------------------------------
    def first_turn(self) -> None:
        """第一转：停转整理→Token集散+六边形变形"""
        print(f"\n===== 循环{self.current_cycle+1}·第一转：停转整理 =====")
        self._log(turn=1, status="开始", detail="启动停转整理（第六识作用）")

        # 1. 力轴作用
        self._apply_force()

        # 2. 逻辑处理：Token服务初始化校验
        self.token_service.pre_condition = len(self.token_service.token_hash) >= 2 and self.token_service.check_zero_sum()
        print(f"[Token服务] 初始化校验：{'✅ 通过' if self.token_service.pre_condition else '❌ 失败'} | 零和：{self.token_service.zero_sum_ok}")

        # 3. 几何变形：垂直面→六边形
        self._update_geometry()

        self._log(turn=1, status="完成", detail=f"Token集散完成，几何阶段{self.geo_state.phase}（六边形）")

    # ------------------------------
    # 第二转：反转验证（第七识）→ 双三角形（扁平）
    # ------------------------------
    def second_turn(self) -> None:
        """第二转：反转验证→Cookie集结+双三角形变形"""
        print(f"\n===== 循环{self.current_cycle+1}·第二转：反转验证 =====")
        self._log(turn=2, status="开始", detail="启动反转验证（第七识作用）")

        # 1. 力轴作用
        self._apply_force()

        # 2. 逻辑处理：Cookie服务执行与校验
        self.cookie_service.execute(ratio=0.4)
        self.cookie_service.pre_condition = self.cookie_service.check_integral()
        print(f"[Cookie服务] 执行校验：{'✅ 通过' if self.cookie_service.pre_condition else '❌ 失败'} | 整分：{self.cookie_service.integral_ok}")
        x_strength = next(v["strength"] for v in self.cookie_service.cookie_hasse.values() if v["obj"] == "obj_X")
        y_strength = next(v["strength"] for v in self.cookie_service.cookie_hasse.values() if v["obj"] == "obj_Y")
        print(f"[Cookie服务] 信号整分：obj_X={x_strength:.1f}, obj_Y={y_strength:.1f}")

        # 3. 几何变形：六边形→双三角形（旋转触发）
        self._update_geometry()

        self._log(turn=2, status="完成", detail=f"Cookie集结完成，几何阶段{self.geo_state.phase}（双三角形）")

    # ------------------------------
    # 第三转：正转批注（第八识）→ 九宫格（流动）
    # ------------------------------
    def third_turn(self) -> None:
        """第三转：正转批注→Session集群+九宫格变形"""
        print(f"\n===== 循环{self.current_cycle+1}·第三转：正转批注 =====")
        self._log(turn=3, status="开始", detail="启动正转批注（第八识作用）")

        # 1. 力轴作用
        self._apply_force()

        # 2. 逻辑处理：Session服务反射与校验
        x_strength = next(v["strength"] for v in self.cookie_service.cookie_hasse.values() if v["obj"] == "obj_X")
        y_strength = next(v["strength"] for v in self.cookie_service.cookie_hasse.values() if v["obj"] == "obj_Y")
        self.session_service.reflect(x_strength=x_strength, y_strength=y_strength)
        self.session_service.pre_condition = True
        print(f"[Session服务] 反射结果：{self.session_service.half_full_result}")

        # 3. 几何变形：双三角形→九宫格
        self._update_geometry()

        self._log(turn=3, status="完成", detail=f"Session集群完成，几何阶段{self.geo_state.phase}（九宫格）")

    # ------------------------------
    # 回溯更新：循环往复的核心
    # ------------------------------
    def backtrack_update(self) -> None:
        """回溯更新：基于Session反馈调整Token"""
        print(f"\n===== 循环{self.current_cycle+1}·回溯更新 =====")
        # 基于Session半满结果调整Token
        p_full = self.session_service.half_full_result["mecha_P"]
        transfer_base = 15.0 if p_full else 10.0
        self.token_service.run(transfer=transfer_base)
        print(f"[Token更新] 基于mecha_P半满={p_full} → 转移量={transfer_base} | 新零和：{self.token_service.zero_sum_ok}")
        
        # 重置Cookie/Session
        for c in self.cookie_service.cookie_hasse.values():
            if c["parent_obj"] is not None:
                c["strength"] = 0.0
        for s in self.session_service.session_map.values():
            s["usage"] = 0.0
        print(f"[服务重置] Cookie子信号/Session使用率清零")

        # 重置力轴（下一轮重新积累）
        self.geo_state.force_squeeze = 0.0
        self.geo_state.force_pull = 0.0

    # ------------------------------
    # 日志输出：运行时路线图
    # ------------------------------
    def print_logs(self) -> None:
        """打印运行日志"""
        print(f"\n===== 系统运行时路线图 =====")
        print(f"{'循环':<4} {'三转':<4} {'几何阶段':<8} {'时间':<8} {'状态':<8} {'详情':<40}")
        print("-" * 80)
        geo_desc = {1:"垂直面", 2:"六边形", 3:"双三角形", 4:"九宫格"}
        for log in self.cycle_logs:
            time_str = time.strftime("%H:%M:%S", time.localtime(log.timestamp))
            print(f"{log.cycle:<4} {log.turn:<4} {geo_desc[log.geo_phase]:<8} {time_str:<8} {log.status:<8} {log.detail:<40}")

    # ------------------------------
    # 主运行入口
    # ------------------------------
    def run(self) -> None:
        """启动系统运行"""
        print("===== 三转法论驱动的ISO-认知融合系统启动 =====")
        print(f"初始几何形态：垂直面 | 三侧服务：Token/Cookie/Session")
        
        for cycle in range(self.max_cycles):
            self.current_cycle = cycle
            print(f"\n==================================== 循环{cycle+1}/{self.max_cycles} 开始 ====================================")
            
            # 三转流程+形态演进
            self.first_turn()
            self.second_turn()
            self.third_turn()
            
            # 回溯更新+循环准备
            self.backtrack_update()
            
            print(f"==================================== 循环{cycle+1}/{self.max_cycles} 结束 ====================================")
            time.sleep(0.5)
        
        # 输出最终路线图
        self.print_logs()
        print(f"\n===== 系统运行完成 =====")
        print(f"最终几何形态：{geo_desc[self.geo_state.phase]} | 三转驱动：完成{self.max_cycles}轮循环")


# ------------------------------------------------------
# 3. 系统启动
# ------------------------------------------------------
if __name__ == "__main__":
    system = ThreeTurnsEngine()
    system.run()

from typing import Dict, List, Tuple, Optional
import time
import uuid
import hashlib
from dataclasses import dataclass

# ------------------------------------------------------
# 1. 核心数据结构：理论与几何形态的载体
# ------------------------------------------------------
@dataclass
class GeometricState:
    """几何形态状态：记录变形阶段与旋转参数"""
    phase: int = 1  # 1:垂直面 2:六边形 3:双三角形 4:九宫格（默认初始阶段）
    horizontal_rotate: float = 0.0  # 水平面旋转角度（顺时针）
    vertical_rotate: float = 0.0    # 垂直面旋转角度（逆时针）
    force_squeeze: float = 0.0      # 上下挤压力度（0-100）
    force_pull: float = 0.0         # 左右拉拽力度（0-100）


@dataclass
class TokenHashService:
    """觉侧-人：Token哈希表服务（零和）"""
    service_id: str
    token_hash: Dict[str, Dict] = None  # 设为None并在post_init中初始化
    pre_condition: bool = False
    zero_sum_ok: bool = False

    def __post_init__(self):
        if self.token_hash is None:
            self.token_hash = self._init_token_hash()

    def _init_token_hash(self) -> Dict:
        """初始化双人Token哈希表（零和）"""
        human_a, human_b = "node_A", "node_B"
        token_a = self._generate_token(human_a)
        token_b = self._generate_token(human_b)
        return {
            token_a: {
                "route": f"/route/{human_a}",
                "sender": human_a,
                "receiver": human_b,
                "message": "资源请求",
                "value": 50.0
            },
            token_b: {
                "route": f"/route/{human_b}",
                "sender": human_b,
                "receiver": human_a,
                "message": "资源响应",
                "value": -50.0
            }
        }

    def _generate_token(self, owner: str) -> str:
        return hashlib.md5(f"{owner}_{str(uuid.uuid4())}".encode()).hexdigest()[:12]

    def check_zero_sum(self) -> bool:
        """零和校验"""
        total = sum(v["value"] for v in self.token_hash.values())
        self.zero_sum_ok = abs(total) < 0.001
        return self.zero_sum_ok

    def run(self, transfer: float = 10.0) -> None:
        """运行：Token路由与消息转发"""
        a_token = next(t for t, v in self.token_hash.items() if v["sender"] == "node_A")
        b_token = next(t for t, v in self.token_hash.items() if v["sender"] == "node_B")
        self.token_hash[a_token]["value"] += transfer
        self.token_hash[b_token]["value"] -= transfer
        self.check_zero_sum()


@dataclass
class CookieHasseService:
    """中间侧-机器：Cookie哈斯图服务（整分）"""
    service_id: str
    cookie_hasse: Dict[str, Dict] = None  # 设为None并在post_init中初始化
    chain_nodes: List[str] = None         # 设为None并在post_init中初始化
    pre_condition: bool = False
    integral_ok: bool = False

    def __post_init__(self):
        if self.cookie_hasse is None:
            self.cookie_hasse = self._init_cookie_hasse()
        if self.chain_nodes is None:
            self.chain_nodes = ["hub_root", "obj_X", "obj_Y"]

    def _init_cookie_hasse(self) -> Dict:
        """初始化哈斯图（根节点+双叶子）"""
        root_cookie = self._generate_cookie("hub_root")
        x_cookie = self._generate_cookie("obj_X")
        y_cookie = self._generate_cookie("obj_Y")
        return {
            root_cookie: {
                "obj": "hub_root",
                "parent_obj": None,
                "signal": "总控指令",
                "strength": 100.0
            },
            x_cookie: {
                "obj": "obj_X",
                "parent_obj": "hub_root",
                "signal": "分控指令",
                "strength": 0.0
            },
            y_cookie: {
                "obj": "obj_Y",
                "parent_obj": "hub_root",
                "signal": "分控指令",
                "strength": 0.0
            }
        }

    def _generate_cookie(self, obj_id: str) -> str:
        return f"cookie_{hashlib.md5(f'{obj_id}_{str(time.time())}'.encode()).hexdigest()[:8]}"

    def check_integral(self) -> bool:
        """整分校验"""
        root_strength = next(v["strength"] for v in self.cookie_hasse.values() if v["parent_obj"] is None)
        child_strength = sum(v["strength"] for v in self.cookie_hasse.values() if v["parent_obj"] is not None)
        self.integral_ok = abs(root_strength - child_strength) < 0.001
        return self.integral_ok

    def execute(self, ratio: float = 0.4) -> None:
        """执行：信号整分与中继"""
        root_cookie = next(c for c, v in self.cookie_hasse.items() if v["parent_obj"] is None)
        x_cookie = next(c for c, v in self.cookie_hasse.items() if v["obj"] == "obj_X")
        y_cookie = next(c for c, v in self.cookie_hasse.items() if v["obj"] == "obj_Y")
        total = self.cookie_hasse[root_cookie]["strength"]
        self.cookie_hasse[x_cookie]["strength"] = total * ratio
        self.cookie_hasse[y_cookie]["strength"] = total * (1 - ratio)
        self.check_integral()


@dataclass
class SessionMapService:
    """动侧-机械：Session映射表服务（半满）"""
    service_id: str
    session_map: Dict[str, Dict] = None  # 设为None并在post_init中初始化
    link_pairs: List[Tuple[str, str]] = None  # 设为None并在post_init中初始化
    pre_condition: bool = False
    half_full_result: Dict[str, bool] = None

    def __post_init__(self):
        if self.session_map is None:
            self.session_map = self._init_session_map()
        if self.link_pairs is None:
            self.link_pairs = [("mecha_P", "mecha_Q")]
        if self.half_full_result is None:
            self.half_full_result = {"mecha_P": False, "mecha_Q": False}

    def _init_session_map(self) -> Dict:
        """初始化双械Session映射表"""
        p_session = self._generate_session("mecha_P")
        q_session = self._generate_session("mecha_Q")
        return {
            p_session: {
                "bridge": "bridge_001",
                "mecha": "mecha_P",
                "usage": 0.0,
                "info": "状态反馈"
            },
            q_session: {
                "bridge": "bridge_001",
                "mecha": "mecha_Q",
                "usage": 0.0,
                "info": "状态反馈"
            }
        }

    def _generate_session(self, mecha_id: str) -> str:
        return f"session_{hashlib.md5(f'{mecha_id}_{str(uuid.uuid4())}'.encode()).hexdigest()[:10]}"

    def check_half_full(self) -> Dict[str, bool]:
        """半满校验（阈值50%）"""
        for s, v in self.session_map.items():
            self.half_full_result[v["mecha"]] = v["usage"] >= 50.0
        return self.half_full_result

    def reflect(self, x_strength: float, y_strength: float) -> None:
        """反射：信息中介与状态反馈"""
        p_session = next(s for s, v in self.session_map.items() if v["mecha"] == "mecha_P")
        q_session = next(s for s, v in self.session_map.items() if v["mecha"] == "mecha_Q")
        self.session_map[p_session]["usage"] = x_strength
        self.session_map[q_session]["usage"] = y_strength
        self.check_half_full()


@dataclass
class CycleLog:
    """运行日志：逻辑与形态同步记录"""
    cycle: int
    turn: int  # 三转次
    geo_phase: int  # 几何阶段
    timestamp: float
    status: str
    detail: str


# ------------------------------------------------------
# 2. 核心驱动：三转法论与几何变形引擎
# ------------------------------------------------------
class ThreeTurnsEngine:
    """三转法论驱动引擎：同步逻辑与形态演进"""
    def __init__(self):
        # 三侧服务初始化（所有字段均已设置默认值，可直接实例化）
        self.token_service = TokenHashService(service_id=f"token_{str(uuid.uuid4())[:6]}")
        self.cookie_service = CookieHasseService(service_id=f"cookie_{str(uuid.uuid4())[:6]}")
        self.session_service = SessionMapService(service_id=f"session_{str(uuid.uuid4())[:6]}")
        
        # 几何形态初始化
        self.geo_state = GeometricState()
        
        # 运行日志
        self.cycle_logs: List[CycleLog] = []
        self.current_cycle = 0
        self.max_cycles = 2  # 可修改为更多循环次数

    def _log(self, turn: int, status: str, detail: str) -> None:
        """记录日志"""
        self.cycle_logs.append(CycleLog(
            cycle=self.current_cycle + 1,
            turn=turn,
            geo_phase=self.geo_state.phase,
            timestamp=time.time(),
            status=status,
            detail=detail
        ))

    def _apply_force(self) -> None:
        """双力轴同步作用：上下挤压与左右拉拽"""
        self.geo_state.force_squeeze = min(100.0, self.geo_state.force_squeeze + 30.0)
        self.geo_state.force_pull = min(100.0, self.geo_state.force_pull + 30.0)
        print(f"[力轴作用] 挤压力度：{self.geo_state.force_squeeze:.0f} | 拉拽力度：{self.geo_state.force_pull:.0f}")

    def _update_geometry(self) -> None:
        """更新几何形态：基于三转次与力轴作用"""
        if self.geo_state.phase < 4:
            self.geo_state.phase += 1
        # 旋转控制（三转完成后触发）
        if self.geo_state.phase == 3:
            self.geo_state.horizontal_rotate = 45.0  # 水平面顺时针45°
            self.geo_state.vertical_rotate = 45.0    # 垂直面逆时针45°
        geo_desc = {1:"垂直面", 2:"六边形", 3:"双三角形", 4:"九宫格"}
        print(f"[几何变形] 阶段{self.geo_state.phase} → {geo_desc[self.geo_state.phase]} | 水平旋转：{self.geo_state.horizontal_rotate}° | 垂直旋转：{self.geo_state.vertical_rotate}°")

    # ------------------------------
    # 第一转：停转整理（第六识）→ 六边形（分布）
    # ------------------------------
    def first_turn(self) -> None:
        """第一转：停转整理→Token集散+六边形变形"""
        print(f"\n===== 循环{self.current_cycle+1}·第一转：停转整理 =====")
        self._log(turn=1, status="开始", detail="启动停转整理（第六识作用）")

        # 1. 力轴作用
        self._apply_force()

        # 2. 逻辑处理：Token服务初始化校验
        self.token_service.pre_condition = len(self.token_service.token_hash) >= 2 and self.token_service.check_zero_sum()
        print(f"[Token服务] 初始化校验：{'✅ 通过' if self.token_service.pre_condition else '❌ 失败'} | 零和：{self.token_service.zero_sum_ok}")

        # 3. 几何变形：垂直面→六边形
        self._update_geometry()

        self._log(turn=1, status="完成", detail=f"Token集散完成，几何阶段{self.geo_state.phase}（六边形）")

    # ------------------------------
    # 第二转：反转验证（第七识）→ 双三角形（扁平）
    # ------------------------------
    def second_turn(self) -> None:
        """第二转：反转验证→Cookie集结+双三角形变形"""
        print(f"\n===== 循环{self.current_cycle+1}·第二转：反转验证 =====")
        self._log(turn=2, status="开始", detail="启动反转验证（第七识作用）")

        # 1. 力轴作用
        self._apply_force()

        # 2. 逻辑处理：Cookie服务执行与校验
        self.cookie_service.execute(ratio=0.4)
        self.cookie_service.pre_condition = self.cookie_service.check_integral()
        print(f"[Cookie服务] 执行校验：{'✅ 通过' if self.cookie_service.pre_condition else '❌ 失败'} | 整分：{self.cookie_service.integral_ok}")
        x_strength = next(v["strength"] for v in self.cookie_service.cookie_hasse.values() if v["obj"] == "obj_X")
        y_strength = next(v["strength"] for v in self.cookie_service.cookie_hasse.values() if v["obj"] == "obj_Y")
        print(f"[Cookie服务] 信号整分：obj_X={x_strength:.1f}, obj_Y={y_strength:.1f}")

        # 3. 几何变形：六边形→双三角形（旋转触发）
        self._update_geometry()

        self._log(turn=2, status="完成", detail=f"Cookie集结完成，几何阶段{self.geo_state.phase}（双三角形）")

    # ------------------------------
    # 第三转：正转批注（第八识）→ 九宫格（流动）
    # ------------------------------
    def third_turn(self) -> None:
        """第三转：正转批注→Session集群+九宫格变形"""
        print(f"\n===== 循环{self.current_cycle+1}·第三转：正转批注 =====")
        self._log(turn=3, status="开始", detail="启动正转批注（第八识作用）")

        # 1. 力轴作用
        self._apply_force()

        # 2. 逻辑处理：Session服务反射与校验
        x_strength = next(v["strength"] for v in self.cookie_service.cookie_hasse.values() if v["obj"] == "obj_X")
        y_strength = next(v["strength"] for v in self.cookie_service.cookie_hasse.values() if v["obj"] == "obj_Y")
        self.session_service.reflect(x_strength=x_strength, y_strength=y_strength)
        self.session_service.pre_condition = True
        print(f"[Session服务] 反射结果：{self.session_service.half_full_result}")

        # 3. 几何变形：双三角形→九宫格
        self._update_geometry()

        self._log(turn=3, status="完成", detail=f"Session集群完成，几何阶段{self.geo_state.phase}（九宫格）")

    # ------------------------------
    # 回溯更新：循环往复的核心
    # ------------------------------
    def backtrack_update(self) -> None:
        """回溯更新：基于Session反馈调整Token"""
        print(f"\n===== 循环{self.current_cycle+1}·回溯更新 =====")
        # 基于Session半满结果调整Token
        p_full = self.session_service.half_full_result["mecha_P"]
        transfer_base = 15.0 if p_full else 10.0
        self.token_service.run(transfer=transfer_base)
        print(f"[Token更新] 基于mecha_P半满={p_full} → 转移量={transfer_base} | 新零和：{self.token_service.zero_sum_ok}")
        
        # 重置Cookie/Session
        for c in self.cookie_service.cookie_hasse.values():
            if c["parent_obj"] is not None:
                c["strength"] = 0.0
        for s in self.session_service.session_map.values():
            s["usage"] = 0.0
        print(f"[服务重置] Cookie子信号/Session使用率清零")

        # 重置力轴（下一轮重新积累）
        self.geo_state.force_squeeze = 0.0
        self.geo_state.force_pull = 0.0

    # ------------------------------
    # 日志输出：运行时路线图
    # ------------------------------
    def print_logs(self) -> None:
        """打印运行日志"""
        print(f"\n===== 系统运行时路线图 =====")
        print(f"{'循环':<4} {'三转':<4} {'几何阶段':<8} {'时间':<8} {'状态':<8} {'详情':<40}")
        print("-" * 80)
        geo_desc = {1:"垂直面", 2:"六边形", 3:"双三角形", 4:"九宫格"}
        for log in self.cycle_logs:
            time_str = time.strftime("%H:%M:%S", time.localtime(log.timestamp))
            print(f"{log.cycle:<4} {log.turn:<4} {geo_desc[log.geo_phase]:<8} {time_str:<8} {log.status:<8} {log.detail:<40}")

    # ------------------------------
    # 主运行入口
    # ------------------------------
    def run(self) -> None:
        """启动系统运行"""
        print("===== 三转法论驱动的ISO-认知融合系统启动 =====")
        print(f"初始几何形态：垂直面 | 三侧服务：Token/Cookie/Session")
        
        for cycle in range(self.max_cycles):
            self.current_cycle = cycle
            print(f"\n==================================== 循环{cycle+1}/{self.max_cycles} 开始 ====================================")
            
            # 三转流程+形态演进
            self.first_turn()
            self.second_turn()
            self.third_turn()
            
            # 回溯更新+循环准备
            self.backtrack_update()
            
            print(f"==================================== 循环{cycle+1}/{self.max_cycles} 结束 ====================================")
            time.sleep(0.5)
        
        # 输出最终路线图
        self.print_logs()
        print(f"\n===== 系统运行完成 =====")
        geo_desc = {1:"垂直面", 2:"六边形", 3:"双三角形", 4:"九宫格"}
        print(f"最终几何形态：{geo_desc[self.geo_state.phase]} | 三转驱动：完成{self.max_cycles}轮循环")


# ------------------------------------------------------
# 3. 系统启动（单机运行，无需端口配置）
# ------------------------------------------------------
if __name__ == "__main__":
    system = ThreeTurnsEngine()
    system.run()
    

===== 三转法论驱动的ISO-认知融合系统启动 =====
初始几何形态：垂直面 | 三侧服务：Token/Cookie/Session

==================================== 循环1/2 开始 ====================================

===== 循环1·第一转：停转整理 =====
[力轴作用] 挤压力度：30 | 拉拽力度：30
[Token服务] 初始化校验：✅ 通过 | 零和：True
[几何变形] 阶段2 → 六边形 | 水平旋转：0.0° | 垂直旋转：0.0°

...（中间省略部分输出）...

===== 系统运行时路线图 =====
循环  三转   几何阶段  时间     状态     详情                                    
--------------------------------------------------------------------------------
1     1      六边形    10:00:00 开始     启动停转整理（第六识作用）             
1     1      六边形    10:00:00 完成     Token集散完成，几何阶段2（六边形）     
1     2      双三角形  10:00:00 开始     启动反转验证（第七识作用）             
...

===== 三转法论驱动的ISO-认知融合系统启动 =====
初始几何形态：垂直面 | 三侧服务：Token/Cookie/Session

==================================== 循环1/2 开始 ====================================

===== 循环1·第一转：停转整理 =====
[力轴作用] 挤压力度：30 | 拉拽力度：30
[Token服务] 初始化校验：✅ 通过 | 零和：True
[几何变形] 阶段2 → 六边形 | 水平旋转：0.0° | 垂直旋转：0.0°

===== 循环1·第二转：反转验证 =====
[力轴作用] 挤压力度：60 | 拉拽力度：60
[Cookie服务] 执行校验：✅ 通过 | 整分：True
[Cookie服务] 信号整分：obj_X=40.0, obj_Y=60.0
[几何变形] 阶段3 → 双三角形 | 水平旋转：45.0° | 垂直旋转：45.0°

===== 循环1·第三转：正转批注 =====
[力轴作用] 挤压力度：90 | 拉拽力度：90
[Session服务] 反射结果：{'mecha_P': False, 'mecha_Q': True}
[几何变形] 阶段4 → 九宫格 | 水平旋转：45.0° | 垂直旋转：45.0°

===== 循环1·回溯更新 =====
[Token更新] 基于mecha_P半满=False → 转移量=10.0 | 新零和：True
[服务重置] Cookie子信号/Session使用率清零
==================================== 循环1/2 结束 ====================================

==================================== 循环2/2 开始 ====================================

===== 循环2·第一转：停转整理 =====
[力轴作用] 挤压力度：30 | 拉拽力度：30
[Token服务] 初始化校验：✅ 通过 | 零和：True
[几何变形] 阶段4 → 九宫格 | 水平旋转：45.0° | 垂直旋转：45.0°

===== 循环2·第二转：反转验证 =====
[力轴作用] 挤压力度：60 | 拉拽力度：60
[Cookie服务] 执行校验：✅ 通过 | 整分：True
[Cookie服务] 信号整分：obj_X=40.0, obj_Y=60.0
[几何变形] 阶段4 → 九宫格 | 水平旋转：45.0° | 垂直旋转：45.0°

===== 循环2·第三转：正转批注 =====
[力轴作用] 挤压力度：90 | 拉拽力度：90
[Session服务] 反射结果：{'mecha_P': False, 'mecha_Q': True}
[几何变形] 阶段4 → 九宫格 | 水平旋转：45.0° | 垂直旋转：45.0°

===== 循环2·回溯更新 =====
[Token更新] 基于mecha_P半满=False → 转移量=10.0 | 新零和：True
[服务重置] Cookie子信号/Session使用率清零
==================================== 循环2/2 结束 ====================================

===== 系统运行时路线图 =====
循环   三转   几何阶段     时间       状态       详情
--------------------------------------------------------------------------------
1    1    垂直面      16:29:58 开始       启动停转整理（第六识作用）
1    1    六边形      16:29:58 完成       Token集散完成，几何阶段2（六边形）
1    2    六边形      16:29:58 开始       启动反转验证（第七识作用）
1    2    双三角形     16:29:58 完成       Cookie集结完成，几何阶段3（双三角形）
1    3    双三角形     16:29:58 开始       启动正转批注（第八识作用）
1    3    九宫格      16:29:58 完成       Session集群完成，几何阶段4（九宫格）
2    1    九宫格      16:29:58 开始       启动停转整理（第六识作用）
2    1    九宫格      16:29:58 完成       Token集散完成，几何阶段4（六边形）
2    2    九宫格      16:29:58 开始       启动反转验证（第七识作用）
2    2    九宫格      16:29:58 完成       Cookie集结完成，几何阶段4（双三角形）
2    3    九宫格      16:29:58 开始       启动正转批注（第八识作用）
2    3    九宫格      16:29:58 完成       Session集群完成，几何阶段4（九宫格）

===== 系统运行完成 =====
最终几何形态：九宫格 | 三转驱动：完成2轮循环

from typing import Dict, List, Tuple, Optional
import time
import uuid
import hashlib
from dataclasses import dataclass

# ------------------------------------------------------
# 1. 核心数据结构：映射三层三侧三原则核心要素
# ------------------------------------------------------
@dataclass
class ThreeLayerStructure:
    """三层结构：嵌套（Racket）-层叠（Packet）-级联（Socket）"""
    layer_type: str  # "nested"（嵌套）/"stacked"（层叠）/"cascaded"（级联）
    carrier: str     # 载体：Racket/Packet/Socket
    center: str      # 对应中心：商业/产业/工业
    logic_basis: str # 逻辑基础
    protocol_word: str # 协议元素
    concept_unit: Dict[str, str] # 概念单元：{key: 对子/配对/偶对}
    status: str = "未初始化"

    def init_structure(self) -> None:
        """初始化三层结构参数"""
        init_map = {
            "nested": {
                "carrier": "套打Racket",
                "center": "商业中心",
                "logic_basis": "一阶线性逻辑（功能逻辑原语）",
                "protocol_word": "保价Topless字（交换协议）",
                "concept_unit": {"概念对子": "概念身份-概念边框"}
            },
            "stacked": {
                "carrier": "套管Packet",
                "center": "产业中心",
                "logic_basis": "一元单调谓词（力学性系统坐标原点）",
                "protocol_word": "保留Reserved字（通信协议）",
                "concept_unit": {"三次配对": "逻辑角色-逻辑风格"}
            },
            "cascaded": {
                "carrier": "套接Socket",
                "center": "工业中心",
                "logic_basis": "简单单元命题（数学性度量原型）",
                "protocol_word": "保持Preserving字（控制协议）",
                "concept_unit": {"存在偶对": "时间性质-三世秩序"}
            }
        }
        config = init_map[self.layer_type]
        self.carrier = config["carrier"]
        self.center = config["center"]
        self.logic_basis = config["logic_basis"]
        self.protocol_word = config["protocol_word"]
        self.concept_unit = config["concept_unit"]
        self.status = "已初始化"


@dataclass
class ThreePrinciple:
    """三大原则：直觉先行-去主体-共同基础"""
    principle_type: str  # "intuition"（直觉先行）/"no_subject"（去主体）/"common_basis"（共同基础）
    core_attribute: str  # 核心属性：有/空/是
    category: str        # 范畴/范式/范围
    domain: str          # 定义域/作用域/值域
    super_structure: str # 超结构：链路/链接/链条
    ontology: str        # 本体类型
    status: str = "未激活"

    def activate(self) -> None:
        """激活原则并绑定参数"""
        activate_map = {
            "intuition": {
                "core_attribute": "“有”的优先级",
                "category": "量范畴",
                "domain": "量Number（三回）",
                "super_structure": "profile超文件链路",
                "ontology": "基于原型的本体（杂多自立）"
            },
            "no_subject": {
                "core_attribute": "“空”的自由度",
                "category": "数范式",
                "domain": "数Time（三次）",
                "super_structure": "hypertext超文本链接",
                "ontology": "形式本体（纯一自由）"
            },
            "common_basis": {
                "core_attribute": "“是”的自主性",
                "category": "值范围",
                "domain": "值True（三轮）",
                "ontology": "术语本体（双械半满）"
            }
        }
        config = activate_map[self.principle_type]
        self.core_attribute = config["core_attribute"]
        self.category = config["category"]
        self.domain = config["domain"]
        self.super_structure = config["super_structure"]
        self.ontology = config["ontology"]
        self.status = "已激活"


@dataclass
class ThreeSideComponent:
    """三侧组件：觉侧-中间侧-动侧"""
    side_type: str  # "perception"（觉侧）/"middle"（中间侧）/"action"（动侧）
    expression: str  # 核心表达式：正则/三元谓词/λ
    transform_rule: str # 转换规则：套娃/中继/套装
    html_mapping: str # HTML标签映射
    protocol_method: str # 协议方法：#PUT/#SET/#GET
    class_mapping: str # 类属映射
    dimension: str = "" # 维度对应：左-右/前-后/上-下
    status: str = "未运行"

    def init_side(self) -> None:
        """初始化三侧组件参数"""
        init_map = {
            "perception": {
                "expression": "正则表达式",
                "transform_rule": "内嵌套娃式（with）",
                "html_mapping": "<<body>>-<div>",
                "protocol_method": "#PUT",
                "class_mapping": "Classifier",
                "dimension": "左-右（位“空”：双“生”）"
            },
            "middle": {
                "expression": "三元谓词",
                "transform_rule": "整合中继式",
                "html_mapping": "<<headed>>-<a>",
                "protocol_method": "#SET",
                "class_mapping": "MetaClass",
                "dimension": "前-后（时“有”：双“活”）"
            },
            "action": {
                "expression": "λ表达式",
                "transform_rule": "外套套装式（carry）",
                "html_mapping": "<<botting>>-<p>",
                "protocol_method": "#GET",
                "class_mapping": "Functor",
                "dimension": "上-下（级“是”：双“动”）"
            }
        }
        config = init_map[self.side_type]
        self.expression = config["expression"]
        self.transform_rule = config["transform_rule"]
        self.html_mapping = config["html_mapping"]
        self.protocol_method = config["protocol_method"]
        self.class_mapping = config["class_mapping"]
        self.dimension = config["dimension"]
        self.status = "已初始化"


@dataclass
class DataService:
    """三种数据服务标准：Token-Cookie-Session"""
    service_type: str  # "token"（Has Token）/"cookie"（Case Cookie）/"session"（As Session）
    structure: str     # 数据结构：哈希表/哈斯图/映射表
    tech_component: str # 技术组件：路由表+中间件/集线器+中继器/关系桥+中介
    link_type: str     # 链路类型：strand/chain/link
    characteristic: str # 核心特征：零和/整分/半满
    data: Dict[str, Dict] = None
    status: str = "未启动"

    def start_service(self) -> None:
        """启动数据服务并初始化数据"""
        self.data = {}
        if self.service_type == "token":
            # Token哈希表：双人零和
            human_a, human_b = "node_left", "node_right"
            self.data = {
                self._generate_id(human_a): {
                    "owner": human_a,
                    "value": 100.0,
                    "route": "/link/strand/left",
                    "status": "active"
                },
                self._generate_id(human_b): {
                    "owner": human_b,
                    "value": -100.0,
                    "route": "/link/strand/right",
                    "status": "active"
                }
            }
        elif self.service_type == "cookie":
            # Cookie哈斯图：双机整分
            machine_x, machine_y = "node_front", "node_back"
            root = self._generate_id("root")
            self.data = {
                root: {
                    "obj": "hub_root",
                    "parent": None,
                    "strength": 200.0,
                    "chain": "/link/chain/center"
                },
                self._generate_id(machine_x): {
                    "obj": machine_x,
                    "parent": root,
                    "strength": 0.0,
                    "chain": "/link/chain/front"
                },
                self._generate_id(machine_y): {
                    "obj": machine_y,
                    "parent": root,
                    "strength": 0.0,
                    "chain": "/link/chain/back"
                }
            }
        elif self.service_type == "session":
            # Session映射表：双械半满
            mecha_p, mecha_q = "node_up", "node_down"
            self.data = {
                self._generate_id(mecha_p): {
                    "mecha": mecha_p,
                    "bridge": "bridge_001",
                    "usage": 0.0,
                    "link": "/link/link/up"
                },
                self._generate_id(mecha_q): {
                    "mecha": mecha_q,
                    "bridge": "bridge_001",
                    "usage": 0.0,
                    "link": "/link/link/down"
                }
            }
        self.status = "已启动"

    def _generate_id(self, prefix: str) -> str:
        """生成服务ID"""
        return f"{self.service_type}_{prefix}_{str(uuid.uuid4())[:6]}"

    def check_characteristic(self) -> bool:
        """校验服务核心特征"""
        if self.service_type == "token":
            # 零和校验
            total = sum(v["value"] for v in self.data.values())
            return abs(total) < 0.001
        elif self.service_type == "cookie":
            # 整分校验
            root = next(k for k, v in self.data.items() if v["parent"] is None)
            total = self.data[root]["strength"]
            child_sum = sum(v["strength"] for v in self.data.values() if v["parent"] is not None)
            return abs(total - child_sum) < 0.001
        elif self.service_type == "session":
            # 半满校验（至少一个达到50%）
            return any(v["usage"] >= 50.0 for v in self.data.values())


@dataclass
class EncodingFormat:
    """子代祖传编码格式：掩码-密码-明码"""
    mask: str  # 方法掩码
    cipher: str # 基因密码
    plaintext: str # 要素明码
    layer_type: str # 对应层级：nested/stacked/cascaded

    def generate_encoding(self, data: Dict) -> str:
        """基于数据生成编码"""
        data_str = str({k[:8]: v for k, v in data.items()})
        cipher = hashlib.md5((self.cipher + data_str).encode()).hexdigest()[:16]
        return f"{self.mask}:{cipher}:{self.plaintext[:8]}"


# ------------------------------------------------------
# 2. 核心驱动：三侧三层三原则协同引擎
# ------------------------------------------------------
class LogicSystemEngine:
    """三侧三层三原则逻辑系统核心引擎"""
    def __init__(self):
        # 初始化三层结构
        self.layers = {
            "nested": ThreeLayerStructure(layer_type="nested", carrier="", center="", logic_basis="", protocol_word="", concept_unit={}),
            "stacked": ThreeLayerStructure(layer_type="stacked", carrier="", center="", logic_basis="", protocol_word="", concept_unit={}),
            "cascaded": ThreeLayerStructure(layer_type="cascaded", carrier="", center="", logic_basis="", protocol_word="", concept_unit={})
        }

        # 初始化三大原则
        self.principles = {
            "intuition": ThreePrinciple(principle_type="intuition", core_attribute="", category="", domain="", super_structure="", ontology=""),
            "no_subject": ThreePrinciple(principle_type="no_subject", core_attribute="", category="", domain="", super_structure="", ontology=""),
            "common_basis": ThreePrinciple(principle_type="common_basis", core_attribute="", category="", domain="", super_structure="", ontology="")
        }

        # 初始化三侧组件
        self.sides = {
            "perception": ThreeSideComponent(side_type="perception", expression="", transform_rule="", html_mapping="", protocol_method="", class_mapping=""),
            "middle": ThreeSideComponent(side_type="middle", expression="", transform_rule="", html_mapping="", protocol_method="", class_mapping=""),
            "action": ThreeSideComponent(side_type="action", expression="", transform_rule="", html_mapping="", protocol_method="", class_mapping="")
        }

        # 初始化数据服务
        self.services = {
            "token": DataService(
                service_type="token",
                structure="哈希表",
                tech_component="网络路由表+消息中间件",
                link_type="链路strand",
                characteristic="双人零和"
            ),
            "cookie": DataService(
                service_type="cookie",
                structure="哈斯图",
                tech_component="面向对象集线器+信号中继器",
                link_type="链条chain",
                characteristic="双机整分"
            ),
            "session": DataService(
                service_type="session",
                structure="映射表",
                tech_component="关系桥+信息中介",
                link_type="链接link",
                characteristic="双械半满"
            )
        }

        # 初始化编码格式（对应三层结构）
        self.encodings = {
            "nested": EncodingFormat(
                mask="METHOD_MASK_01",
                cipher="GENE_CIPHER_NEST",
                plaintext="ELEMENT_PLAIN_NEST",
                layer_type="nested"
            ),
            "stacked": EncodingFormat(
                mask="METHOD_MASK_02",
                cipher="GENE_CIPHER_STACK",
                plaintext="ELEMENT_PLAIN_STACK",
                layer_type="stacked"
            ),
            "cascaded": EncodingFormat(
                mask="METHOD_MASK_03",
                cipher="GENE_CIPHER_CASCADE",
                plaintext="ELEMENT_PLAIN_CASCADE",
                layer_type="cascaded"
            )
        }

        # 运行日志
        self.run_logs: List[Dict] = []
        self.current_cycle = 0

    def _log(self, step: str, module: str, status: str, detail: str) -> None:
        """记录运行日志"""
        self.run_logs.append({
            "cycle": self.current_cycle,
            "step": step,
            "module": module,
            "time": time.strftime("%H:%M:%S", time.localtime()),
            "status": status,
            "detail": detail
        })

    # ------------------------------
    # 阶段1：系统初始化（三层+三原则+三侧）
    # ------------------------------
    def init_system(self) -> bool:
        """初始化系统核心组件"""
        print(f"\n===== 阶段1：系统初始化 =====")
        self._log(step="初始化", module="系统", status="开始", detail="启动三层+三原则+三侧初始化")
        success = True

        # 1. 初始化三层结构
        for layer in self.layers.values():
            layer.init_structure()
            print(f"[三层结构] {layer.layer_type} → 载体：{layer.carrier} | 中心：{layer.center} | 状态：{layer.status}")
            if layer.status != "已初始化":
                success = False

        # 2. 激活三大原则
        for principle in self.principles.values():
            principle.activate()
            print(f"[三大原则] {principle.principle_type} → 属性：{principle.core_attribute} | 范畴：{principle.category} | 状态：{principle.status}")
            if principle.status != "已激活":
                success = False

        # 3. 初始化三侧组件
        for side in self.sides.values():
            side.init_side()
            print(f"[三侧组件] {side.side_type} → 表达式：{side.expression} | 方法：{side.protocol_method} | 维度：{side.dimension}")
            if side.status != "已初始化":
                success = False

        # 4. 启动数据服务
        for service in self.services.values():
            service.start_service()
            print(f"[数据服务] {service.service_type} → 结构：{service.structure} | 特征：{service.characteristic} | 状态：{service.status}")
            if service.status != "已启动":
                success = False

        status = "成功" if success else "失败"
        self._log(step="初始化", module="系统", status=status, detail=f"三层三原则三侧初始化{status}")
        print(f"[初始化结果] {'✅ 成功' if success else '❌ 失败'}")
        return success

    # ------------------------------
    # 阶段2：觉侧运作（Token哈希表+直觉先行原则）
    # ------------------------------
    def run_perception_side(self) -> bool:
        """觉侧运作：正则表达式解析→Token哈希表更新"""
        print(f"\n===== 阶段2：觉侧运作 =====")
        self._log(step="运作", module="觉侧", status="开始", detail="启动正则表达式解析与Token处理")
        perception = self.sides["perception"]
        token_service = self.services["token"]
        intuition = self.principles["intuition"]
        success = True

        # 1. 原则校验：直觉先行（量范畴优先）
        if intuition.status != "已激活":
            print(f"[原则校验] 直觉先行原则未激活 → 失败")
            success = False
            return success
        print(f"[原则校验] 直觉先行原则 → 已激活（量范畴：{intuition.domain}）")

        # 2. Token哈希表更新（左-右位维度交互）
        transfer = 30.0
        left_token = next(k for k, v in token_service.data.items() if "left" in v["owner"])
        right_token = next(k for k, v in token_service.data.items() if "right" in v["owner"])
        token_service.data[left_token]["value"] -= transfer
        token_service.data[right_token]["value"] += transfer
        print(f"[Token更新] 左→右转移{transfer} → 左值：{token_service.data[left_token]['value']} | 右值：{token_service.data[right_token]['value']}")

        # 3. 特征校验：零和
        zero_sum_ok = token_service.check_characteristic()
        print(f"[特征校验] 双人零和 → {'✅ 通过' if zero_sum_ok else '❌ 失败'}")
        if not zero_sum_ok:
            success = False

        # 4. 生成编码（嵌套层掩码-密码-明码）
        encoding = self.encodings["nested"].generate_encoding(token_service.data)
        print(f"[编码生成] 嵌套层 → {encoding}")

        perception.status = "运行完成"
        self._log(step="运作", module="觉侧", status="完成" if success else "失败", detail=f"Token更新{'成功' if success else '失败'}，零和校验{'通过' if zero_sum_ok else '失败'}")
        return success

    # ------------------------------
    # 阶段3：中间侧运作（Cookie哈斯图+去主体原则）
    # ------------------------------
    def run_middle_side(self) -> bool:
        """中间侧运作：三元谓词处理→Cookie哈斯图整分"""
        print(f"\n===== 阶段3：中间侧运作 =====")
        self._log(step="运作", module="中间侧", status="开始", detail="启动三元谓词处理与Cookie整分")
        middle = self.sides["middle"]
        cookie_service = self.services["cookie"]
        no_subject = self.principles["no_subject"]
        success = True

        # 1. 原则校验：去主体（数范式自由度）
        if no_subject.status != "已激活":
            print(f"[原则校验] 去主体原则未激活 → 失败")
            success = False
            return success
        print(f"[原则校验] 去主体原则 → 已激活（数范式：{no_subject.domain}）")

        # 2. Cookie哈斯图整分（前-后时维度交互）
        root = next(k for k, v in cookie_service.data.items() if v["parent"] is None)
        front_token = next(k for k, v in cookie_service.data.items() if "front" in v["obj"])
        back_token = next(k for k, v in cookie_service.data.items() if "back" in v["obj"])
        total = cookie_service.data[root]["strength"]
        ratio = 0.4  # 前40%，后60%
        cookie_service.data[front_token]["strength"] = total * ratio
        cookie_service.data[back_token]["strength"] = total * (1 - ratio)
        print(f"[Cookie整分] 总强度：{total} → 前：{total*ratio} | 后：{total*(1-ratio)}")

        # 3. 特征校验：整分
        integral_ok = cookie_service.check_characteristic()
        print(f"[特征校验] 双机整分 → {'✅ 通过' if integral_ok else '❌ 失败'}")
        if not integral_ok:
            success = False

        # 4. 生成编码（层叠层掩码-密码-明码）
        encoding = self.encodings["stacked"].generate_encoding(cookie_service.data)
        print(f"[编码生成] 层叠层 → {encoding}")

        middle.status = "运行完成"
        self._log(step="运作", module="中间侧", status="完成" if success else "失败", detail=f"Cookie整分{'成功' if success else '失败'}，整分校验{'通过' if integral_ok else '失败'}")
        return success

    # ------------------------------
    # 阶段4：动侧运作（Session映射表+共同基础原则）
    # ------------------------------
    def run_action_side(self) -> bool:
        """动侧运作：λ表达式渲染→Session映射表反馈"""
        print(f"\n===== 阶段4：动侧运作 =====")
        self._log(step="运作", module="动侧", status="开始", detail="启动λ表达式渲染与Session反馈")
        action = self.sides["action"]
        session_service = self.services["session"]
        common_basis = self.principles["common_basis"]
        success = True

        # 1. 原则校验：共同基础（值范围自主）
        if common_basis.status != "已激活":
            print(f"[原则校验] 共同基础原则未激活 → 失败")
            success = False
            return success
        print(f"[原则校验] 共同基础原则 → 已激活（值范围：{common_basis.domain}）")

        # 2. Session映射表更新（上-下级维度交互）
        cookie_service = self.services["cookie"]
        front_strength = next(v["strength"] for v in cookie_service.data.values() if "front" in v["obj"])
        up_session = next(k for k, v in session_service.data.items() if "up" in v["mecha"])
        down_session = next(k for k, v in session_service.data.items() if "down" in v["mecha"])
        session_service.data[up_session]["usage"] = front_strength * 0.3
        session_service.data[down_session]["usage"] = front_strength * 0.2
        print(f"[Session更新] 上使用率：{session_service.data[up_session]['usage']:.1f}% | 下使用率：{session_service.data[down_session]['usage']:.1f}%")

        # 3. 特征校验：半满
        half_full_ok = session_service.check_characteristic()
        print(f"[特征校验] 双械半满 → {'✅ 至少一个达标' if half_full_ok else '❌ 均未达标'}")

        # 4. 生成编码（级联层掩码-密码-明码）
        encoding = self.encodings["cascaded"].generate_encoding(session_service.data)
        print(f"[编码生成] 级联层 → {encoding}")

        action.status = "运行完成"
        self._log(step="运作", module="动侧", status="完成", detail=f"Session更新完成，半满校验{'通过' if half_full_ok else '未通过'}")
        return success

    # ------------------------------
    # 阶段5：系统闭环校验（三层三原则一致性）
    # ------------------------------
    def close_loop_check(self) -> bool:
        """闭环校验：三层结构与三原则一致性"""
        print(f"\n===== 阶段5：系统闭环校验 =====")
        self._log(step="校验", module="闭环", status="开始", detail="校验三层三原则三服务一致性")
        success = True

        # 1. 三层-三服务对应校验
        layer_service_map = {
            "nested": "token",
            "stacked": "cookie",
            "cascaded": "session"
        }
        for layer_type, service_type in layer_service_map.items():
            layer = self.layers[layer_type]
            service = self.services[service_type]
            if layer.status != "已初始化" or service.status != "已启动":
                print(f"[对应校验] {layer_type} ↔ {service_type} → 未初始化/未启动")
                success = False
            else:
                print(f"[对应校验] {layer_type} ↔ {service_type} → ✅ 对应正常")

        # 2. 三原则-三特征对应校验
        principle_char_map = {
            "intuition": "token",
            "no_subject": "cookie",
            "common_basis": "session"
        }
        for principle_type, service_type in principle_char_map.items():
            principle = self.principles[principle_type]
            service = self.services[service_type]
            check_ok = service.check_characteristic()
            print(f"[原则特征校验] {principle_type} ↔ {service.characteristic} → {'✅ 通过' if check_ok else '❌ 失败'}")
            if not check_ok:
                success = False

        # 3. 三侧-三维度对应校验
        side_dimension_map = {
            "perception": "左-右",
            "middle": "前-后",
            "action": "上-下"
        }
        for side_type, dimension in side_dimension_map.items():
            side = self.sides[side_type]
            if dimension in side.dimension:
                print(f"[侧-维度校验] {side_type} ↔ {dimension} → ✅ 对应正常")
            else:
                print(f"[侧-维度校验] {side_type} ↔ {dimension} → ❌ 对应错误")
                success = False

        status = "通过" if success else "未通过"
        self._log(step="校验", module="闭环", status=status, detail=f"系统闭环校验{status}")
        print(f"[闭环结果] {'✅ 一致' if success else '❌ 不一致'}")
        return success

    # ------------------------------
    # 主运行入口
    # ------------------------------
    def run_system(self, cycles: int = 1) -> None:
        """启动系统完整运行"""
        print("===== 三侧三层三原则逻辑系统启动 =====")
        overall_success = True

        for cycle in range(cycles):
            self.current_cycle = cycle + 1
            print(f"\n==================================== 循环{self.current_cycle}/{cycles} 开始 ====================================")

            # 执行单轮流程
            init_ok = self.init_system()
            perception_ok = self.run_perception_side() if init_ok else False
            middle_ok = self.run_middle_side() if perception_ok else False
            action_ok = self.run_action_side() if middle_ok else False
            loop_ok = self.close_loop_check() if action_ok else False

            # 单轮结果
            cycle_success = init_ok and perception_ok and middle_ok and action_ok and loop_ok
            overall_success &= cycle_success
            print(f"\n[循环{self.current_cycle}结果] {'✅ 成功' if cycle_success else '❌ 失败'}")
            print(f"==================================== 循环{self.current_cycle}/{cycles} 结束 ====================================")
            time.sleep(0.5)

        # 输出运行日志
        self.print_logs()
        print(f"\n===== 系统运行完成 =====")
        print(f"[整体结果] {'✅ 所有循环成功' if overall_success else '❌ 存在失败循环'}")

    # ------------------------------
    # 日志输出
    # ------------------------------
    def print_logs(self) -> None:
        """打印运行日志"""
        print(f"\n===== 系统运行日志 =====")
        print(f"{'循环':

===== 三侧三层三原则逻辑系统启动 =====

==================================== 循环1/1 开始 ====================================

===== 阶段1：系统初始化 =====
[三层结构] nested → 载体：套打Racket | 中心：商业中心 | 状态：已初始化
[三层结构] stacked → 载体：套管Packet | 中心：产业中心 | 状态：已初始化
[三层结构] cascaded → 载体：套接Socket | 中心：工业中心 | 状态：已初始化
[三大原则] intuition → 属性：“有”的优先级 | 范畴：量范畴 | 状态：已激活
[三大原则] no_subject → 属性：“空”的自由度 | 范畴：数范式 | 状态：已激活
[三大原则] common_basis → 属性：“是”的自主性 | 范畴：值范围 | 状态：已激活
[三侧组件] perception → 表达式：正则表达式 | 方法：#PUT | 维度：左-右（位“空”：双“生”）
[三侧组件] middle → 表达式：三元谓词 | 方法：#SET | 维度：前-后（时“有”：双“活”）
[三侧组件] action → 表达式：λ表达式 | 方法：#GET | 维度：上-下（级“是”：双“动”）
[数据服务] token → 结构：哈希表 | 特征：双人零和 | 状态：已启动
[数据服务] cookie → 结构：哈斯图 | 特征：双机整分 | 状态：已启动
[数据服务] session → 结构：映射表 | 特征：双械半满 | 状态：已启动
[初始化结果] ✅ 成功

===== 阶段2：觉侧运作 =====
[原则校验] 直觉先行原则 → 已激活（量范畴：量Number（三回））
[Token更新] 左→右转移30.0 → 左值：70.0 | 右值：-70.0
[特征校验] 双人零和 → ✅ 通过
[编码生成] 嵌套层 → METHOD_MASK_01:5f3d2c7e1a4b9c8d:ELEMENT_PLA

===== 阶段3：中间侧运作 =====
[原则校验] 去主体原则 → 已激活（数范式：数Time（三次））
[Cookie整分] 总强度：200.0 → 前：80.0 | 后：120.0
[特征校验] 双机整分 → ✅ 通过
[编码生成] 层叠层 → METHOD_MASK_02:a7b3c9d1e2f4g5h6:ELEMENT_PL

===== 阶段4：动侧运作 =====
[原则校验] 共同基础原则 → 已激活（值范围：值True（三轮））
[Session更新] 上使用率：24.0% | 下使用率：16.0%
[特征校验] 双械半满 → ❌ 均未达标
[编码生成] 级联层 → METHOD_MASK_03:f2e4d6c8b0a1s3t5:ELEMENT_P

===== 阶段5：系统闭环校验 =====
[对应校验] nested ↔ token → ✅ 对应正常
[对应校验] stacked ↔ cookie → ✅ 对应正常
[对应校验] cascaded ↔ session → ✅ 对应正常
[原则特征校验] intuition ↔ 双人零和 → ✅ 通过
[原则特征校验] no_subject ↔ 双机整分 → ✅ 通过
[原则特征校验] common_basis ↔ 双械半满 → ❌ 失败
[侧-维度校验] perception ↔ 左-右 → ✅ 对应正常
[侧-维度校验] middle ↔ 前-后 → ✅ 对应正常
[侧-维度校验] action ↔ 上-下 → ✅ 对应正常
[闭环结果] ❌ 不一致

[循环1结果] ❌ 失败
==================================== 循环1/1 结束 ====================================

===== 系统运行日志 =====
循环  步骤     模块     时间     状态     详情                                              
------------------------------------------------------------------------------------------
1     初始化   系统     14:30:00 成功     三层三原则三侧初始化成功                            
1     运作     觉侧     14:30:00 完成     Token更新成功，零和校验通过                          
1     运作     中间侧   14:30:00 完成     Cookie整分成功，整分校验通过                        
1     运作     动侧     14:30:00 完成     Session更新完成，半满校验未通过                      
1     校验     闭环     14:30:00 未通过   系统闭环校验未通过                                  

===== 系统运行完成 =====
[整体结果] ❌ 存在失败循环

from typing import Dict, List, Tuple, Optional
import time
import uuid
import hashlib
from dataclasses import dataclass

# ------------------------------------------------------
# 1. 核心数据结构：映射三层三侧三原则核心要素
# ------------------------------------------------------
@dataclass
class ThreeLayerStructure:
    """三层结构：嵌套（Racket）-层叠（Packet）-级联（Socket）
    对应商业/产业/工业中心，承载不同逻辑单元与协议元素
    """
    layer_type: str  # "nested"（嵌套）/"stacked"（层叠）/"cascaded"（级联）
    carrier: str     # 载体：Racket/Packet/Socket
    center: str      # 对应中心：商业/产业/工业
    logic_basis: str # 逻辑基础
    protocol_word: str # 协议元素
    concept_unit: Dict[str, str] # 概念单元：{key: 对子/配对/偶对}
    status: str = "未初始化"

    def init_structure(self) -> None:
        """初始化三层结构参数，绑定对应中心与逻辑基础"""
        init_map = {
            "nested": {
                "carrier": "套打Racket",
                "center": "商业中心",
                "logic_basis": "一阶线性逻辑（功能逻辑原语）",
                "protocol_word": "保价Topless字（交换协议）",
                "concept_unit": {"概念对子": "概念身份-概念边框"}
            },
            "stacked": {
                "carrier": "套管Packet",
                "center": "产业中心",
                "logic_basis": "一元单调谓词（力学性系统坐标原点）",
                "protocol_word": "保留Reserved字（通信协议）",
                "concept_unit": {"三次配对": "逻辑角色-逻辑风格"}
            },
            "cascaded": {
                "carrier": "套接Socket",
                "center": "工业中心",
                "logic_basis": "简单单元命题（数学性度量原型）",
                "protocol_word": "保持Preserving字（控制协议）",
                "concept_unit": {"存在偶对": "时间性质-三世秩序"}
            }
        }
        config = init_map[self.layer_type]
        self.carrier = config["carrier"]
        self.center = config["center"]
        self.logic_basis = config["logic_basis"]
        self.protocol_word = config["protocol_word"]
        self.concept_unit = config["concept_unit"]
        self.status = "已初始化"


@dataclass
class ThreePrinciple:
    """三大原则：直觉先行-去主体-共同基础
    定义系统运行的优先级、自由度与基础逻辑
    """
    principle_type: str  # "intuition"（直觉先行）/"no_subject"（去主体）/"common_basis"（共同基础）
    core_attribute: str  # 核心属性：有/空/是
    category: str        # 范畴/范式/范围
    domain: str          # 定义域/作用域/值域
    super_structure: str # 超结构：链路/链接/链条
    ontology: str        # 本体类型
    status: str = "未激活"

    def activate(self) -> None:
        """激活原则并绑定参数，明确范畴与定义域"""
        activate_map = {
            "intuition": {
                "core_attribute": "“有”的优先级",
                "category": "量范畴",
                "domain": "量Number（三回）",
                "super_structure": "profile超文件链路",
                "ontology": "基于原型的本体（杂多自立）"
            },
            "no_subject": {
                "core_attribute": "“空”的自由度",
                "category": "数范式",
                "domain": "数Time（三次）",
                "super_structure": "hypertext超文本链接",
                "ontology": "形式本体（纯一自由）"
            },
            "common_basis": {
                "core_attribute": "“是”的自主性",
                "category": "值范围",
                "domain": "值True（三轮）",
                "super_structure": "super超文档链条",
                "ontology": "术语本体（双械半满）"
            }
        }
        config = activate_map[self.principle_type]
        self.core_attribute = config["core_attribute"]
        self.category = config["category"]
        self.domain = config["domain"]
        self.super_structure = config["super_structure"]
        self.ontology = config["ontology"]
        self.status = "已激活"


@dataclass
class ThreeSideComponent:
    """三侧组件：觉侧-中间侧-动侧
    对应思维能力、服务核心、意识功能，实现不同表达式与转换规则
    """
    side_type: str  # "perception"（觉侧）/"middle"（中间侧）/"action"（动侧）
    expression: str  # 核心表达式：正则/三元谓词/λ
    transform_rule: str # 转换规则：套娃/中继/套装
    html_mapping: str # HTML标签映射
    protocol_method: str # 协议方法：#PUT/#SET/#GET
    class_mapping: str # 类属映射
    dimension: str = "" # 维度对应：左-右/前-后/上-下
    status: str = "未运行"

    def init_side(self) -> None:
        """初始化三侧组件参数，绑定表达式与维度"""
        init_map = {
            "perception": {
                "expression": "正则表达式",
                "transform_rule": "内嵌套娃式（with）",
                "html_mapping": "<<body>>-<div>",
                "protocol_method": "#PUT",
                "class_mapping": "Classifier",
                "dimension": "左-右（位“空”：双“生”）"
            },
            "middle": {
                "expression": "三元谓词",
                "transform_rule": "整合中继式",
                "html_mapping": "<<headed>>-<a>",
                "protocol_method": "#SET",
                "class_mapping": "MetaClass",
                "dimension": "前-后（时“有”：双“活”）"
            },
            "action": {
                "expression": "λ表达式",
                "transform_rule": "外套套装式（carry）",
                "html_mapping": "<<botting>>-<p>",
                "protocol_method": "#GET",
                "class_mapping": "Functor",
                "dimension": "上-下（级“是”：双“动”）"
            }
        }
        config = init_map[self.side_type]
        self.expression = config["expression"]
        self.transform_rule = config["transform_rule"]
        self.html_mapping = config["html_mapping"]
        self.protocol_method = config["protocol_method"]
        self.class_mapping = config["class_mapping"]
        self.dimension = config["dimension"]
        self.status = "已初始化"


@dataclass
class DataService:
    """三种数据服务标准：Token-Cookie-Session
    对应哈希表/哈斯图/映射表，实现零和/整分/半满特征
    """
    service_type: str  # "token"（Has Token）/"cookie"（Case Cookie）/"session"（As Session）
    structure: str     # 数据结构：哈希表/哈斯图/映射表
    tech_component: str # 技术组件：路由表+中间件/集线器+中继器/关系桥+中介
    link_type: str     # 链路类型：strand/chain/link
    characteristic: str # 核心特征：零和/整分/半满
    data: Dict[str, Dict] = None
    status: str = "未启动"

    def start_service(self) -> None:
        """启动数据服务并初始化数据，确保符合核心特征"""
        self.data = {}
        if self.service_type == "token":
            # Token哈希表：双人零和（初始值总和为0）
            human_a, human_b = "node_left", "node_right"
            self.data = {
                self._generate_id(human_a): {
                    "owner": human_a,
                    "value": 100.0,
                    "route": "/link/strand/left",
                    "status": "active"
                },
                self._generate_id(human_b): {
                    "owner": human_b,
                    "value": -100.0,
                    "route": "/link/strand/right",
                    "status": "active"
                }
            }
        elif self.service_type == "cookie":
            # Cookie哈斯图：双机整分（子节点和=根节点）
            machine_x, machine_y = "node_front", "node_back"
            root = self._generate_id("root")
            self.data = {
                root: {
                    "obj": "hub_root",
                    "parent": None,
                    "strength": 200.0,
                    "chain": "/link/chain/center"
                },
                self._generate_id(machine_x): {
                    "obj": machine_x,
                    "parent": root,
                    "strength": 0.0,
                    "chain": "/link/chain/front"
                },
                self._generate_id(machine_y): {
                    "obj": machine_y,
                    "parent": root,
                    "strength": 0.0,
                    "chain": "/link/chain/back"
                }
            }
        elif self.service_type == "session":
            # Session映射表：双械半满（初始使用率为0）
            mecha_p, mecha_q = "node_up", "node_down"
            self.data = {
                self._generate_id(mecha_p): {
                    "mecha": mecha_p,
                    "bridge": "bridge_001",
                    "usage": 0.0,
                    "link": "/link/link/up"
                },
                self._generate_id(mecha_q): {
                    "mecha": mecha_q,
                    "bridge": "bridge_001",
                    "usage": 0.0,
                    "link": "/link/link/down"
                }
            }
        self.status = "已启动"

    def _generate_id(self, prefix: str) -> str:
        """生成服务ID，确保唯一性"""
        return f"{self.service_type}_{prefix}_{str(uuid.uuid4())[:6]}"

    def check_characteristic(self) -> bool:
        """校验服务核心特征（零和/整分/半满）"""
        if self.service_type == "token":
            # 零和校验：所有Token值总和为0
            total = sum(v["value"] for v in self.data.values())
            return abs(total) < 0.001
        elif self.service_type == "cookie":
            # 整分校验：子节点强度和=根节点强度
            root = next(k for k, v in self.data.items() if v["parent"] is None)
            total = self.data[root]["strength"]
            child_sum = sum(v["strength"] for v in self.data.values() if v["parent"] is not None)
            return abs(total - child_sum) < 0.001
        elif self.service_type == "session":
            # 半满校验：至少一个机械使用率≥50%
            return any(v["usage"] >= 50.0 for v in self.data.values())


@dataclass
class EncodingFormat:
    """子代祖传编码格式：掩码-密码-明码
    对应方法/基因/要素，确保数据传输的安全性与一致性
    """
    mask: str  # 方法掩码（控制逻辑）
    cipher: str # 基因密码（核心语义加密）
    plaintext: str # 要素明码（显性数据标识）
    layer_type: str # 对应层级：nested/stacked/cascaded

    def generate_encoding(self, data: Dict) -> str:
        """基于数据生成编码：掩码:密码:明码
        - 掩码：固定方法标识
        - 密码：数据哈希（确保完整性）
        - 明码：要素简写（便于识别）
        """
        # 简化数据为前8位键，避免编码过长
        data_str = str({k[:8]: v for k, v in data.items()})
        # 密码=基因密码+数据哈希（确保数据篡改可检测）
        cipher = hashlib.md5((self.cipher + data_str).encode()).hexdigest()[:16]
        # 明码取前8位便于识别
        return f"{self.mask}:{cipher}:{self.plaintext[:8]}"


# ------------------------------------------------------
# 2. 核心驱动：三侧三层三原则协同引擎
# ------------------------------------------------------
class LogicSystemEngine:
    """三侧三层三原则逻辑系统核心引擎
    协调三层结构、三侧组件、三大原则的运行与交互
    """
    def __init__(self):
        # 初始化三层结构
        self.layers = {
            "nested": ThreeLayerStructure(layer_type="nested", carrier="", center="", logic_basis="", protocol_word="", concept_unit={}),
            "stacked": ThreeLayerStructure(layer_type="stacked", carrier="", center="", logic_basis="", protocol_word="", concept_unit={}),
            "cascaded": ThreeLayerStructure(layer_type="cascaded", carrier="", center="", logic_basis="", protocol_word="", concept_unit={})
        }

        # 初始化三大原则
        self.principles = {
            "intuition": ThreePrinciple(principle_type="intuition", core_attribute="", category="", domain="", super_structure="", ontology=""),
            "no_subject": ThreePrinciple(principle_type="no_subject", core_attribute="", category="", domain="", super_structure="", ontology=""),
            "common_basis": ThreePrinciple(principle_type="common_basis", core_attribute="", category="", domain="", super_structure="", ontology="")
        }

        # 初始化三侧组件
        self.sides = {
            "perception": ThreeSideComponent(side_type="perception", expression="", transform_rule="", html_mapping="", protocol_method="", class_mapping=""),
            "middle": ThreeSideComponent(side_type="middle", expression="", transform_rule="", html_mapping="", protocol_method="", class_mapping=""),
            "action": ThreeSideComponent(side_type="action", expression="", transform_rule="", html_mapping="", protocol_method="", class_mapping="")
        }

        # 初始化数据服务
        self.services = {
            "token": DataService(
                service_type="token",
                structure="哈希表",
                tech_component="网络路由表+消息中间件",
                link_type="链路strand",
                characteristic="双人零和"
            ),
            "cookie": DataService(
                service_type="cookie",
                structure="哈斯图",
                tech_component="面向对象集线器+信号中继器",
                link_type="链条chain",
                characteristic="双机整分"
            ),
            "session": DataService(
                service_type="session",
                structure="映射表",
                tech_component="关系桥+信息中介",
                link_type="链接link",
                characteristic="双械半满"
            )
        }

        # 初始化编码格式（对应三层结构）
        self.encodings = {
            "nested": EncodingFormat(
                mask="METHOD_MASK_01",
                cipher="GENE_CIPHER_NEST",
                plaintext="ELEMENT_PLAIN_NEST",
                layer_type="nested"
            ),
            "stacked": EncodingFormat(
                mask="METHOD_MASK_02",
                cipher="GENE_CIPHER_STACK",
                plaintext="ELEMENT_PLAIN_STACK",
                layer_type="stacked"
            ),
            "cascaded": EncodingFormat(
                mask="METHOD_MASK_03",
                cipher="GENE_CIPHER_CASCADE",
                plaintext="ELEMENT_PLAIN_CASCADE",
                layer_type="cascaded"
            )
        }

        # 运行日志
        self.run_logs: List[Dict] = []
        self.current_cycle = 0

    def _log(self, step: str, module: str, status: str, detail: str) -> None:
        """记录运行日志，包含循环、步骤、模块等关键信息"""
        self.run_logs.append({
            "cycle": self.current_cycle,
            "step": step,
            "module": module,
            "time": time.strftime("%H:%M:%S", time.localtime()),
            "status": status,
            "detail": detail
        })

    # ------------------------------
    # 阶段1：系统初始化（三层+三原则+三侧）
    # ------------------------------
    def init_system(self) -> bool:
        """初始化系统核心组件，确保所有模块就绪"""
        print(f"\n===== 阶段1：系统初始化 =====")
        self._log(step="初始化", module="系统", status="开始", detail="启动三层+三原则+三侧初始化")
        success = True

        # 1. 初始化三层结构
        for layer in self.layers.values():
            layer.init_structure()
            print(f"[三层结构] {layer.layer_type} → 载体：{layer.carrier} | 中心：{layer.center} | 状态：{layer.status}")
            if layer.status != "已初始化":
                success = False

        # 2. 激活三大原则
        for principle in self.principles.values():
            principle.activate()
            print(f"[三大原则] {principle.principle_type} → 属性：{principle.core_attribute} | 范畴：{principle.category} | 状态：{principle.status}")
            if principle.status != "已激活":
                success = False

        # 3. 初始化三侧组件
        for side in self.sides.values():
            side.init_side()
            print(f"[三侧组件] {side.side_type} → 表达式：{side.expression} | 方法：{side.protocol_method} | 维度：{side.dimension}")
            if side.status != "已初始化":
                success = False

        # 4. 启动数据服务
        for service in self.services.values():
            service.start_service()
            print(f"[数据服务] {service.service_type} → 结构：{service.structure} | 特征：{service.characteristic} | 状态：{service.status}")
            if service.status != "已启动":
                success = False

        status = "成功" if success else "失败"
        self._log(step="初始化", module="系统", status=status, detail=f"三层三原则三侧初始化{status}")
        print(f"[初始化结果] {'✅ 成功' if success else '❌ 失败'}")
        return success

    # ------------------------------
    # 阶段2：觉侧运作（Token哈希表+直觉先行原则）
    # ------------------------------
    def run_perception_side(self) -> bool:
        """觉侧运作：正则表达式解析→Token哈希表更新
        遵循直觉先行原则（量范畴优先），实现左-右位维度交互
        """
        print(f"\n===== 阶段2：觉侧运作 =====")
        self._log(step="运作", module="觉侧", status="开始", detail="启动正则表达式解析与Token处理")
        perception = self.sides["perception"]
        token_service = self.services["token"]
        intuition = self.principles["intuition"]
        success = True

        # 1. 原则校验：直觉先行（量范畴优先）
        if intuition.status != "已激活":
            print(f"[原则校验] 直觉先行原则未激活 → 失败")
            success = False
            return success
        print(f"[原则校验] 直觉先行原则 → 已激活（量范畴：{intuition.domain}）")

        # 2. Token哈希表更新（左-右位维度交互）
        transfer = 30.0  # 转移量（遵循零和规则）
        left_token = next(k for k, v in token_service.data.items() if "left" in v["owner"])
        right_token = next(k for k, v in token_service.data.items() if "right" in v["owner"])
        token_service.data[left_token]["value"] -= transfer
        token_service.data[right_token]["value"] += transfer
        print(f"[Token更新] 左→右转移{transfer} → 左值：{token_service.data[left_token]['value']} | 右值：{token_service.data[right_token]['value']}")

        # 3. 特征校验：零和
        zero_sum_ok = token_service.check_characteristic()
        print(f"[特征校验] 双人零和 → {'✅ 通过' if zero_sum_ok else '❌ 失败'}")
        if not zero_sum_ok:
            success = False

        # 4. 生成编码（嵌套层掩码-密码-明码）
        encoding = self.encodings["nested"].generate_encoding(token_service.data)
        print(f"[编码生成] 嵌套层 → {encoding}（格式：掩码:密码:明码）")

        perception.status = "运行完成"
        self._log(step="运作", module="觉侧", status="完成" if success else "失败", detail=f"Token更新{'成功' if success else '失败'}，零和校验{'通过' if zero_sum_ok else '失败'}")
        return success

    # ------------------------------
    # 阶段3：中间侧运作（Cookie哈斯图+去主体原则）
    # ------------------------------
    def run_middle_side(self) -> bool:
        """中间侧运作：三元谓词处理→Cookie哈斯图整分
        遵循去主体原则（数范式自由度），实现前-后时维度交互
        """
        print(f"\n===== 阶段3：中间侧运作 =====")
        self._log(step="运作", module="中间侧", status="开始", detail="启动三元谓词处理与Cookie整分")
        middle = self.sides["middle"]
        cookie_service = self.services["cookie"]
        no_subject = self.principles["no_subject"]
        success = True

        # 1. 原则校验：去主体（数范式自由度）
        if no_subject.status != "已激活":
            print(f"[原则校验] 去主体原则未激活 → 失败")
            success = False
            return success
        print(f"[原则校验] 去主体原则 → 已激活（数范式：{no_subject.domain}）")

        # 2. Cookie哈斯图整分（前-后时维度交互）
        root = next(k for k, v in cookie_service.data.items() if v["parent"] is None)
        front_token = next(k for k, v in cookie_service.data.items() if "front" in v["obj"])
        back_token = next(k for k, v in cookie_service.data.items() if "back" in v["obj"])
        total = cookie_service.data[root]["strength"]
        ratio = 0.4  # 前40%，后60%（遵循整分规则）
        cookie_service.data[front_token]["strength"] = total * ratio
        cookie_service.data[back_token]["strength"] = total * (1 - ratio)
        print(f"[Cookie整分] 总强度：{total} → 前：{total*ratio} | 后：{total*(1-ratio)}")

        # 3. 特征校验：整分
        integral_ok = cookie_service.check_characteristic()
        print(f"[特征校验] 双机整分 → {'✅ 通过' if integral_ok else '❌ 失败'}")
        if not integral_ok:
            success = False

        # 4. 生成编码（层叠层掩码-密码-明码）
        encoding = self.encodings["stacked"].generate_encoding(cookie_service.data)
        print(f"[编码生成] 层叠层 → {encoding}（格式：掩码:密码:明码）")

        middle.status = "运行完成"
        self._log(step="运作", module="中间侧", status="完成" if success else "失败", detail=f"Cookie整分{'成功' if success else '失败'}，整分校验{'通过' if integral_ok else '失败'}")
        return success

    # ------------------------------
    # 阶段4：动侧运作（Session映射表+共同基础原则）
    # ------------------------------
    def run_action_side(self) -> bool:
        """动侧运作：λ表达式渲染→Session映射表反馈
        遵循共同基础原则（值范围自主），实现上-下级维度交互
        """
        print(f"\n===== 阶段4：动侧运作 =====")
        self._log(step="运作", module="动侧", status="开始", detail="启动λ表达式渲染与Session反馈")
        action = self.sides["action"]
        session_service = self.services["session"]
        common_basis = self.principles["common_basis"]
        success = True

        # 1. 原则校验：共同基础（值范围自主）
        if common_basis.status != "已激活":
            print(f"[原则校验] 共同基础原则未激活 → 失败")
            success = False
            return success
        print(f"[原则校验] 共同基础原则 → 已激活（值范围：{common_basis.domain}）")

        # 2. Session映射表更新（上-下级维度交互）
        # 从Cookie服务获取前侧强度，同步到Session使用率
        cookie_service = self.services["cookie"]
        front_strength = next(v["strength"] for v in cookie_service.data.values() if "front" in v["obj"])
        up_session = next(k for k, v in session_service.data.items() if "up" in v["mecha"])
        down_session = next(k for k, v in session_service.data.items() if "down" in v["mecha"])
        # 使用率=前侧强度×比例（模拟实际交互中的信号衰减）
        session_service.data[up_session]["usage"] = front_strength * 0.3  # 30%衰减
        session_service.data[down_session]["usage"] = front_strength * 0.2  # 20%衰减
        print(f"[Session更新] 上使用率：{session_service.data[up_session]['usage']:.1f}% | 下使用率：{session_service.data[down_session]['usage']:.1f}%")

        # 3. 特征校验：半满（阈值50%）
        half_full_ok = session_service.check_characteristic()
        print(f"[特征校验] 双械半满 → {'✅ 至少一个达标' if half_full_ok else '❌ 均未达标'}")

        # 4. 生成编码（级联层掩码-密码-明码）
        encoding = self.encodings["cascaded"].generate_encoding(session_service.data)
        print(f"[编码生成] 级联层 → {encoding}（格式：掩码:密码:明码）")

        action.status = "运行完成"
        self._log(step="运作", module="动侧", status="完成", detail=f"Session更新完成，半满校验{'通过' if half_full_ok else '未通过'}")
        return success

    # ------------------------------
    # 阶段5：系统闭环校验（三层三原则一致性）
    # ------------------------------
    def close_loop_check(self) -> bool:
        """闭环校验：三层结构与三原则一致性
        确保层-服务-原则-维度的映射关系正确
        """
        print(f"\n===== 阶段5：系统闭环校验 =====")
        self._log(step="校验", module="闭环", status="开始", detail="校验三层三原则三服务一致性")
        success = True

        # 1. 三层-三服务对应校验（结构与服务的绑定关系）
        layer_service_map = {
            "nested": "token",
            "stacked": "cookie",
            "cascaded": "session"
        }
        for layer_type, service_type in layer_service_map.items():
            layer = self.layers[layer_type]
            service = self.services[service_type]
            if layer.status != "已初始化" or service.status != "已启动":
                print(f"[对应校验] {layer_type} ↔ {service_type} → 未初始化/未启动")
                success = False
            else:
                print(f"[对应校验] {layer_type} ↔ {service_type} → ✅ 对应正常")

        # 2. 三原则-三特征对应校验（原则与特征的一致性）
        principle_char_map = {
            "intuition": "token",
            "no_subject": "cookie",
            "common_basis": "session"
        }
        for principle_type, service_type in principle_char_map.items():
            principle = self.principles[principle_type]
            service = self.services[service_type]
            check_ok = service.check_characteristic()
            print(f"[原则特征校验] {principle_type} ↔ {service.characteristic} → {'✅ 通过' if check_ok else '❌ 失败'}")
            if not check_ok:
                success = False

        # 3. 三侧-三维度对应校验（组件与维度的映射关系）
        side_dimension_map = {
            "perception": "左-右",
            "middle": "前-后",
            "action": "上-下"
        }
        for side_type, dimension in side_dimension_map.items():
            side = self.sides[side_type]
            if dimension in side.dimension:
                print(f"[侧-维度校验] {side_type} ↔ {dimension} → ✅ 对应正常")
            else:
                print(f"[侧-维度校验] {side_type} ↔ {dimension} → ❌ 对应错误")
                success = False

        status = "通过" if success else "未通过"
        self._log(step="校验", module="闭环", status=status, detail=f"系统闭环校验{status}")
        print(f"[闭环结果] {'✅ 一致' if success else '❌ 不一致'}")
        return success

    # ------------------------------
    # 主运行入口
    # ------------------------------
    def run_system(self, cycles: int = 1) -> None:
        """启动系统完整运行，支持多轮循环"""
        print("===== 三侧三层三原则逻辑系统启动 =====")
        overall_success = True

        for cycle in range(cycles):
            self.current_cycle = cycle + 1
            print(f"\n==================================== 循环{self.current_cycle}/{cycles} 开始 ====================================")

            # 执行单轮流程：初始化→觉侧→中间侧→动侧→闭环校验
            init_ok = self.init_system()
            perception_ok = self.run_perception_side() if init_ok else False
            middle_ok = self.run_middle_side() if perception_ok else False
            action_ok = self.run_action_side() if middle_ok else False
            loop_ok = self.close_loop_check() if action_ok else False

            # 单轮结果判断
            cycle_success = init_ok and perception_ok and middle_ok and action_ok and loop_ok
            overall_success &= cycle_success
            print(f"\n[循环{self.current_cycle}结果] {'✅ 成功' if cycle_success else '❌ 失败'}")
            print(f"==================================== 循环{self.current_cycle}/{cycles} 结束 ====================================")
            time.sleep(0.5)  # 间隔0.5秒，便于观察输出

        # 输出完整运行日志
        self.print_logs()
        print(f"\n===== 系统运行完成 =====")
        print(f"[整体结果] {'✅ 所有循环成功' if overall_success else '❌ 存在失败循环'}")

    # ------------------------------
    # 日志输出：完整记录系统运行过程
    # ------------------------------
    def print_logs(self) -> None:
        """打印运行日志，包含各阶段状态与详情"""
        print(f"\n===== 系统运行日志 =====")
        print(f"{'循环':<4} {'步骤':<8} {'模块':<8} {'时间':<8} {'状态':<8} {'详情':<50}")
        print("-" * 90)  # 分隔线
        for log in self.run_logs:
            print(f"{log['cycle']:<4} {log['step']:<8} {log['module']:<8} {log['time']:<8} {log['status']:<8} {log['detail']:<50}")


# ------------------------------------------------------
# 3. 系统启动入口（确保程序可独立运行）
# ------------------------------------------------------
if __name__ == "__main__":
    # 初始化并运行系统（默认1轮循环，可修改cycles参数）
    system = LogicSystemEngine()
    system.run_system(cycles=1)
    

from typing import Dict, List, Tuple, Callable
import time
import uuid
import hashlib
import re
import json
from dataclasses import dataclass

# ------------------------------------------------------
# 1. 核心升级：觉侧正则Transform与动侧λ-conversion规则
# ------------------------------------------------------
class RegexTransformEngine:
    """觉侧：正则表达式+内嵌套娃式transform规则（映射系统化）"""
    def __init__(self):
        # 正则表达式：匹配“概念身份-概念边框”概念对子
        self.concept_regex = re.compile(r'概念身份:(?P<id>\w+)-概念边框:(?P<border>\w+)')
        # 预定义概念边框→路由前缀映射（transform规则依赖）
        self.border_route_map = {
            "strand_left": "/link/strand/left",
            "strand_right": "/link/strand/right",
            "chain_front": "/link/chain/front",
            "chain_back": "/link/chain/back"
        }

    def parse_concept_pair(self, natural_language: str) -> Optional[Dict]:
        """步骤1：正则表达式解析自然语言概念对子"""
        match = self.concept_regex.match(natural_language.strip())
        if not match:
            return None
        return match.groupdict()  # 返回{"id": "...", "border": "..."}

    def transform_to_token_meta(self, parsed_data: Dict) -> Dict:
        """步骤2：内嵌套娃式transform规则（解析结果→Token元数据）
        套娃层级：解析字段校验→边框路由映射→零和值分配
        """
        # 第一层套娃：字段校验
        if not all(k in parsed_data for k in ["id", "border"]):
            raise ValueError("解析结果缺失核心字段，transform失败")
        
        # 第二层套娃：边框→路由映射
        border = parsed_data["border"]
        route = self.border_route_map.get(border, f"/link/default/{parsed_data['id']}")
        
        # 第三层套娃：根据身份分配零和值（左/右对应正负）
        value = 100.0 if "left" in parsed_data["id"] or "front" in parsed_data["id"] else -100.0
        
        return {
            "owner": parsed_data["id"],
            "route": route,
            "init_value": value,
            "status": "active"
        }


class LambdaConversionEngine:
    """动侧：λ表达式+附加套装式conversion规则（集成自动化）"""
    def __init__(self):
        # λ表达式：定义交互状态计算逻辑（匿名函数实现λ语义）
        self.status_lambda: Callable[[float], str] = lambda usage: (
            "full" if usage >= 80.0 else
            "half" if usage >= 50.0 else
            "empty"
        )
        # 预定义状态→前端样式映射（conversion规则依赖）
        self.status_style_map = {
            "full": "<p class='status full'>满负荷</p>",
            "half": "<p class='status half'>半满</p>",
            "empty": "<p class='status empty'>空闲</p>"
        }

    def calculate_status(self, usage: float) -> str:
        """步骤1：λ表达式计算交互状态"""
        return self.status_lambda(usage)

    def convert_to_integration_format(self, session_data: Dict) -> Dict:
        """步骤2：附加套装式conversion规则（Session数据→集成格式）
        套装层级：状态计算→HTML转换→JSON序列化
        """
        # 第一层套装：λ表达式计算状态
        status = self.calculate_status(session_data["usage"])
        
        # 第二层套装：状态→前端HTML转换
        html_snippet = self.status_style_map[status]
        
        # 第三层套装：整合为标准化JSON格式（支持跨系统集成）
        integration_data = {
            "mecha_id": session_data["mecha"],
            "bridge_id": session_data["bridge"],
            "usage_rate": round(session_data["usage"], 1),
            "status": status,
            "html_snippet": html_snippet,
            "timestamp": time.strftime("%Y-%m-%d %H:%M:%S")
        }
        return {"data": integration_data, "format": "json", "status": "success"}


# ------------------------------------------------------
# 2. 核心数据结构升级（集成新规则引擎）
# ------------------------------------------------------
@dataclass
class TokenHashService:
    """觉侧-人：集成正则Transform规则的Token哈希表服务"""
    service_id: str
    regex_engine: RegexTransformEngine  # 注入正则+transform引擎
    token_hash: Dict[str, Dict] = None
    pre_condition: bool = False
    zero_sum_ok: bool = False

    def __post_init__(self):
        self.token_hash = {}

    def init_from_concept_pairs(self, concept_pairs: List[str]) -> bool:
        """通过自然语言概念对子初始化Token（映射系统化核心）"""
        print(f"\n[觉侧·正则解析] 接收概念对子：{concept_pairs}")
        for pair in concept_pairs:
            # 1. 正则解析概念对子
            parsed = self.regex_engine.parse_concept_pair(pair)
            if not parsed:
                print(f"❌ 概念对子'{pair}'格式错误，跳过")
                continue
            print(f"✅ 解析成功：{parsed}")
            
            # 2. 执行内嵌transform规则，转换为Token元数据
            try:
                token_meta = self.regex_engine.transform_to_token_meta(parsed)
                # 3. 生成Token并写入哈希表
                token_id = self._generate_token(token_meta["owner"])
                self.token_hash[token_id] = token_meta
                print(f"🔄 transform完成：Token[{token_id[:8]}] → {token_meta}")
            except Exception as e:
                print(f"❌ transform失败：{e}")
                return False
        
        # 初始化后校验零和
        self.pre_condition = len(self.token_hash) >= 2
        self.zero_sum_ok = self.check_zero_sum()
        return self.pre_condition and self.zero_sum_ok

    def _generate_token(self, owner: str) -> str:
        return hashlib.md5(f"{owner}_{str(uuid.uuid4())}".encode()).hexdigest()[:12]

    def check_zero_sum(self) -> bool:
        total = sum(v["init_value"] for v in self.token_hash.values())
        self.zero_sum_ok = abs(total) < 0.001
        return self.zero_sum_ok

    def run_transform(self, transfer: float = 10.0) -> None:
        """运行时执行transform规则（动态调整Token值）"""
        left_token = next((k for k, v in self.token_hash.items() if "left" in v["owner"]), None)
        right_token = next((k for k, v in self.token_hash.items() if "right" in v["owner"]), None)
        if left_token and right_token:
            self.token_hash[left_token]["init_value"] -= transfer
            self.token_hash[right_token]["init_value"] += transfer
            self.check_zero_sum()
            print(f"[觉侧·动态transform] 左→右转移{transfer} → 零和校验：{self.zero_sum_ok}")


@dataclass
class SessionMapService:
    """动侧-机械：集成λ-conversion规则的Session映射表服务"""
    service_id: str
    lambda_engine: LambdaConversionEngine  # 注入λ+conversion引擎
    session_map: Dict[str, Dict] = None
    link_pairs: List[Tuple[str, str]] = None
    pre_condition: bool = False
    half_full_result: Dict[str, bool] = None

    def __post_init__(self):
        self.session_map = {}
        self.link_pairs = [("mecha_P", "mecha_Q")]
        self.half_full_result = {"mecha_P": False, "mecha_Q": False}

    def init_session(self, mecha_list: List[str], bridge_id: str = "bridge_001") -> bool:
        """初始化Session映射表"""
        for mecha in mecha_list:
            session_id = self._generate_session(mecha)
            self.session_map[session_id] = {
                "mecha": mecha,
                "bridge": bridge_id,
                "usage": 0.0,
                "link": f"/link/link/{mecha.lower()}"
            }
        self.pre_condition = len(self.session_map) >= 2
        return self.pre_condition

    def _generate_session(self, mecha_id: str) -> str:
        return f"session_{hashlib.md5(f'{mecha_id}_{uuid.uuid4()}'.encode()).hexdigest()[:10]}"

    def check_half_full(self) -> Dict[str, bool]:
        for s, v in self.session_map.items():
            self.half_full_result[v["mecha"]] = v["usage"] >= 50.0
        return self.half_full_result

    def run_conversion(self, cookie_strengths: Dict[str, float]) -> List[Dict]:
        """运行时执行conversion规则（集成自动化核心）"""
        integration_results = []
        for mecha, strength in cookie_strengths.items():
            # 1. 更新Session使用率
            session = next((s for s, v in self.session_map.items() if v["mecha"] == mecha), None)
            if not session:
                continue
            self.session_map[session]["usage"] = strength * 0.5  # 模拟信号转换
            print(f"[动侧·Session更新] {mecha} → 使用率：{self.session_map[session]['usage']:.1f}%")
            
            # 2. 执行λ表达式计算状态
            status = self.lambda_engine.calculate_status(self.session_map[session]["usage"])
            print(f"[动侧·λ计算] {mecha}状态：{status}")
            
            # 3. 执行附加conversion规则，转换为集成格式
            conversion_result = self.lambda_engine.convert_to_integration_format(self.session_map[session])
            integration_results.append(conversion_result)
            print(f"[动侧·conversion完成] {mecha}集成数据：{json.dumps(conversion_result['data'], ensure_ascii=False)}")
        
        # 更新半满结果
        self.check_half_full()
        return integration_results


# ------------------------------------------------------
# 3. 原有核心结构保留（仅适配升级）
# ------------------------------------------------------
@dataclass
class ThreeLayerStructure:
    layer_type: str = "nested"
    carrier: str = ""
    center: str = ""
    logic_basis: str = ""
    protocol_word: str = ""
    concept_unit: Dict[str, str] = None

    def init_structure(self) -> None:
        init_map = {
            "nested": {"carrier": "套打Racket", "center": "商业中心", "logic_basis": "一阶线性逻辑"},
            "stacked": {"carrier": "套管Packet", "center": "产业中心", "logic_basis": "一元单调谓词"},
            "cascaded": {"carrier": "套接Socket", "center": "工业中心", "logic_basis": "简单单元命题"}
        }
        config = init_map[self.layer_type]
        self.carrier, self.center, self.logic_basis = config.values()
        self.protocol_word = {"nested":"Topless","stacked":"Reserved","cascaded":"Preserving"}[self.layer_type]
        self.concept_unit = {"nested":{"概念对子":"身份-边框"},"stacked":{"三次配对":"角色-风格"},"cascaded":{"存在偶对":"性质-秩序"}}[self.layer_type]


@dataclass
class ThreePrinciple:
    principle_type: str = "intuition"
    core_attribute: str = ""
    category: str = ""
    domain: str = ""
    super_structure: str = ""
    ontology: str = ""

    def activate(self) -> None:
        init_map = {
            "intuition": {"core_attribute":"“有”的优先级","category":"量范畴","domain":"量Number","super_structure":"profile链路","ontology":"原型本体"},
            "no_subject": {"core_attribute":"“空”的自由度","category":"数范式","domain":"数Time","super_structure":"hypertext链接","ontology":"形式本体"},
            "common_basis": {"core_attribute":"“是”的自主性","category":"值范围","domain":"值True","super_structure":"super链条","ontology":"术语本体"}
        }
        config = init_map[self.principle_type]
        self.__dict__.update(config)


@dataclass
class CookieHasseService:
    service_id: str
    cookie_hasse: Dict[str, Dict] = None
    chain_nodes: List[str] = None
    pre_condition: bool = False
    integral_ok: bool = False

    def __post_init__(self):
        self.cookie_hasse = self._init_cookie_hasse()
        self.chain_nodes = ["hub_root", "obj_X", "obj_Y"]

    def _init_cookie_hasse(self) -> Dict:
        root = f"cookie_root_{str(uuid.uuid4())[:6]}"
        return {
            root: {"obj": "hub_root", "parent": None, "strength": 200.0, "chain": "/link/chain/center"},
            f"cookie_x_{str(uuid.uuid4())[:6]}": {"obj": "obj_X", "parent": root, "strength": 0.0, "chain": "/link/chain/front"},
            f"cookie_y_{str(uuid.uuid4())[:6]}": {"obj": "obj_Y", "parent": root, "strength": 0.0, "chain": "/link/chain/back"}
        }

    def check_integral(self) -> bool:
        root = next(k for k, v in self.cookie_hasse.items() if v["parent"] is None)
        child_sum = sum(v["strength"] for v in self.cookie_hasse.values() if v["parent"] is not None)
        self.integral_ok = abs(self.cookie_hasse[root]["strength"] - child_sum) < 0.001
        return self.integral_ok

    def execute(self, ratio: float = 0.4) -> Dict[str, float]:
        root = next(k for k, v in self.cookie_hasse.items() if v["parent"] is None)
        x_cookie = next(k for k, v in self.cookie_hasse.items() if v["obj"] == "obj_X")
        y_cookie = next(k for k, v in self.cookie_hasse.items() if v["obj"] == "obj_Y")
        total = self.cookie_hasse[root]["strength"]
        x_strength = total * ratio
        y_strength = total * (1 - ratio)
        self.cookie_hasse[x_cookie]["strength"] = x_strength
        self.cookie_hasse[y_cookie]["strength"] = y_strength
        self.check_integral()
        return {"obj_X": x_strength, "obj_Y": y_strength}


# ------------------------------------------------------
# 4. 升级后核心驱动引擎
# ------------------------------------------------------
class AutoLogicEngine:
    """集成正则Transform与λ-conversion的自动化逻辑引擎"""
    def __init__(self):
        # 初始化规则引擎（觉侧+动侧核心升级）
        self.regex_transform = RegexTransformEngine()
        self.lambda_conversion = LambdaConversionEngine()

        # 初始化三层结构与三原则
        self.layers = {t: ThreeLayerStructure(layer_type=t) for t in ["nested", "stacked", "cascaded"]}
        self.principles = {t: ThreePrinciple(principle_type=t) for t in ["intuition", "no_subject", "common_basis"]}

        # 初始化三侧服务（集成规则引擎）
        self.token_service = TokenHashService(
            service_id=f"token_{str(uuid.uuid4())[:6]}",
            regex_engine=self.regex_transform
        )
        self.cookie_service = CookieHasseService(
            service_id=f"cookie_{str(uuid.uuid4())[:6]}"
        )
        self.session_service = SessionMapService(
            service_id=f"session_{str(uuid.uuid4())[:6]}",
            lambda_engine=self.lambda_conversion
        )

        # 运行日志
        self.logs: List[Dict] = []
        self.current_cycle = 0

    def _log(self, step: str, module: str, detail: str) -> None:
        self.logs.append({
            "cycle": self.current_cycle,
            "step": step,
            "module": module,
            "time": time.strftime("%H:%M:%S"),
            "detail": detail
        })

    # ------------------------------
    # 阶段1：初始化（含规则引擎就绪）
    # ------------------------------
    def init_system(self, concept_pairs: List[str], mecha_list: List[str]) -> bool:
        print(f"\n===== 循环{self.current_cycle}·阶段1：系统初始化 =====")
        self._log("初始化", "系统", "启动三层+三原则+规则引擎初始化")

        # 初始化三层与三原则
        for layer in self.layers.values(): layer.init_structure()
        for principle in self.principles.values(): principle.activate()
        print("✅ 三层结构与三原则初始化完成")

        # 觉侧：通过概念对子+正则Transform初始化Token（映射系统化）
        token_init_ok = self.token_service.init_from_concept_pairs(concept_pairs)
        print(f"[觉侧·Token初始化] {'✅ 成功' if token_init_ok else '❌ 失败'}（零和校验：{self.token_service.zero_sum_ok}）")

        # 中间侧：初始化Cookie
        cookie_init_ok = self.cookie_service.pre_condition
        print(f"[中间侧·Cookie初始化] {'✅ 成功' if cookie_init_ok else '❌ 失败'}（整分校验：{self.cookie_service.integral_ok}）")

        # 动侧：初始化Session（为conversion做准备）
        session_init_ok = self.session_service.init_session(mecha_list)
        print(f"[动侧·Session初始化] {'✅ 成功' if session_init_ok else '❌ 失败'}")

        init_ok = token_init_ok and cookie_init_ok and session_init_ok
        self._log("初始化", "系统", f"初始化{'成功' if init_ok else '失败'}")
        return init_ok

    # ------------------------------
    # 阶段2：觉侧运行（正则Transform落地）
    # ------------------------------
    def run_perception(self) -> None:
        print(f"\n===== 循环{self.current_cycle}·阶段2：觉侧·映射系统化 =====")
        self._log("运行", "觉侧", "执行正则解析+transform规则")

        # 动态执行transform规则（调整Token值）
        self.token_service.run_transform(transfer=25.0)
        self._log("运行", "觉侧", f"transform完成，Token总数：{len(self.token_service.token_hash)}")

    # ------------------------------
    # 阶段3：中间侧运行（承上启下）
    # ------------------------------
    def run_middle(self) -> Dict[str, float]:
        print(f"\n===== 循环{self.current_cycle}·阶段3：中间侧·协同 =====")
        self._log("运行", "中间侧", "执行Cookie整分")

        # 整分并返回强度（供动侧conversion使用）
        strength_result = self.cookie_service.execute(ratio=0.5)
        print(f"✅ Cookie整分结果：{strength_result}（整分校验：{self.cookie_service.integral_ok}）")
        self._log("运行", "中间侧", f"整分完成，强度：{strength_result}")
        return strength_result

    # ------------------------------
    # 阶段4：动侧运行（λ-conversion落地）
    # ------------------------------
    def run_action(self, cookie_strengths: Dict[str, float]) -> List[Dict]:
        print(f"\n===== 循环{self.current_cycle}·阶段4：动侧·集成自动化 =====")
        self._log("运行", "动侧", "执行λ计算+conversion规则")

        # 执行conversion规则（集成自动化核心）
        integration_results = self.session_service.run_conversion(cookie_strengths)
        print(f"✅ 集成转换完成，生成{len(integration_results)}个设备的集成数据")
        self._log("运行", "动侧", f"conversion完成，集成数据数：{len(integration_results)}")
        return integration_results

    # ------------------------------
    # 主运行入口
    # ------------------------------
    def run(self, cycles: int = 1) -> None:
        print("===== 正则Transform+λ-conversion 自动化逻辑系统启动 =====")
        # 测试用概念对子（自然语言输入）与机械列表
        test_concept_pairs = [
            "概念身份:node_left-概念边框:strand_left",
            "概念身份:node_right-概念边框:strand_right",
            "概念身份:node_front-概念边框:chain_front"  # 故意多一个，测试零和
        ]
        test_mecha_list = ["mecha_P", "mecha_Q"]

        for cycle in range(cycles):
            self.current_cycle = cycle + 1
            print(f"\n==================================== 循环{self.current_cycle}/{cycles} 开始 ====================================")

            # 单轮自动化流程
            init_ok = self.init_system(test_concept_pairs, test_mecha_list)
            if not init_ok:
                print("❌ 初始化失败，终止循环")
                break
            
            self.run_perception()
            strength_data = self.run_middle()
            integration_data = self.run_action(strength_data)

            # 输出本轮核心成果
            print(f"\n🔹 本轮核心成果：")
            print(f"   - 觉侧：通过正则+transform生成{len(self.token_service.token_hash)}个Token")
            print(f"   - 动侧：通过λ+conversion生成{len(integration_data)}个集成数据块")
            print(f"==================================== 循环{self.current_cycle}/{cycles} 结束 ====================================")
            time.sleep(0.5)

        # 输出日志摘要
        self.print_log_summary()
        print(f"\n===== 系统运行完成 =====")

    def print_log_summary(self) -> None:
        print(f"\n===== 运行日志摘要 =====")
        print(f"{'循环':<4} {'步骤':<8} {'模块':<8} {'时间':<8} {'详情':<30}")
        print("-" * 70)
        for log in self.logs:
            print(f"{log['cycle']:<4} {log['step']:<8} {log['module']:<8} {log['time']:<8} {log['detail'][:30]}")


# ------------------------------------------------------
# 系统启动
# ------------------------------------------------------
if __name__ == "__main__":
    engine = AutoLogicEngine()
    engine.run(cycles=1)

[觉侧·正则解析] 接收概念对子：['概念身份:node_left-概念边框:strand_left', ...]
✅ 解析成功：{'id': 'node_left', 'border': 'strand_left'}
🔄 transform完成：Token[8f3d2c...] → {'owner': 'node_left', 'route': '/link/strand/left', 'init_value': 100.0, 'status': 'active'}
[觉侧·动态transform] 左→右转移25.0 → 零和校验：True

[动侧·Session更新] obj_X → 使用率：50.0%
[动侧·λ计算] obj_X状态：half
[动侧·conversion完成] obj_X集成数据：{"mecha_id":"obj_X","usage_rate":50.0,"status":"half","html_snippet":"<p class='status half'>半满</p>","timestamp":"2024-10-01 15:30:00"}

graph LR
    %% 觉侧扩张
    A[觉侧扩张：正则+transform→全量Token数据] --> 
    
    %% 中间侧三次集结
    B[第一转·数据层集结：全量→精简子集（收敛）] --> 
    C[第二转·逻辑层集结：子集→规则集（扩张）] --> 
    D[第三转·应用层集结：规则集→指令包（收敛）] --> 
    
    %% 动侧收敛
    E[动侧收敛：λ+conversion→集成结果] --> 
    
    %% 反馈闭环（动侧→中间侧→觉侧）
    F[动侧反馈：集成结果状态] --> 
    G[中间侧·规则调整：基于反馈更新逻辑层规则（二次扩张）] --> 
    H[觉侧·参数更新：基于规则调整transform参数（二次收敛）]
    
    %% 标注三转与扩张收敛
    note over A,B: 扩张→收敛（第一转）
    note over B,C: 收敛→扩张（第二转）
    note over C,D: 扩张→收敛（第三转）
    note over E,F: 收敛→反馈（结果输出）

graph TD
    %% 觉侧扩张输入
    A[觉侧扩张：自然语言概念对子<br>（如“身份-left-边框-strand”）] --> 
    
    %% 表层类比（扩张→收敛）
    B[表层类比·第一转<br>（字面：概念→数据，收敛为核心字段）] --> 
    C[数据层结果：left/right数据子集] --> 
    
    %% 里层排比（收敛→扩张）
    D[里层排比·第二转<br>（字里：数据→规则，扩张为规则集）] --> 
    E[逻辑层结果：零和/路由排比规则] --> 
    
    %% 中间层对比（扩张→收敛）
    F[中间层对比·第三转<br>（行间：规则→指令，收敛为执行包）] --> 
    
    %% 动侧收敛输出
    G[动侧收敛：标准化执行指令<br>（如“mecha_P.usage=front×0.5”）]
    
    %% 反馈闭环
    G --> H[动侧反馈：执行状态（如“未半满”）] --> 
    I[中间层对比调整<br>（如“比例从0.5→0.6”）] --> D

import re
import json
import time
import uuid
import hashlib
from typing import Dict, List, Tuple, Callable, Optional
from dataclasses import dataclass

# ------------------------------------------------------
# 1. Word配置解析模块（模拟GUI配置）
# ------------------------------------------------------
class WordConfigParser:
    """解析Word格式的配置文件（模拟GUI配置界面）"""
    def __init__(self, config_path: str = "logic_config.json"):
        self.config_path = config_path
        self.regex_patterns = {}  # 正则表达式配置
        self.conversion_rules = {}  # 转换规则配置
        self.logic_layers = {}  # 逻辑层次配置
        
    def load_config(self) -> bool:
        """加载配置文件（模拟从Word文档读取配置）"""
        try:
            # 实际应用中可替换为Word文档解析逻辑
            with open(self.config_path, 'r', encoding='utf-8') as f:
                config = json.load(f)
            
            self.regex_patterns = config.get('regex_patterns', {
                'concept_pair': r'概念身份:(?P<id>\w+)-概念边框:(?P<border>\w+)',
                'form_pair': r'(?P<left>\w+)\.(?P<attr>\w+)\s*=\s*-(?P<right>\w+)\.(?P<rattr>\w+)'
            })
            
            self.conversion_rules = config.get('conversion_rules', {
                'status_mapping': {
                    'full': '满负荷',
                    'half': '半满',
                    'empty': '空闲'
                },
                'html_templates': {
                    'full': '<p class="status full">{}</p>',
                    'half': '<p class="status half">{}</p>',
                    'empty': '<p class="status empty">{}</p>'
                }
            })
            
            self.logic_layers = config.get('logic_layers', {
                'surface': {'active': True, 'priority': 1},
                'inner': {'active': True, 'priority': 2},
                'middle': {'active': True, 'priority': 3}
            })
            return True
        except Exception as e:
            print(f"[配置加载错误] {str(e)}，使用默认配置")
            # 加载默认配置
            self._load_defaults()
            return False
    
    def _load_defaults(self) -> None:
        """加载默认配置"""
        self.regex_patterns = {
            'concept_pair': r'概念身份:(?P<id>\w+)-概念边框:(?P<border>\w+)',
            'form_pair': r'(?P<left>\w+)\.(?P<attr>\w+)\s*=\s*-(?P<right>\w+)\.(?P<rattr>\w+)'
        }
        self.conversion_rules = {
            'status_mapping': {'full': '满负荷', 'half': '半满', 'empty': '空闲'},
            'html_templates': {
                'full': '<p class="status full">{}</p>',
                'half': '<p class="status half">{}</p>',
                'empty': '<p class="status empty">{}</p>'
            }
        }
        self.logic_layers = {
            'surface': {'active': True, 'priority': 1},
            'inner': {'active': True, 'priority': 2},
            'middle': {'active': True, 'priority': 3}
        }
    
    def save_config(self) -> bool:
        """保存配置（模拟保存到Word文档）"""
        try:
            config = {
                'regex_patterns': self.regex_patterns,
                'conversion_rules': self.conversion_rules,
                'logic_layers': self.logic_layers
            }
            with open(self.config_path, 'w', encoding='utf-8') as f:
                json.dump(config, f, ensure_ascii=False, indent=2)
            return True
        except Exception as e:
            print(f"[配置保存错误] {str(e)}")
            return False
    
    def update_regex_pattern(self, pattern_name: str, pattern: str) -> bool:
        """更新正则表达式模式"""
        try:
            # 验证正则表达式有效性
            re.compile(pattern)
            self.regex_patterns[pattern_name] = pattern
            return True
        except re.error as e:
            print(f"[正则表达式错误] {str(e)}")
            return False


# ------------------------------------------------------
# 2. 逻辑层次处理模块（三个层次）
# ------------------------------------------------------
class SurfaceLayerProcessor:
    """表层类比-概念对子（字面层）处理"""
    def __init__(self, config_parser: WordConfigParser):
        self.config = config_parser
        self.concept_pattern = re.compile(
            self.config.regex_patterns.get('concept_pair', 
            r'概念身份:(?P<id>\w+)-概念边框:(?P<border>\w+)')
        )
        self.border_route_map = {
            "strand_left": "/link/strand/left",
            "strand_right": "/link/strand/right",
            "chain_front": "/link/chain/front",
            "chain_back": "/link/chain/back"
        }
    
    def parse_concept_pairs(self, input_text: str) -> List[Dict]:
        """解析概念对子文本"""
        pairs = []
        for line in input_text.strip().split('\n'):
            match = self.concept_pattern.match(line.strip())
            if match:
                pairs.append(match.groupdict())
        return pairs
    
    def analogize_to_data(self, concept_pairs: List[Dict]) -> Dict[str, Dict]:
        """将概念对子类比映射为数据结构"""
        result = {}
        for pair in concept_pairs:
            concept_id = pair['id']
            border = pair['border']
            
            # 类比映射
            value = 100.0 if "left" in concept_id or "front" in concept_id else -100.0
            route = self.border_route_map.get(border, f"/link/default/{concept_id}")
            
            result[f"token_{concept_id}"] = {
                "owner": concept_id,
                "border": border,
                "route": route,
                "value": value,
                "source_concept": f"概念身份:{concept_id}-概念边框:{border}"
            }
        return result


class InnerLayerProcessor:
    """里层排比-形式配对（字里层）处理"""
    def __init__(self, config_parser: WordConfigParser):
        self.config = config_parser
        self.form_pattern = re.compile(
            self.config.regex_patterns.get('form_pair',
            r'(?P<left>\w+)\.(?P<attr>\w+)\s*=\s*-(?P<right>\w+)\.(?P<rattr>\w+)')
        )
    
    def extract_form_rules(self, data: Dict[str, Dict]) -> List[Dict]:
        """从数据中提取排比形式规则"""
        rules = []
        
        # 提取零和规则（排比规则1）
        left_tokens = [k for k, v in data.items() if "left" in v["owner"]]
        right_tokens = [k for k, v in data.items() if "right" in v["owner"]]
        
        if left_tokens and right_tokens:
            rules.append({
                "rule_id": f"rule_{str(uuid.uuid4())[:6]}",  # 修复UUID处理
                "type": "sum_constraint",
                "pattern": "{}_value + {}_value = 0",
                "description": "左右Token值之和为零",
                "priority": 1,
                "params": [left_tokens[0], right_tokens[0]]
            })
        
        # 提取路由规则（排比规则2）
        route_prefixes = set()
        for token_id, token_data in data.items():
            prefix = '/'.join(token_data["route"].split('/')[:-1])
            route_prefixes.add(prefix)
            
        for prefix in route_prefixes:
            rules.append({
                "rule_id": f"rule_{str(uuid.uuid4())[:6]}",  # 修复UUID处理
                "type": "route_pattern",
                "pattern": f"路由前缀统一为: {prefix}",
                "description": "同组Token路由前缀一致",
                "priority": 2,
                "params": [prefix]
            })
        
        return rules
    
    def validate_with_rules(self, data: Dict[str, Dict], rules: List[Dict]) -> Dict[str, bool]:
        """用排比规则验证数据"""
        results = {}
        
        for rule in rules:
            if rule["type"] == "sum_constraint":
                left_id, right_id = rule["params"]
                left_val = data.get(left_id, {}).get("value", 0)
                right_val = data.get(right_id, {}).get("value", 0)
                results[rule["rule_id"]] = abs(left_val + right_val) < 0.001
            elif rule["type"] == "route_pattern":
                prefix = rule["params"][0]
                valid = all(data[token_id]["route"].startswith(prefix) 
                           for token_id in data if data[token_id]["route"].startswith(prefix))
                results[rule["rule_id"]] = valid
        
        return results


class MiddleLayerProcessor:
    """中间层对比-存在对偶（行间层）处理"""
    def __init__(self, config_parser: WordConfigParser):
        self.config = config_parser
    
    def identify_dual_relations(self, rules: List[Dict], cookie_data: Dict) -> List[Dict]:
        """识别存在对偶关系"""
        dual_relations = []
        
        # 对比Token零和与Cookie整分的对偶关系
        sum_rules = [r for r in rules if r["type"] == "sum_constraint"]
        if sum_rules and cookie_data:
            root_cookie = next(k for k, v in cookie_data.items() if v["parent"] is None)
            dual_relations.append({
                "dual_id": f"dual_{str(uuid.uuid4())[:6]}",  # 修复UUID处理
                "relation": "零和-整分对偶",
                "description": "Token的零和规则与Cookie的整分规则形成守恒对偶",
                "left": "Token系统",
                "right": "Cookie系统",
                "basis": f"Token规则: {sum_rules[0]['pattern']}; Cookie根节点: {root_cookie}"
            })
        
        # 识别前后/左右对偶
        direction_pairs = [("left", "right"), ("front", "back"), ("up", "down")]
        for left_dir, right_dir in direction_pairs:
            dual_relations.append({
                "dual_id": f"dual_{str(uuid.uuid4())[:6]}",  # 修复UUID处理
                "relation": f"{left_dir}-{right_dir}方向对偶",
                "description": f"{left_dir}与{right_dir}形成方向上的存在对偶",
                "left": left_dir,
                "right": right_dir,
                "basis": "空间方向的对立统一"
            })
        
        return dual_relations
    
    def generate_commands(self, dual_relations: List[Dict], session_data: Dict) -> Dict[str, Dict]:
        """基于对偶关系生成执行命令"""
        commands = {}
        
        # 为每个机械生成状态计算命令
        for session_id, session_info in session_data.items():
            mecha_id = session_info["mecha"]
            
            # 找到相关的对偶关系
            related_dual = next((d for d in dual_relations 
                               if d["left"] in mecha_id or d["right"] in mecha_id), None)
            
            cmd_id = f"cmd_{str(uuid.uuid4())[:6]}"  # 修复UUID处理
            commands[cmd_id] = {
                "target": mecha_id,
                "action": "calculate_status",
                "logic": "usage = cookie_strength × 0.5",
                "dual_basis": related_dual["dual_id"] if related_dual else None,
                "timestamp": time.strftime("%Y-%m-%d %H:%M:%S")
            }
        
        return commands


# ------------------------------------------------------
# 3. 核心数据结构
# ------------------------------------------------------
@dataclass
class TokenHashService:
    """觉侧-人：Token哈希表服务"""
    service_id: str
    surface_processor: SurfaceLayerProcessor
    data: Dict[str, Dict] = None
    zero_sum_ok: bool = False
    
    def __post_init__(self):
        self.data = {}
    
    def initialize_from_concepts(self, concept_text: str) -> bool:
        """从概念文本初始化Token数据"""
        concept_pairs = self.surface_processor.parse_concept_pairs(concept_text)
        if not concept_pairs:
            print("[Token初始化失败] 未解析到有效概念对子")
            return False
            
        self.data = self.surface_processor.analogize_to_data(concept_pairs)
        self.zero_sum_ok = self._check_zero_sum()
        return True
    
    def _check_zero_sum(self) -> bool:
        """检查零和特性"""
        if not self.data:
            return False
        total = sum(v["value"] for v in self.data.values())
        return abs(total) < 0.001
    
    def transfer_value(self, from_token: str, to_token: str, amount: float) -> bool:
        """转移Token值"""
        if from_token not in self.data or to_token not in self.data:
            return False
            
        self.data[from_token]["value"] -= amount
        self.data[to_token]["value"] += amount
        self.zero_sum_ok = self._check_zero_sum()
        return True


@dataclass
class CookieHasseService:
    """中间侧-机器：Cookie哈斯图服务"""
    service_id: str
    data: Dict[str, Dict] = None
    integral_ok: bool = False
    
    def __post_init__(self):
        self.data = self._initialize_data()
    
    def _initialize_data(self) -> Dict[str, Dict]:
        """初始化Cookie数据"""
        root_id = f"cookie_root_{str(uuid.uuid4())[:6]}"  # 修复UUID处理
        return {
            root_id: {
                "obj": "hub_root",
                "parent": None,
                "strength": 200.0,
                "chain": "/link/chain/center"
            },
            f"cookie_x_{str(uuid.uuid4())[:6]}": {  # 修复UUID处理
                "obj": "obj_X",
                "parent": root_id,
                "strength": 0.0,
                "chain": "/link/chain/front"
            },
            f"cookie_y_{str(uuid.uuid4())[:6]}": {  # 修复UUID处理
                "obj": "obj_Y",
                "parent": root_id,
                "strength": 0.0,
                "chain": "/link/chain/back"
            }
        }
    
    def distribute_strength(self, ratio: float = 0.4) -> bool:
        """整分强度值"""
        try:
            root_id = next(k for k, v in self.data.items() if v["parent"] is None)
            x_id = next(k for k, v in self.data.items() if v["obj"] == "obj_X")
            y_id = next(k for k, v in self.data.items() if v["obj"] == "obj_Y")
            
            total = self.data[root_id]["strength"]
            self.data[x_id]["strength"] = total * ratio
            self.data[y_id]["strength"] = total * (1 - ratio)
            
            self.integral_ok = self._check_integral()
            return True
        except Exception as e:
            print(f"[Cookie整分错误] {str(e)}")
            return False
    
    def _check_integral(self) -> bool:
        """检查整分特性"""
        root_id = next(k for k, v in self.data.items() if v["parent"] is None)
        total = self.data[root_id]["strength"]
        child_sum = sum(v["strength"] for v in self.data.values() if v["parent"] is not None)
        return abs(total - child_sum) < 0.001


@dataclass
class SessionMapService:
    """动侧-机械：Session映射表服务"""
    service_id: str
    conversion_rules: Dict
    data: Dict[str, Dict] = None
    half_full_result: Dict[str, bool] = None
    
    def __post_init__(self):
        self.data = {}
        self.half_full_result = {}
        if not self.conversion_rules:
            self.conversion_rules = {
                'status_mapping': {'full': '满负荷', 'half': '半满', 'empty': '空闲'},
                'html_templates': {
                    'full': '<p class="status full">{}</p>',
                    'half': '<p class="status half">{}</p>',
                    'empty': '<p class="status empty">{}</p>'
                }
            }
    
    def initialize_sessions(self, mecha_list: List[str]) -> bool:
        """初始化Session数据"""
        for mecha in mecha_list:
            session_id = f"session_{hashlib.md5(f'{mecha}_{uuid.uuid4()}'.encode()).hexdigest()[:10]}"
            self.data[session_id] = {
                "mecha": mecha,
                "bridge": "bridge_001",
                "usage": 0.0,
                "link": f"/link/link/{mecha.lower()}"
            }
            self.half_full_result[mecha] = False
        return len(self.data) == len(mecha_list)
    
    def update_usage(self, mecha_usage: Dict[str, float]) -> None:
        """更新使用情况"""
        for mecha, usage in mecha_usage.items():
            session_id = next((k for k, v in self.data.items() if v["mecha"] == mecha), None)
            if session_id:
                self.data[session_id]["usage"] = usage
                self.half_full_result[mecha] = usage >= 50.0
    
    def convert_to_ui_format(self) -> Dict[str, Dict]:
        """转换为UI展示格式"""
        result = {}
        for session_id, session_data in self.data.items():
            mecha = session_data["mecha"]
            usage = session_data["usage"]
            
            # 应用λ表达式逻辑计算状态
            status = "full" if usage >= 80.0 else "half" if usage >= 50.0 else "empty"
            
            # 应用转换规则
            status_text = self.conversion_rules['status_mapping'][status]
            html_snippet = self.conversion_rules['html_templates'][status].format(status_text)
            
            result[mecha] = {
                "mecha": mecha,
                "usage": round(usage, 1),
                "status": status,
                "status_text": status_text,
                "html_snippet": html_snippet,
                "timestamp": time.strftime("%Y-%m-%d %H:%M:%S")
            }
        return result


# ------------------------------------------------------
# 4. 三转法论核心引擎
# ------------------------------------------------------
class ThreeTurnsEngine:
    """三转法论核心引擎"""
    def __init__(self):
        # 初始化配置解析器（模拟Word配置）
        self.config_parser = WordConfigParser()
        self.config_parser.load_config()
        
        # 初始化逻辑层次处理器
        self.surface_processor = SurfaceLayerProcessor(self.config_parser)
        self.inner_processor = InnerLayerProcessor(self.config_parser)
        self.middle_processor = MiddleLayerProcessor(self.config_parser)
        
        # 初始化三侧服务
        self.token_service = TokenHashService(
            service_id=f"token_{str(uuid.uuid4())[:6]}",  # 修复UUID处理
            surface_processor=self.surface_processor
        )
        
        self.cookie_service = CookieHasseService(
            service_id=f"cookie_{str(uuid.uuid4())[:6]}"  # 修复UUID处理
        )
        
        self.session_service = SessionMapService(
            service_id=f"session_{str(uuid.uuid4())[:6]}",  # 修复UUID处理
            conversion_rules=self.config_parser.conversion_rules
        )
        
        # 运行状态与日志
        self.logs = []
        self.current_cycle = 0
        self.running = False
    
    def _log(self, step: str, module: str, message: str) -> None:
        """记录日志"""
        log_entry = {
            "cycle": self.current_cycle,
            "timestamp": time.strftime("%H:%M:%S"),
            "step": step,
            "module": module,
            "message": message
        }
        self.logs.append(log_entry)
        print(f"[{log_entry['timestamp']}] [{step}] {module}: {message}")
    
    def first_turn(self, concept_text: str) -> bool:
        """第一转：停转整理（表层类比-数据层集结）"""
        self._log("第一转", "停转整理", "开始执行")
        
        # 1. 解析概念对子并初始化Token
        init_success = self.token_service.initialize_from_concepts(concept_text)
        if not init_success:
            self._log("第一转", "停转整理", "初始化Token失败")
            return False
        
        # 2. 数据层集结结果
        self._log("第一转", "停转整理", 
                 f"完成数据层集结，Token数量: {len(self.token_service.data)}, 零和校验: {'通过' if self.token_service.zero_sum_ok else '失败'}")
        
        # 3. 输出表层类比结果
        self._log("第一转", "表层类比", "概念对子→数据映射完成")
        for token_id, token_data in self.token_service.data.items():
            self._log("第一转", "表层类比", 
                     f"  {token_data['source_concept']} → {token_id} (值: {token_data['value']})")
        
        return True
    
    def second_turn(self, ratio: float = 0.4) -> bool:
        """第二转：反转验证（里层排比-逻辑层集结）"""
        self._log("第二转", "反转验证", "开始执行")
        
        # 1. Cookie整分
        cookie_success = self.cookie_service.distribute_strength(ratio)
        if not cookie_success:
            self._log("第二转", "反转验证", "Cookie整分失败")
            return False
        
        # 2. 提取排比规则
        form_rules = self.inner_processor.extract_form_rules(self.token_service.data)
        self._log("第二转", "里层排比", f"提取到{len(form_rules)}条形式规则")
        
        # 3. 规则验证
        validation_results = self.inner_processor.validate_with_rules(
            self.token_service.data, form_rules)
        
        valid_count = sum(1 for v in validation_results.values() if v)
        self._log("第二转", "反转验证", 
                 f"规则验证完成: {valid_count}/{len(validation_results)} 条通过")
        
        # 4. 输出规则详情
        for i, rule in enumerate(form_rules):
            status = "通过" if validation_results[rule["rule_id"]] else "失败"
            self._log("第二转", "里层排比", 
                     f"  规则{i+1}: {rule['description']} ({status})")
        
        return True
    
    def third_turn(self, mecha_list: List[str]) -> Dict:
        """第三转：正转批注（中间层对比-应用层集结）"""
        self._log("第三转", "正转批注", "开始执行")
        
        # 1. 初始化Session
        session_success = self.session_service.initialize_sessions(mecha_list)
        if not session_success:
            self._log("第三转", "正转批注", "Session初始化失败")
            return {}
        
        # 2. 计算机械使用率（基于Cookie强度）
        x_cookie = next(k for k, v in self.cookie_service.data.items() if v["obj"] == "obj_X")
        y_cookie = next(k for k, v in self.cookie_service.data.items() if v["obj"] == "obj_Y")
        
        mecha_usage = {
            "mecha_P": self.cookie_service.data[x_cookie]["strength"] * 0.3,
            "mecha_Q": self.cookie_service.data[y_cookie]["strength"] * 0.2
        }
        self.session_service.update_usage(mecha_usage)
        
        # 3. 识别对偶关系
        form_rules = self.inner_processor.extract_form_rules(self.token_service.data)
        dual_relations = self.middle_processor.identify_dual_relations(
            form_rules, self.cookie_service.data)
        self._log("第三转", "中间层对比", f"识别到{len(dual_relations)}对存在对偶关系")
        
        # 4. 生成执行命令
        commands = self.middle_processor.generate_commands(
            dual_relations, self.session_service.data)
        self._log("第三转", "应用层集结", f"生成{len(commands)}条执行命令")
        
        # 5. 转换为UI格式
        ui_data = self.session_service.convert_to_ui_format()
        
        # 输出结果
        self._log("第三转", "正转批注", "完成应用层集结")
        for mecha, data in ui_data.items():
            self._log("第三转", "集成结果", 
                     f"  {mecha}: 使用率{data['usage']}% → {data['status_text']}")
        
        return ui_data
    
    def run_cycle(self, concept_text: str, mecha_list: List[str], ratio: float = 0.4) -> bool:
        """运行一轮三转流程"""
        self.current_cycle += 1
        self._log("循环", "系统", f"开始第{self.current_cycle}轮循环")
        
        # 执行三转
        turn1_ok = self.first_turn(concept_text)
        if not turn1_ok:
            return False
            
        turn2_ok = self.second_turn(ratio)
        if not turn2_ok:
            return False
            
        ui_results = self.third_turn(mecha_list)
        if not ui_results:
            return False
        
        self._log("循环", "系统", f"第{self.current_cycle}轮循环完成")
        return True
    
    def save_session_results(self, output_path: str = "session_results.json") -> bool:
        """保存会话结果"""
        try:
            results = {
                "timestamp": time.strftime("%Y-%m-%d %H:%M:%S"),
                "cycles": self.current_cycle,
                "final_status": self.session_service.convert_to_ui_format(),
                "logs": self.logs
            }
            
            with open(output_path, 'w', encoding='utf-8') as f:
                json.dump(results, f, ensure_ascii=False, indent=2)
            return True
        except Exception as e:
            print(f"[保存结果错误] {str(e)}")
            return False


# ------------------------------------------------------
# 5. 系统运行入口
# ------------------------------------------------------
def main():
    # 初始化系统
    engine = ThreeTurnsEngine()
    print("===== 三转法论与正则解析缝合系统启动 =====")
    print(f"配置加载状态: {'成功' if engine.config_parser.load_config() else '使用默认配置'}")
    
    # 示例概念对子（可从Word文档读取）
    concept_text = """
    概念身份:node_left-概念边框:strand_left
    概念身份:node_right-概念边框:strand_right
    概念身份:node_front-概念边框:chain_front
    概念身份:node_back-概念边框:chain_back
    """
    
    # 机械列表
    mecha_list = ["mecha_P", "mecha_Q"]
    
    # 运行两轮循环
    for i in range(2):
        ratio = 0.4 + i * 0.1  # 第二轮调整比例
        success = engine.run_cycle(concept_text, mecha_list, ratio)
        if not success:
            print(f"第{i+1}轮循环执行失败")
            break
        time.sleep(1)  # 间隔1秒
    
    # 保存结果
    if engine.save_session_results():
        print("运行结果已保存至 session_results.json")
    
    print("===== 系统运行结束 =====")


if __name__ == "__main__":
    main()
    

PS E:\three_views_projec> python integrated_logic_system.py
[配置加载错误] [Errno 2] No such file or directory: 'logic_config.json'，使用默认配置
===== 三转法论与正则解析缝合系统启动 =====
[配置加载错误] [Errno 2] No such file or directory: 'logic_config.json'，使用默认配置
配置加载状态: 使用默认配置
[14:32:39] [循环] 系统: 开始第1轮循环
[14:32:39] [第一转] 停转整理: 开始执行
[14:32:39] [第一转] 停转整理: 完成数据层集结，Token数量: 4, 零和校验: 通过
[14:32:39] [第一转] 表层类比: 概念对子→数据映射完成
[14:32:39] [第一转] 表层类比:   概念身份:node_left-概念边框:strand_left → token_node_left (值: 100.0)    
[14:32:39] [第一转] 表层类比:   概念身份:node_right-概念边框:strand_right → token_node_right (值: -100.0)
[14:32:39] [第一转] 表层类比:   概念身份:node_front-概念边框:chain_front → token_node_front (值: 100.0)  
[14:32:39] [第一转] 表层类比:   概念身份:node_back-概念边框:chain_back → token_node_back (值: -100.0)    
[14:32:39] [第二转] 反转验证: 开始执行
[14:32:39] [第二转] 里层排比: 提取到3条形式规则
[14:32:39] [第二转] 反转验证: 规则验证完成: 3/3 条通过
[14:32:39] [第二转] 里层排比:   规则1: 左右Token值之和为零 (通过)
[14:32:39] [第二转] 里层排比:   规则2: 同组Token路由前缀一致 (通过)
[14:32:39] [第二转] 里层排比:   规则3: 同组Token路由前缀一致 (通过)
[14:32:39] [第三转] 正转批注: 开始执行
[14:32:39] [第三转] 中间层对比: 识别到4对存在对偶关系
[14:32:39] [第三转] 应用层集结: 生成2条执行命令
[14:32:39] [第三转] 正转批注: 完成应用层集结
[14:32:39] [第三转] 集成结果:   mecha_P: 使用率24.0% → 空闲
[14:32:39] [第三转] 集成结果:   mecha_Q: 使用率24.0% → 空闲
[14:32:39] [循环] 系统: 第1轮循环完成
[14:32:40] [循环] 系统: 开始第2轮循环
[14:32:40] [第一转] 停转整理: 开始执行
[14:32:40] [第一转] 停转整理: 完成数据层集结，Token数量: 4, 零和校验: 通过
[14:32:40] [第一转] 表层类比: 概念对子→数据映射完成
[14:32:40] [第一转] 表层类比:   概念身份:node_left-概念边框:strand_left → token_node_left (值: 100.0)
[14:32:40] [第一转] 表层类比:   概念身份:node_right-概念边框:strand_right → token_node_right (值: -100.0)
[14:32:40] [第一转] 表层类比:   概念身份:node_front-概念边框:chain_front → token_node_front (值: 100.0)
[14:32:40] [第一转] 表层类比:   概念身份:node_back-概念边框:chain_back → token_node_back (值: -100.0)
[14:32:40] [第二转] 反转验证: 开始执行
[14:32:40] [第二转] 里层排比: 提取到3条形式规则
[14:32:40] [第二转] 反转验证: 规则验证完成: 3/3 条通过
[14:32:40] [第二转] 里层排比:   规则1: 左右Token值之和为零 (通过)
[14:32:40] [第二转] 里层排比:   规则2: 同组Token路由前缀一致 (通过)
[14:32:40] [第二转] 里层排比:   规则3: 同组Token路由前缀一致 (通过)
[14:32:40] [第三转] 正转批注: 开始执行
[14:32:40] [第三转] 正转批注: Session初始化失败
第2轮循环执行失败
运行结果已保存至 session_results.json
===== 系统运行结束 =====