CNSH 排序不动点协议引擎 v1.0

#!/usr/bin/env python3
# -*- coding: utf-8 -*-

import os as _os
import sys as _sys
_module_dir = _os.path.dirname(_os.path.abspath(__file__))
if _module_dir not in _sys.path:
    _sys.path.insert(0, _module_dir)
"""
CNSH 排序不动点协议引擎 v1.0
协议原文：龍魂排序不动点 · 三层排序 · 三次审计 · 七维度对射
DNA: #龍芯⚡️2026-04-19-ORDER-ANCHOR-v1.0
确认码: #CONFIRM🌌9622-ONLY-ONCE🧬LK9X-772Z ✅
GPG指纹: A2D0092CEE2E5BA87035600924C3704A8CC26D5F
原则: 只翻译不破解 · 顺序是心脏 · 护弱是底线
"""

import json
import math
import secrets
from dataclasses import dataclass, field
from datetime import datetime, timezone
from pathlib import Path
from typing import Dict, List, Optional, Tuple

from CNSH_基础类型 import 三色, 审计维度, 审计项, 审计报告
from CNSH_国密工具 import SM3, hmac_sm3, 生成随机密钥


# ============== 协议常量（只读，不可覆盖） ==============
class 排序层:
    宏观_立国 = "人民 > 国家 > 集体 > 个人"
    中观_立身 = "忠 > 孝 > 义"
    微观_立事 = "人 > 地 > 天"


class 审计轮次:
    人心审 = "人心审"
    天地审 = "天地审"
    民利审 = "民利审"


@dataclass
class 决策输入:
    名称: str
    全球收益: float
    群体损失: float
    涉及弱者: bool = False
    弱者数量: int = 0
    卦象权重: float = 1.0
    文化权重: float = 1.0
    忠排序分: float = 1.0   # 0~1，越高越守忠
    孝排序分: float = 1.0
    义排序分: float = 1.0
    人民排序分: float = 1.0
    国家排序分: float = 1.0
    个人排序分: float = 0.0  # 越低越好，防止个人优先


@dataclass
class 决策结果:
    名称: str
    三色: 三色
    人心审结果: Dict[str, any]
    天地审结果: Dict[str, any]
    民利审结果: Dict[str, any]
    综合得分: float
    决策: str
    DNA: str
    输入SM3哈希: str


class CNSH_排序不动点引擎:
    """
    把「排序不动点」协议翻译为可执行代码。
    核心：人民第一、护弱底线、顺序错了熔断。
    """

    def __init__(self, 护弱密钥: Optional[bytes] = None):
        self.护弱密钥 = 护弱密钥 or 生成随机密钥()
        self.审计日志: List[Dict[str, any]] = []

    # ---------- 国密工具 ----------
    def _计算SM3(self, 数据: str) -> str:
        return SM3.hex_hash(数据)

    def _生成DNA(self, 动作: str, 输入哈希: str) -> str:
        时间戳 = datetime.now(timezone.utc).strftime("%Y%m%d%H%M%S")
        熵 = secrets.token_hex(4).upper()
        原料 = f"{动作}-{输入哈希}-{时间戳}-{熵}-UID9622-ORDER-ANCHOR"
        短哈希 = SM3.hex_hash(原料)[:16].upper()
        return f"#龍芯⚡️{datetime.now(timezone.utc).strftime('%Y-%m-%d')}-{动作}-{短哈希}-ENTROPY{熵}-UID9622"

    # ---------- 第一审：人心审（伦理红线） ----------
    def 人心审(self, 输入: 决策输入) -> Dict[str, any]:
        """
        问：这事良心过得去吗？
        触发 🔴 红线的条件：
        - 个人排序 > 人民排序
        - 忠 < 孝 或 忠 < 义（忠必须最高）
        - 涉及弱者且收益来自弱者损失
        """
        红线 = []
        等级 = 三色.绿

        if 输入.个人排序分 > 输入.人民排序分:
            红线.append("个人排序高于人民排序，触∞级熔断")
            等级 = 三色.红

        if 输入.忠排序分 < 输入.孝排序分:
            红线.append("忠 < 孝，排序倒置")
            if 等级 != 三色.红:
                等级 = 三色.黄

        if 输入.忠排序分 < 输入.义排序分:
            红线.append("忠 < 义，排序倒置")
            if 等级 != 三色.红:
                等级 = 三色.黄

        if 输入.涉及弱者 and 输入.群体损失 > 0 and 输入.全球收益 > 0:
            红线.append("涉及弱者且存在群体损失，触发护弱审")
            等级 = 三色.红

        return {
            "轮次": 审计轮次.人心审,
            "等级": 等级.value,
            "红线": 红线,
            "排序校验": {
                "人民 > 个人": 输入.人民排序分 > 输入.个人排序分,
                "忠 > 孝": 输入.忠排序分 >= 输入.孝排序分,
                "忠 > 义": 输入.忠排序分 >= 输入.义排序分,
            },
        }

    # ---------- 第二审：天地审（三才打分） ----------
    def 天地审(self, 输入: 决策输入) -> Dict[str, any]:
        """
        问：时机对不对？资源够不够？
        R = Σ(wᵢ · xᵢ)
        人 > 地 > 天，权重锁定 w_人 > w_地 > w_天
        """
        w_人, w_地, w_天 = 0.5, 0.3, 0.2
        x_人 = 输入.人民排序分
        x_地 = 输入.国家排序分
        x_天 = 输入.卦象权重 * 输入.文化权重

        R = (w_人 * x_人 + w_地 * x_地 + w_天 * x_天) * 100

        if R >= 85:
            等级 = 三色.绿
        elif R >= 60:
            等级 = 三色.黄
        else:
            等级 = 三色.红

        return {
            "轮次": 审计轮次.天地审,
            "等级": 等级.value,
            "R分数": round(R, 4),
            "三才": {"人": x_人, "地": x_地, "天": x_天},
            "权重": {"人": w_人, "地": w_地, "天": w_天},
        }

    # ---------- 第三审：民利审（最小损失最大收益） ----------
    def 民利审(self, 输入: 决策输入) -> Dict[str, any]:
        """
        决策 = max(全球收益 × W卦象 × W文化 / (群体损失 + ε护弱))
        ε护弱：涉及弱者时趋近无穷大，分母炸开，收益变0
        """
        分子 = 输入.全球收益 * 输入.卦象权重 * 输入.文化权重

        # 护弱修正项：涉及弱者时，ε 随弱者数量指数增长
        if 输入.涉及弱者:
            if 输入.弱者数量 > 0:
                ε护弱 = float(输入.弱者数量) * 1e12
            else:
                ε护弱 = 1e12
        else:
            ε护弱 = 1e-9

        分母 = 输入.群体损失 + ε护弱
        收益损失比 = 分子 / 分母

        # 同时计算无护弱修正的原始比，用于对比
        原始比 = 分子 / max(输入.群体损失, 1e-9)

        if 收益损失比 >= 2.0:
            等级 = 三色.绿
        elif 收益损失比 >= 1.0:
            等级 = 三色.黄
        else:
            等级 = 三色.红

        # 一旦涉及弱者且群体损失>0，强制熔断
        if 输入.涉及弱者 and 输入.群体损失 > 0:
            等级 = 三色.红

        return {
            "轮次": 审计轮次.民利审,
            "等级": 等级.value,
            "分子_全球收益加权": round(分子, 4),
            "分母_群体损失加护弱": round(分母, 4),
            "ε护弱": ε护弱,
            "收益损失比": round(收益损失比, 6),
            "原始比_无护弱": round(原始比, 6),
            "涉及弱者": 输入.涉及弱者,
            "弱者数量": 输入.弱者数量,
        }

    # ---------- 综合决策 ----------
    def 决策(self, 输入: 决策输入) -> 决策结果:
        输入JSON = json.dumps({
            "名称": 输入.名称,
            "全球收益": 输入.全球收益,
            "群体损失": 输入.群体损失,
            "涉及弱者": 输入.涉及弱者,
            "弱者数量": 输入.弱者数量,
        }, sort_keys=True, ensure_ascii=False)
        输入哈希 = self._计算SM3(输入JSON)

        人心 = self.人心审(输入)
        天地 = self.天地审(输入)
        民利 = self.民利审(输入)

        # 三色聚合：有一红则红，无红有黄则黄，全绿才绿
        if 三色.红.value in [人心["等级"], 天地["等级"], 民利["等级"]]:
            最终三色 = 三色.红
        elif 三色.黄.value in [人心["等级"], 天地["等级"], 民利["等级"]]:
            最终三色 = 三色.黄
        else:
            最终三色 = 三色.绿

        # 综合得分：三审加权
        R分数 = 天地["R分数"]
        收益比 = 民利["收益损失比"]
        综合得分 = round((R分数 * 0.4 + min(收益比 * 50, 100) * 0.4 + (100 if 人心["等级"] == "🟢" else 0) * 0.2), 4)

        if 最终三色 == 三色.红:
            决策文本 = "🔴 熔断：排序触碰红线或护弱底线，不做。"
        elif 最终三色 == 三色.黄:
            决策文本 = "🟡 人审：进入人工复核，由老大最终确认。"
        else:
            决策文本 = "🟢 放行：三层排序通过，可以执行。"

        DNA = self._生成DNA("ORDER-DECISION", 输入哈希)

        记录 = {
            "时间": datetime.now(timezone.utc).isoformat(),
            "输入哈希": 输入哈希,
            "DNA": DNA,
            "三色": 最终三色.value,
            "人心审": 人心,
            "天地审": 天地,
            "民利审": 民利,
        }
        self.审计日志.append(记录)

        return 决策结果(
            名称=输入.名称,
            三色=最终三色,
            人心审结果=人心,
            天地审结果=天地,
            民利审结果=民利,
            综合得分=综合得分,
            决策=决策文本,
            DNA=DNA,
            输入SM3哈希=输入哈希,
        )

    # ---------- 排序校验器 ----------
    def 校验三层排序(self, 宏观: List[str], 中观: List[str], 微观: List[str]) -> Dict[str, any]:
        """
        校验用户给出的排序是否符合协议心脏。
        宏观：人民 > 国家 > 集体 > 个人
        中观：忠 > 孝 > 义
        微观：人 > 地 > 天
        """
        标准宏观 = ["人民", "国家", "集体", "个人"]
        标准中观 = ["忠", "孝", "义"]
        标准微观 = ["人", "地", "天"]

        def 检查(实际, 标准):
            return 实际 == 标准

        return {
            "宏观_立国": {"标准": 标准宏观, "实际": 宏观, "通过": 检查(宏观, 标准宏观)},
            "中观_立身": {"标准": 标准中观, "实际": 中观, "通过": 检查(中观, 标准中观)},
            "微观_立事": {"标准": 标准微观, "实际": 微观, "通过": 检查(微观, 标准微观)},
            "总体": 检查(宏观, 标准宏观) and 检查(中观, 标准中观) and 检查(微观, 标准微观),
        }

    # ---------- 协议固化（只追加） ----------
    def 固化协议(self, 协议文本: str, 输出路径: str = "CNSH_排序不动点_固化.txt") -> Dict[str, any]:
        """
        把协议原文与国密哈希绑定，生成不可篡改的固化文件。
        不修改原文，只追加审计尾巴。
        """
        协议哈希 = self._计算SM3(协议文本)
        DNA = self._生成DNA("PROTOCOL-SEAL", 协议哈希)
        签名 = hmac_sm3(self.护弱密钥, 协议文本)
        时间戳 = datetime.now(timezone.utc).isoformat()

        固化块 = f"""
{'='*60}
CNSH 协议固化区 · 只追加 · 不覆盖 · 不篡改
协议 DNA: #龍芯⚡️2026-04-19-ORDER-ANCHOR-v1.0
确认码: #CONFIRM🌌9622-ONLY-ONCE🧬LK9X-772Z ✅
GPG指纹: A2D0092CEE2E5BA87035600924C3704A8CC26D5F
固化时间: {时间戳}
协议 SM3 哈希: {协议哈希}
HMAC-SM3 签名: {签名}
{DNA}
{'='*60}
"""
        输出 = Path(输出路径)
        if 输出.exists():
            输出内容 = 输出.read_text(encoding="utf-8")
        else:
            输出内容 = 协议文本

        输出内容 = 输出内容.rstrip() + "\n" + 固化块 + "\n"
        with open(输出, "w", encoding="utf-8") as f:
            f.write(输出内容)

        return {
            "输出路径": str(输出),
            "协议SM3哈希": 协议哈希,
            "HMAC_SM3签名": 签名,
            "DNA": DNA,
        }

    # ---------- 报告生成 ----------
    def 生成报告(self, 结果: 决策结果) -> str:
        行 = []
        行.append("╔" + "═" * 60 + "╗")
        行.append("║" + " " * 14 + "CNSH 排序不动点决策报告" + " " * 19 + "║")
        行.append("╠" + "═" * 60 + "╣")
        行.append(f"║ 决策名称: {结果.名称:<47} ║")
        行.append(f"║ 最终三色: {结果.三色.value:<47} ║")
        行.append(f"║ 综合得分: {结果.综合得分:<47} ║")
        行.append(f"║ 决策结论: {结果.决策:<47} ║")
        行.append(f"║ 输入 SM3: {结果.输入SM3哈希[:40]:<47} ║")
        行.append(f"║ 决策 DNA: {结果.DNA:<47} ║")
        行.append("╠" + "═" * 60 + "╣")
        行.append(f"║ 第一审·人心: {结果.人心审结果['等级']} {'; '.join(结果.人心审结果['红线']):<35} ║")
        行.append(f"║ 第二审·天地: {结果.天地审结果['等级']} R={结果.天地审结果['R分数']:<44} ║")
        行.append(f"║ 第三审·民利: {结果.民利审结果['等级']} 比={结果.民利审结果['收益损失比']:<42} ║")
        行.append("╚" + "═" * 60 + "╝")
        return "\n".join(行)


# ============== 演示 ==============
if __name__ == "__main__":
    引擎 = CNSH_排序不动点引擎()

    print("=" * 60)
    print("CNSH 排序不动点协议引擎 · 演示")
    print("=" * 60)

    # 演示1：正常决策（绿）
    输入1 = 决策输入(
        名称="建设乡村数字图书馆",
        全球收益=1000.0,
        群体损失=50.0,
        涉及弱者=False,
        人民排序分=1.0,
        国家排序分=0.9,
        个人排序分=0.1,
        忠排序分=1.0,
        孝排序分=0.8,
        义排序分=0.8,
        卦象权重=0.9,
        文化权重=0.95,
    )
    结果1 = 引擎.决策(输入1)
    print(引擎.生成报告(结果1))
    print()

    # 演示2：个人优先（红）
    输入2 = 决策输入(
        名称="卖用户数据换广告收益",
        全球收益=5000.0,
        群体损失=100.0,
        涉及弱者=True,
        弱者数量=1000000,
        人民排序分=0.2,
        国家排序分=0.3,
        个人排序分=0.9,
        忠排序分=0.3,
        孝排序分=0.8,
        义排序分=0.5,
        卦象权重=0.5,
        文化权重=0.5,
    )
    结果2 = 引擎.决策(输入2)
    print(引擎.生成报告(结果2))
    print()

    # 演示3：排序校验
    排序校验 = 引擎.校验三层排序(
        宏观=["人民", "国家", "集体", "个人"],
        中观=["忠", "孝", "义"],
        微观=["人", "地", "天"],
    )
    print("三层排序校验结果:")
    print(json.dumps(排序校验, ensure_ascii=False, indent=2))
    print()

    # 演示4：协议固化
    协议原文 = """
《道德经》第三十九章：「昔之得一者：天得一以清，地得一以宁，人得一以灵。」
一以贯之的那个「一」，就是排序。
人民第一 · 这就是排序的源头，也是排序的终点。
"""
    固化 = 引擎.固化协议(协议原文, "/tmp/CNSH_排序不动点_固化_demo.txt")
    print("协议固化完成:")
    print(json.dumps(固化, ensure_ascii=False, indent=2))

    print("\nDNA: #龍芯⚡️2026-04-19-ORDER-ANCHOR-v1.0")