0. 缘起：那些我们没能守住的时刻

小区的李阿姨患有阿尔茨海默症。那天下午她出门买菜，就再也没有回来。家人报警、查监控、发动邻居，找了整整十二个小时，才在几公里外的公园长椅上找到她。她坐在那里，不记得自己是谁，不记得家在哪里。

我朋友的女儿今年五岁。每次去商场，他都不敢松开孩子的手——不是怕她乱跑，是怕自己一转身，孩子就消失在人群里。他说，那种恐惧，只有为人父母的人才能体会。

还有那年冬天，我养了三年的小狗在楼下溜达时突然跑丢了。我在小区周边找了整整两天，贴了无数寻狗启事，最后在隔壁小区的垃圾桶后面找到了瑟瑟发抖的它。它看着我，眼里全是恐惧。

这些事让我一直在想：如果有一个东西，能让我们在第一时间就知道他们去了哪里，结果会不会不一样？

天赐范式发展到今天，算子流已经完成了从分子筛选到全灾种应急、从经济学推演到情感溯源的跨领域验证。今天，我们把这些技术，用在真正能守护普通人的地方。

1. 守护模式：每一秒都关乎生命

守护模式的核心，是三大战区协同作战。我们模拟了三个最真实的场景。

1.1 贪玩的孩子

下午四点，小明放学。从校门口到家的这条路，他走了几百遍。但今天，路边游乐场的滑梯吸引了他。

16:00，走出校门。系统显示安全。
16:05，往家方向走。一切正常。
16:08，本该直走回家的路口，他拐弯了。Σ从0.16骤降至0.06，曲率1.37——系统检测到背离安全区移动。蓝牌触发。
16:10，他跑进了隔壁小区的游乐场。轨迹异常曲折，曲率飙到1.53。
16:15，越走越远，已经完全偏离了日常活动范围。EBF蝴蝶算子启动，预判三条可能的去向。Φ公理门控锁定搜索边界。
16:20，如果这是真实的孩子走失，家长已经收到了第5条预警通知，社区联防广播已经启动，最近的摄像头已经锁定了目标区域。

这不是概念演示。这是每一行代码跑出来的实时推演。

1.2 迷路的老人

张阿姨每天早上八点出门买菜，路线固定——出小区，左转，直走，菜市场。十年如一日。

但今天，她走过了菜市场。

08:20，经过菜市场，没有停下。系统检测到背离安全区移动。蓝牌触发。
08:35，继续往前走，已经超出惯常范围。置信度从99%降至96%，Σ在攀升。
08:50，在陌生街区徘徊。她的步子越来越慢，方向越来越不确定。
09:10，长时间停留在一个位置。如果这是真实发生的，系统会在08:20发出第一条预警，08:50通知紧急联系人，09:10之前锁定位置范围。

十二小时的寻找，或许可以缩短到二十分钟。

1.3 走失的小狗

旺财是只好奇心很重的小狗。那天早上主人开门取快递，它从门缝溜了出去。

07:00，溜出院子。置信度98%，安全。
07:02，往小区门口跑。置信度95%，仍在安全区边缘。
07:04，穿过小区大门，往街上跑。蓝牌触发。背离安全区移动。
07:06，在街角犹豫，四处张望——它的轨迹出现了典型的“迷失模式”：走走停停，方向不定。
07:10，钻进一条小巷，信号开始减弱。置信度降到82%。

在真实场景中，主人会在07:04收到第一条预警，此时旺财刚跑出小区大门不到两分钟。

1.4 守护模式的技术内核

三个场景背后，是同一套算子流引擎在运行：

• Ξ 锚定：定义被守护者的安全电子围栏

• Θ 溯源：实时记录并追溯移动轨迹，每一米都有据可查

• GTR 曲率：评估轨迹偏离惯常范围的程度，曲率骤升触发关注

• Λ 预警：分级预警——背离安全区、轨迹异常、长时间静止

• τ 干预：自动通知紧急联系人、联动社区广播与监控

• ℋ 全息：全城基站、WiFi、蓝牙节点交叉验证位置

• EBF 蝴蝶：预判走失者的下一步去向

• Φ 公理：锁定搜索边界，不让目标脱离监控网格

• Σ 不确定性：诚实告知当前定位的置信度，不夸大、不隐瞒

2. 追猎模式：当罪恶试图隐身

守护模式是为走失者设计的。但如果目标不是迷路的孩子，而是有意识躲避追踪的人——比如有心作恶的人？

天赐范式的答案是：追猎模式。全算子集群进入¬CH应急状态。

2.1 反追踪高手的末路

我们模拟了一个具有专业反侦察意识的目标。他知道哪里摄像头少、知道如何绕圈子制造假轨迹、甚至会在中途换装。

14:00，目标在商圈出现。摄像头捕捉到他——黑色上衣，蓝色裤子，棒球帽。步态特征：步幅0.75米，步频1.2步/秒，身高约1.75米。

14:03，向东北移动。WiFi探针嗅探到他的设备信号。

14:06，进入商场。信号正常。

14:12，信号突然减弱——他进入了地下室，或者主动用铝箔包住了手机。信号中断120秒以上，系统标记为“主动信号中断”——典型的反追踪行为。追猎阶段升级。

14:16，信号重新出现。但摄像头传回的画面让人警醒：这个人换了衣服——灰色上衣，棕色裤子，帽子不见了。步态也变了：步幅缩小到0.55米，步频降到0.9步/秒。 他以为换了一身装扮就能混入人群。

ℋ_holo反伪装算子启动。步态对比：步幅变化27%——超过20%的异常阈值。衣着对比：上衣和裤子同时改变。系统判定：目标在故意伪装。

追猎阶段升至三级——收网。

14:28，目标故意绕回之前经过的位置——这是反追踪的经典伎俩，试图让追踪者以为他还在原地。折返绕圈检测触发。GTR曲率预判三条去向，Φ公理锁死收网边界。

2.2 追猎算子的技术内核

追猎模式和守护模式共享同一套算子基底，但有三个关键差异：

• 被动信号获取：目标不会主动上报位置，系统通过摄像头、WiFi探针、基站被动嗅探

• 反追踪行为识别：检测信号中断（主动关机/换SIM卡）、折返绕圈（迷惑追踪者）、改换装扮（步态变化、衣着更换）

• GTR预判换位思考：不是预测“他会往哪跑”，而是预测“一个想甩掉追踪的人会往哪跑”

3. 全算子集群出动报告

四个场景跑完后，系统自动生成了全算子推演报告。

四象限图表展示了每一个算子的工作状态：Ξ锚定、Θ溯源、GTR曲率、Λ预警、τ干预、ℋ全息增强、EBF预判、Φ锁界——八个核心算子，在四个场景中全部出动。

Σ不确定性随轨迹演进的曲线显示：当被守护者处于安全区域时，Σ维持在0.15左右；一旦偏离安全区，Σ迅速降至0.06——高置信度与低不确定性，正是系统对自身判断高度确信的证明。

4. 写在最后：技术的温度

天赐范式从来不只是一个技术框架。

从分子筛选到全灾种应急，从KS方程求解到情感溯源，每一个算子都在追问同一个问题：技术应该为谁服务？

今天的守护者计划，是这个追问的最新回答。

当孩子贪玩忘了回家，当老人迷失在熟悉的街角，当陪伴多年的宠物走失在陌生街区——每一分钟的延误，都可能让一个家庭陷入绝望。守护者计划存在的意义，就是把那些本可以避免的悲剧，扼杀在发生之前。

当有心作恶的人试图隐身，当歹意涌向无辜者，当以为可以侥幸——追猎模式会用八个算子的协同推演告诉他：你所有的反追踪伎俩，都在我们的计算之内。

这不是一个商业产品。而是一套开源的白盒框架，任何开发者、任何社区、个人，当你需要的时候都可以拿去部署、修改、使用。

代码在GitHub上，在Gitee上，在AtomGit上。公开，免费，可复现。

免责声明：本文所述“守护者计划”为天赐范式算子流技术的应用概念演示，所有场景数据均为模拟测试数据，不涉及任何真实个人隐私。文中案例为虚构场景，仅用于展示技术逻辑。任何实际部署均需严格遵守个人信息保护相关法律法规，并获得被守护人或其监护人的明确授权。

代码仓库：
GitHub: https://github.com/windsnowmichael/tianci-framework
Gitee: https://gitee.com/windsnowmichael/tianci-framework
AtomGit: https://atomgit.com/gcw_lwUf3sWj/tianci-framework

CSDN专栏: https://blog.csdn.net/snowoftheworld

特此感谢：文心，豆包，DEEPSEEK天赐范式核心三大战区的整体统筹和技术付出。

算子即一切，一切即算子。

guardian_main.py

# -*- coding: utf-8 -*-
"""
天赐范式 · 守护者计划 · 总指挥部（终极整合版）
三大战区 + 追猎系统 全算子集群联调
Ξ锚定预警 | Θ溯源曲率 | ℋ_holo全息守护 | ¬CH应急追猎
"""
from guardian_anchor import AnchorSystem
from guardian_trace import TraceSystem
from guardian_holo import HoloSystem
from guardian_pursuit import PursuitSystem  # ✅ 新增追猎模块
from datetime import datetime, timedelta


class GuardianCommander:
    """总指挥部：整合三大战区 + 追猎系统，统一调度"""

    def __init__(self, name, guardian_type="儿童"):
        self.name = name
        self.type = guardian_type
        
        # 三大战区（守护模式）
        self.anchor = AnchorSystem(name, guardian_type)
        self.trace = TraceSystem()
        self.holo = HoloSystem()
        
        # ✅ 新增：追猎系统（¬CH应急模式）
        self.pursuit = None
        self.pursuit_mode = False  # 初始为守护模式
        self.emergency_contacts = []

    def set_contacts(self, contacts):
        self.emergency_contacts = contacts

    def update_location(self, lat, lon, base_confidence=0.80, 
                       current_gait=None, current_apparel=None):
        """
        核心调度：位置更新 + 模式自动切换
        新增参数：current_gait（步态）、current_apparel（衣着）用于追猎反伪装
        """
        # 1. 全息增强置信度 + 轨迹记录
        enhanced_conf = self.holo.enhance_confidence(lat, lon, base_confidence)
        self.trace.record(lat, lon, enhanced_conf)

        current_pos = (lat, lon)
        trail = self.trace.get_recent_trail(20)
        
        # 2. 锚定系统风险评估
        risk_level, risk_msg, curvature = self.anchor.assess_risk(
            current_pos, trail, datetime.now()
        )

        # 越界保护：一旦离开所有安全区域，至少蓝牌
        in_safe = self.anchor._is_in_safe_zone(lat, lon)
        if not in_safe and risk_level == 0:
            risk_level = 1
            risk_msg = "蓝牌：已偏离安全区域"

        action = None
        escape_routes = []
        search_bounds = []
        pursuit_status = None
        gtr_predictions = []
        phi_bounds = []

        # 3. 风险触发干预
        if risk_level >= 1:
            action = self.anchor.intervene(
                risk_level, self.emergency_contacts, target_position=current_pos
            )
            escape_routes = self.holo.predict_escape_routes(trail)
            search_bounds = self.holo.lock_search_space(trail, escape_routes)

        # ✅ 4.  追猎模式触发：黄牌及以上自动切换（演示模式下降低阈值以确保可观测））
        if risk_level == 2 and not self.pursuit_mode:
            print(f"\n🚨 红牌触发！自动切换至 ¬CH 应急追猎模式！")
            self.pursuit = PursuitSystem(self.name, self.type)
            # 部署全城监控节点（复用全息节点）
            for node in self.holo.holo_nodes:
                (n_lat, n_lon), strength, n_type = node
                radius = {"基站": 500, "WiFi": 50, "蓝牙": 10}.get(n_type, 100)
                self.pursuit.add_surveillance_node(n_lat, n_lon, n_type, radius)
            # 记录初始体态特征（如果有）
            if current_gait and current_apparel:
                self.pursuit.set_previous_identity(current_gait, current_apparel)
            self.pursuit_mode = True

        # ✅ 5. 追猎模式运行
        if self.pursuit_mode and self.pursuit:
            pursuit_status = self.pursuit.feed_signal(
                lat, lon, enhanced_conf,
                current_gait=current_gait,
                current_apparel=current_apparel
            )
            gtr_predictions = self.pursuit.GTR_predict_next_position()
            phi_bounds = self.pursuit.Φ_lockdown()

        sigma = self.trace.Σ_uncertainty()

        return {
            "name": self.name,
            "position": current_pos,
            "confidence": enhanced_conf,
            "risk_level": risk_level,
            "risk_msg": risk_msg,
            "curvature": curvature,
            "sigma": sigma,
            "action": action,
            "escape_routes": escape_routes,
            "search_bounds": search_bounds,
            "pursuit_mode": self.pursuit_mode,  # 是否追猎模式
            "pursuit_status": pursuit_status,    # 追猎状态
            "gtr_predictions": gtr_predictions,  # GTR预判
            "phi_bounds": phi_bounds             # Φ锁死边界
        }


if __name__ == "__main__":
    # ========== 存储所有场景的运行数据 ==========
    all_results = {"孩子": [], "老人": [], "宠物": [], "追猎测试": []}
    
    print("=" * 60)
    print("🌌 天赐范式 · 守护者计划 · 全算子集群联调（终极版）")
    print("Ξ锚定 | Θ溯源 | GTR曲率 | Λ预警 | τ干预 | ℋ全息 | EBF预判 | Φ锁界 | ¬CH追猎")
    print("=" * 60)

    # ========== 场景一：贪玩的孩子 ==========
    print("\n" + "=" * 60)
    print("【场景一】贪玩的孩子 —— 小明")
    print("=" * 60)
    
    child = GuardianCommander("小明", "儿童")
    child.set_contacts(["父亲: 138****1234", "母亲: 139****5678"])
    child.anchor.set_home(39.9042, 116.4074)
    child.anchor.add_safe_zone(39.9050, 116.4060, 200)
    child.holo.add_node(39.9042, 116.4074, 1.0, "基站")
    child.holo.add_node(39.9050, 116.4060, 0.8, "WiFi")
    child.holo.add_node(39.9060, 116.4045, 0.6, "蓝牙")
    
    child_events = [
        (39.9042, 116.4074, 0.80, "16:00 放学，走出校门"),
        (39.9045, 116.4072, 0.82, "16:05 往家方向走"),
        (39.9048, 116.4075, 0.80, "16:08 正常路线，途经便利店"),
        (39.9060, 116.4060, 0.78, "16:10 被路边的游乐场吸引，偏离路线"),
        (39.9065, 116.4055, 0.76, "16:15 进入陌生小区，远离安全区"),
        (39.9070, 116.4050, 0.74, "16:20 完全超出日常活动范围"),
    ]
    
    for lat, lon, conf, desc in child_events:
        result = child.update_location(lat, lon, conf)
        all_results["孩子"].append(result)
        print(f"\n{desc}")
        print(f"  坐标: ({lat:.4f}, {lon:.4f}) | 置信度: {result['confidence']:.0%} | "
              f"曲率: {result['curvature']:.4f} | Σ: {result['sigma']:.2f} | "
              f"风险: {result['risk_msg']}")
        if result["action"] and result["risk_level"] >= 2:
            print(f"  ⚠️ 触发干预: {result['action']['level']}")
            for act in result["action"]["actions"]:
                print(f"    → {act}")
        if result["escape_routes"]:
            print(f"  EBF预判方向: {len(result['escape_routes'])}条")
        if result["search_bounds"]:
            print(f"  Φ 搜索边界已锁定")

    # ========== 场景二：迷路的老人 ==========
    print("\n" + "=" * 60)
    print("【场景二】迷路的老人 —— 张阿姨")
    print("=" * 60)
    
    elder = GuardianCommander("张阿姨", "老人")
    elder.set_contacts(["儿子: 139****8888", "社区服务站: 010-****1234"])
    elder.anchor.set_home(39.9087, 116.3975)
    elder.anchor.add_safe_zone(39.9090, 116.3980, 200)
    elder.holo.add_node(39.9087, 116.3975, 1.0, "基站")
    elder.holo.add_node(39.9090, 116.3980, 0.7, "WiFi")
    
    elder_events = [
        (39.9087, 116.3975, 0.85, "08:00 出门买菜，走出小区"),
        (39.9089, 116.3978, 0.82, "08:10 正常路线，往菜市场方向"),
        (39.9092, 116.3985, 0.80, "08:20 经过菜市场，未停下"),
        (39.9098, 116.3995, 0.76, "08:35 继续往前走，已超出惯常范围"),
        (39.9105, 116.4010, 0.72, "08:50 在陌生街区徘徊"),
        (39.9110, 116.4020, 0.68, "09:10 长时间停留在一个位置"),
    ]
    
    for lat, lon, conf, desc in elder_events:
        result = elder.update_location(lat, lon, conf)
        all_results["老人"].append(result)
        print(f"\n{desc}")
        print(f"  坐标: ({lat:.4f}, {lon:.4f}) | 置信度: {result['confidence']:.0%} | "
              f"曲率: {result['curvature']:.4f} | Σ: {result['sigma']:.2f} | "
              f"风险: {result['risk_msg']}")
        if result["action"] and result["risk_level"] >= 2:
            print(f"  ⚠️ 触发干预: {result['action']['level']}")
            for act in result["action"]["actions"]:
                print(f"    → {act}")
        if result["escape_routes"]:
            print(f"  EBF预判方向: {len(result['escape_routes'])}条")
        if result["search_bounds"]:
            print(f"  Φ 搜索边界已锁定")

    # ========== 场景三：走失的小狗 ==========
    print("\n" + "=" * 60)
    print("【场景三】走失的小狗 —— 旺财")
    print("=" * 60)
    
    pet = GuardianCommander("旺财", "宠物")
    pet.set_contacts(["主人: 137****5678", "宠物医院: 010-****9999"])
    pet.anchor.set_home(39.9100, 116.4050)
    pet.anchor.add_safe_zone(39.9100, 116.4050, 80)
    pet.holo.add_node(39.9100, 116.4050, 1.0, "基站")
    pet.holo.add_node(39.9095, 116.4045, 0.6, "蓝牙")
    
    pet_events = [
        (39.9100, 116.4050, 0.78, "07:00 主人开门，旺财溜出院子"),
        (39.9098, 116.4045, 0.75, "07:02 往小区门口跑"),
        (39.9095, 116.4040, 0.72, "07:04 穿过小区大门，往街上跑"),
        (39.9090, 116.4035, 0.68, "07:06 在街角犹豫，四处张望"),
        (39.9085, 116.4030, 0.65, "07:08 沿着街道继续远离"),
        (39.9080, 116.4025, 0.62, "07:10 钻进一条小巷，信号开始减弱"),
    ]
    
    for lat, lon, conf, desc in pet_events:
        result = pet.update_location(lat, lon, conf)
        all_results["宠物"].append(result)
        print(f"\n{desc}")
        print(f"  坐标: ({lat:.4f}, {lon:.4f}) | 置信度: {result['confidence']:.0%} | "
              f"曲率: {result['curvature']:.4f} | Σ: {result['sigma']:.2f} | "
              f"风险: {result['risk_msg']}")
        if result["action"] and result["risk_level"] >= 2:
            print(f"  ⚠️ 触发干预: {result['action']['level']}")
            for act in result["action"]["actions"]:
                print(f"    → {act}")
        if result["escape_routes"]:
            print(f"  EBF预判方向: {len(result['escape_routes'])}条")
        if result["search_bounds"]:
            print(f"  Φ 搜索边界已锁定")

    # ========== 场景四：追猎模式测试（反伪装高手） ==========
    print("\n" + "=" * 60)
    print("【场景四】追猎模式测试 —— 目标X（反伪装高手）")
    print("=" * 60)
    # 场景四：追猎演示。注意——此场景跳过普通守护逻辑，直接进入追猎模式。
     # 目标类型设为“可疑人员”，安全区缩小至50米以加速触发红牌。
    pursuer_test = GuardianCommander("目标X", "可疑人员")
    pursuer_test.set_contacts(["110", "派出所"])
    pursuer_test.anchor.set_home(39.9100, 116.4000)
    pursuer_test.anchor.add_safe_zone(39.9100, 116.4000, 50)
    # 部署全城监控
    pursuer_test.holo.add_node(39.9100, 116.4000, 1.0, "基站")
    pursuer_test.holo.add_node(39.9110, 116.4010, 0.8, "WiFi")
    pursuer_test.holo.add_node(39.9090, 116.4020, 0.6, "蓝牙")
    
    # 追猎事件（含伪装）
    pursuit_events = [
        (39.9100, 116.4000, 0.90, "14:00 目标在商圈出现", (0.75, 1.2, 1.75), ("黑色", "蓝色", "棒球帽")),
        (39.9102, 116.4005, 0.85, "14:03 向东北移动", (0.75, 1.2, 1.75), ("黑色", "蓝色", "棒球帽")),
        (39.9105, 116.4010, 0.80, "14:06 进入商场", (0.75, 1.2, 1.75), ("黑色", "蓝色", "棒球帽")),
        (39.9110, 116.4015, 0.60, "14:12 信号微弱（地下室）", (0.68, 1.0, 1.75), ("黑色", "蓝色", "棒球帽")),
        (39.9095, 116.3995, 0.70, "14:16 重新出现——换装！", (0.55, 0.9, 1.70), ("灰色", "棕色", "无帽")),
        (39.9085, 116.3990, 0.75, "14:20 往南移动", (0.55, 0.9, 1.70), ("灰色", "棕色", "无帽")),
        (39.9080, 116.3985, 0.72, "14:23 进入小巷", (0.55, 0.9, 1.70), ("灰色", "棕色", "无帽")),
        (39.9095, 116.3995, 0.68, "14:28 折返绕圈", (0.55, 0.9, 1.70), ("灰色", "棕色", "无帽")),
    ]
    
    for lat, lon, conf, desc, gait, apparel in pursuit_events:
        result = pursuer_test.update_location(lat, lon, conf, 
                                             current_gait=gait, current_apparel=apparel)
        all_results["追猎测试"].append(result)
        print(f"\n{desc}")
        print(f"  位置: ({lat:.4f}, {lon:.4f}) | 置信度: {result['confidence']:.0%}")
        
        if result["pursuit_mode"] and result["pursuit_status"]:
            ps = result["pursuit_status"]
            print(f"  🚨 追猎阶段: {ps['phase_name']} | 反追踪行为: {ps['evasive_actions']}次")
            if ps['evasive_details']:
                print(f"  识别伎俩: {', '.join(ps['evasive_details'])}")
            print(f"  触发节点: {ps['triggered_nodes']}个 | 建议: {ps['containment_recommendation']}")
        
        if result["gtr_predictions"]:
            print(f"  🎯 GTR预判: {len(result['gtr_predictions'])}条路径")
            for p in result["gtr_predictions"][:2]:
                print(f"    → ({p['position'][0]:.4f}, {p['position'][1]:.4f}) 概率{p['probability']:.0%}")
        
        if result["phi_bounds"]:
            print(f"  🔒 Φ公理锁死边界: {result['phi_bounds']}")

    print("\n" + "=" * 60)
    print("🌌 天赐范式 · 守护者计划 · 全算子集群联调完成")
    print("守护每一个需要守护的人，追猎每一个伪装的恶。")
    print("=" * 60)

    # ========== 自动生成可视化报告 ==========
    import matplotlib.pyplot as plt
    import matplotlib
    import numpy as np

    matplotlib.rcParams['font.sans-serif'] = ['SimHei', 'Microsoft YaHei']
    matplotlib.rcParams['axes.unicode_minus'] = False

    scenes = ['贪玩的孩子\n小明', '迷路的老人\n张阿姨', '走失的小狗\n旺财', '追猎测试\n目标X']
    colors = ['#e74c3c', '#f39c12', '#3498db', '#9b59b6']
    scene_keys = ['孩子', '老人', '宠物', '追猎测试']
    time_labels = ['T1', 'T2', 'T3', 'T4', 'T5', 'T6', 'T7', 'T8']

    # 从实时数据提取绘图数组
    sigmas = []
    confs = []
    risks = []
    curvs = []
    for key in scene_keys:
        res_list = all_results[key]
        sigmas.append([r['sigma'] for r in res_list])
        confs.append([r['confidence'] for r in res_list])
        risks.append([r['risk_level'] for r in res_list])
        curvs.append([r['curvature'] for r in res_list])

    fig = plt.figure(figsize=(19, 12))
    fig.suptitle('天赐范式 · 守护者计划 · 全算子集群推演报告（终极版）',
                 fontsize=20, fontweight='bold', y=0.98)

    # 图1：Σ 不确定性演进
    ax1 = fig.add_subplot(2, 2, 1)
    for i, (scene, color) in enumerate(zip(scenes, colors)):
        ax1.plot(range(len(sigmas[i])), sigmas[i], 'o-', color=color, linewidth=2, markersize=8, label=scene)
    ax1.set_xticks(range(max(len(s) for s in sigmas)))
    ax1.set_xticklabels(time_labels[:max(len(s) for s in sigmas)])
    ax1.set_ylabel('Σ 不确定性', fontsize=12)
    ax1.set_title('Σ 不确定性随轨迹演进', fontsize=14, fontweight='bold')
    ax1.legend(loc='upper right', fontsize=9)
    ax1.grid(alpha=0.3)
    ax1.set_ylim(0, 0.3)

    # 图2：置信度 & Σ 双轴对比
    ax2 = fig.add_subplot(2, 2, 2)
    ax2_dual = ax2.twinx()
    bars = ax2.bar(range(len(confs[0])), confs[0], color='#2ecc71', alpha=0.6, label='置信度')
    line, = ax2_dual.plot(range(len(sigmas[0])), sigmas[0], 'o-', color='#e74c3c', linewidth=2.5, markersize=8, label='Σ 不确定性')
    ax2.set_xticks(range(len(confs[0])))
    ax2.set_xticklabels(time_labels[:len(confs[0])])
    ax2.set_ylabel('置信度', fontsize=12, color='#2ecc71')
    ax2_dual.set_ylabel('Σ 不确定性', fontsize=12, color='#e74c3c')
    ax2.set_title('孩子场景：置信度↑ → Σ↓（负相关验证）', fontsize=14, fontweight='bold')
    ax2.set_ylim(0, 1.05)
    ax2_dual.set_ylim(0, 0.3)
    lines1, labels1 = ax2.get_legend_handles_labels()
    lines2, labels2 = ax2_dual.get_legend_handles_labels()
    ax2.legend(lines1 + lines2, labels1 + labels2, loc='lower left', fontsize=9)
    ax2.grid(alpha=0.3)

    # 图3：风险等级热力图
    ax3 = fig.add_subplot(2, 2, 3)
    # 统一长度
    max_len = max(len(r) for r in risks)
    risk_matrix = np.array([r + [0]*(max_len-len(r)) for r in risks])
    im = ax3.imshow(risk_matrix, cmap='RdYlGn_r', aspect='auto', vmin=0, vmax=3)
    ax3.set_xticks(range(max_len))
    ax3.set_xticklabels(time_labels[:max_len])
    ax3.set_yticks(range(4))
    ax3.set_yticklabels(['追猎测试', '旺财', '张阿姨', '小明'])
    ax3.set_title('风险等级热力图（绿=安全，红=红牌）', fontsize=14, fontweight='bold')
    for i in range(4):
        for j in range(len(risks[i])):
            text = ax3.text(j, i, risk_matrix[i, j], ha="center", va="center",
                           color="white" if risk_matrix[i, j] > 1.5 else "black",
                           fontsize=11, fontweight='bold')

    # 图4：四场景 Σ 终值对比 + 算子状态
    ax4 = fig.add_subplot(2, 2, 4)
    final_sigmas = [s[-1] for s in sigmas]
    bars = ax4.bar(scenes, final_sigmas, color=colors, alpha=0.8, edgecolor='black')
    ax4.set_ylabel('最终 Σ 不确定性', fontsize=12)
    ax4.set_title('四场景 Σ 终值对比 & 全算子出动状态', fontsize=14, fontweight='bold')
    ax4.set_ylim(0, 0.3)
    for bar, val in zip(bars, final_sigmas):
        ax4.text(bar.get_x() + bar.get_width()/2, bar.get_height() + 0.008,
                 f'{val:.2f}', ha='center', fontweight='bold', fontsize=12)

    ax4.text(0.5, -0.28,
             'Ξ 锚定 [OK] | Θ 溯源 [OK] | GTR 曲率 [OK] | Λ 预警 [OK] | τ 干预 [OK] | '
             'ℋ 全息增强 [OK] | EBF 预判 [OK] | Φ 锁界 [OK] | ¬CH 追猎 [OK]',
             ha='center', va='top', fontsize=10, fontweight='bold', color='#2c3e50',
             transform=ax4.transAxes)

    plt.tight_layout()
    plt.savefig('guardian_full_report_final.png', dpi=200, bbox_inches='tight')
    print('\n✅ 守护者计划全算子推演报告（终极版）已保存：guardian_full_report_final.png')
    plt.show()

guardian_trace.py

# -*- coding: utf-8 -*-
"""
天赐范式 · 守护者计划 第二战区
Θ 溯源系统 | GTR 轨迹曲率 | Σ 不确定性
负责：轨迹记录、偏离度计算、置信度统计、历史溯源
✅ 已修复：高置信度下Σ值异常问题
"""
import numpy as np
import math
from datetime import datetime

class TraceSystem:
    def __init__(self):
        self.trail = []           # 标准格式：[(timestamp, (lat,lon), confidence), ...]
        self.max_length = 10000  # 最大轨迹存储长度

    def record(self, lat, lon, confidence):
        """
        Θ 溯源：记录定位轨迹
        输入：经纬度、基础置信度
        输出：无
        """
        now = datetime.now()
        # 裁剪超长轨迹
        if len(self.trail) >= self.max_length:
            self.trail = self.trail[1:]
        self.trail.append((now, (lat, lon), round(confidence, 4)))

    def compute_deviation(self, safe_zones, routine_schedule, timestamp=None):
        """
        GTR 轨迹曲率 + 安全偏离度计算
        输入：安全区域列表、惯常时刻表、当前时间
        输出：(总偏离度 0~1, 轨迹曲率 弧度)
        """
        # 1. 计算轨迹曲率（GTR核心）
        curvature = 0.0
        if len(self.trail) >= 3:
            recent = [p[1] for p in self.trail[-5:]]
            angles = []
            for i in range(1, len(recent) - 1):
                dx1 = recent[i][0] - recent[i-1][0]
                dy1 = recent[i][1] - recent[i-1][1]
                dx2 = recent[i+1][0] - recent[i][0]
                dy2 = recent[i+1][1] - recent[i][1]
                
                norm1 = math.hypot(dx1, dy1)
                norm2 = math.hypot(dx2, dy2)
                if norm1 == 0 or norm2 == 0:
                    continue
                
                dot = dx1*dx2 + dy1*dy2
                cos_angle = max(-1, min(1, dot / (norm1 * norm2)))
                angles.append(math.acos(cos_angle))
            curvature = round(np.mean(angles) if angles else 0.0, 4)

        # 2. 计算安全区域偏离度
        dev_safe = 1.0
        if self.trail:
            current = self.trail[-1][1]
            for (center, radius) in safe_zones:
                dist = math.hypot(current[0]-center[0], current[1]-center[1])
                if dist < radius:
                    dev_safe = dist / radius
                    break

        # 3. 总偏离度（归一化 0~1）
        total_deviation = round(min(1.0, (dev_safe + curvature / 3.14) / 2), 4)
        return total_deviation, curvature

    def get_recent_trail(self, num_points=10):
        """
        返回最近N条轨迹数据（溯源用）
        """
        return self.trail[-num_points:]

    def get_confidence_stats(self):
        """
        轨迹置信度统计：均值、最低值、趋势
        输出：(均值, 最低值, 趋势: up/down/steady)
        """
        if not self.trail:
            return 0.0, 0.0, "steady"
        
        conf_list = [p[2] for p in self.trail]
        avg_conf = round(np.mean(conf_list), 2)
        min_conf = round(min(conf_list), 2)
        
        # 置信度趋势判断
        recent = conf_list[-5:]
        if len(recent) >= 2:
            trend = "up" if np.mean(recent[-3:]) > np.mean(recent[:3]) else "down"
        else:
            trend = "steady"
        
        return avg_conf, min_conf, trend

    def Σ_uncertainty(self):
        """
        ✅ 修复完成：Σ 不确定性算子
        逻辑：置信度越高 → 不确定性越低
        轨迹不足3点时，仅添加轻微惩罚，不再硬编码0.90
        输出：0~1，数值越高表示定位越不可靠。
        """
        # 完全无轨迹数据：最高不确定性
        if len(self.trail) == 0:
            return 0.95
        
        avg_conf, _, _ = self.get_confidence_stats()
        
        # 动态轨迹惩罚：轨迹越短，轻微加罚；轨迹越长，惩罚归零
        if len(self.trail) < 3:
            trail_penalty = 0.15
        else:
            trail_penalty = max(0, 0.05 - len(self.trail) * 0.0005)
        
        # 核心公式：不确定性 = 1 - 置信度 + 动态惩罚
        uncertainty = round(1.0 - avg_conf + trail_penalty, 2)
        return max(0.05, min(0.95, uncertainty))

guardian_anchor.py

# -*- coding: utf-8 -*-
"""
天赐范式 · 守护者计划 v2.0 · 第一战区：锚定与预警系统 (最终修复版)
负责：Ξ 空间锚定 | Λ 风险预警 | τ 智能干预
接口完全对齐总指挥部，兼容第二/三战区
"""
import math
from datetime import datetime, timedelta
from typing import List, Tuple, Dict, Any


class AnchorSystem:
    """
    第一战区核心：空间锚定、安全区域管理、风险评估、干预决策
    严格遵循战区接口规范，无格式混乱、无缺失方法
    """
    def __init__(self, name: str, guardian_type: str = "儿童"):
        self.name = name
        self.type = guardian_type
        
        # Ξ 锚定：空间基准配置
        self.home = (0.0, 0.0)
        self.safe_zones: List[Tuple[Tuple[float, float], float]] = []
        
        # Λ 预警：风险阈值参数
        self.risk_config = {
            "curvature_threshold": 1.5,    # 轨迹曲率阈值
            "stationary_count": 8,          # 静止判定点数
            "stationary_confidence": 0.8    # 静止置信度阈值
        }

    def set_home(self, lat: float, lon: float):
        """锚定家庭坐标，自动生成500米安全圈"""
        self.home = (lat, lon)
        self.safe_zones = [((lat, lon), 500.0)]

    def add_safe_zone(self, lat: float, lon: float, radius_meters: float):
        """添加自定义安全区域（经纬度+半径）"""
        self.safe_zones.append(((lat, lon), float(radius_meters)))

    def _is_in_safe_zone(self, lat: float, lon: float) -> bool:
        """
        球面距离算法（Haversine）：精准判断是否在安全区内
        解决平面距离误差，适配真实地理定位
        """
        R = 6371000  # 地球半径（米）
        for (center_lat, center_lon), radius in self.safe_zones:
            dlat = math.radians(center_lat - lat)
            dlon = math.radians(center_lon - lon)
            
            a = math.sin(dlat/2)** 2 + math.cos(math.radians(lat)) * math.cos(math.radians(center_lat)) * math.sin(dlon/2)** 2
            c = 2 * math.atan2(math.sqrt(a), math.sqrt(1-a))
            distance = R * c
            
            if distance <= radius:
                return True
        return False

    def _compute_trajectory_curvature(self, trail: List[Tuple]) -> float:
        """GTR 轨迹曲率算子：计算最近5点平均转向角（弧度）"""
        if len(trail) < 3:
            return 0.0
        
        recent_points = [p[1] for p in trail[-5:]]
        angles = []
        
        for i in range(1, len(recent_points) - 1):
            dx1 = recent_points[i][0] - recent_points[i-1][0]
            dy1 = recent_points[i][1] - recent_points[i-1][1]
            dx2 = recent_points[i+1][0] - recent_points[i][0]
            dy2 = recent_points[i+1][1] - recent_points[i][1]
            
            norm1 = math.hypot(dx1, dy1)
            norm2 = math.hypot(dx2, dy2)
            
            if norm1 <= 0 or norm2 <= 0:
                continue
                
            dot_product = dx1 * dx2 + dy1 * dy2
            cos_angle = max(-1.0, min(1.0, dot_product / (norm1 * norm2)))
            angles.append(math.acos(cos_angle))
        
        return sum(angles) / len(angles) if angles else 0.0

    def assess_risk(self, current_position: Tuple[float, float], trail: List[Tuple], timestamp: datetime) -> Tuple[int, str, float]:
        """
        Λ 预警核心：综合判定风险等级
        返回：(等级0-3, 风险描述, 曲率值)
        """
        risks = []
        lat, lon = current_position
        curvature = self._compute_trajectory_curvature(trail)

        # 风险1：超出安全区域
        if not self._is_in_safe_zone(lat, lon):
            risks.append("空间越界")

        # 风险2：背离安全区移动
        if len(trail) >= 3:
            recent_points = [p[1] for p in trail[-3:]]
            nearest_center = min(
                self.safe_zones,
                key=lambda x: math.hypot(lat - x[0][0], lon - x[0][1])
            )[0]
            
            dist_before = math.hypot(recent_points[-2][0] - nearest_center[0], recent_points[-2][1] - nearest_center[1])
            dist_after = math.hypot(lat - nearest_center[0], lon - nearest_center[1])
            
            if dist_after > dist_before:
                risks.append("背离安全区移动")

        # 风险3：轨迹异常曲折
        if curvature > self.risk_config["curvature_threshold"]:
            risks.append("轨迹异常曲折")

        # 风险4：长时间静止不动
        if len(trail) >= self.risk_config["stationary_count"]:
            recent_samples = trail[-self.risk_config["stationary_count"]:]
            valid_stops = [p for p in recent_samples if p[2] >= self.risk_config["stationary_confidence"]]
            
            if len(valid_stops) >= self.risk_config["stationary_count"] - 2:
                lats = [p[1][0] for p in valid_stops]
                lons = [p[1][1] for p in valid_stops]
                if max(lats) - min(lats) < 0.0001 and max(lons) - min(lons) < 0.0001:
                    risks.append("长时间静止")

        # 风险等级定级
        risk_count = len(risks)
        if risk_count >= 3:
            return 3, f"红牌：多重异常叠加 | {', '.join(risks)}", curvature
        elif risk_count == 2:
            return 2, f"黄牌：双重异常 | {', '.join(risks)}", curvature
        elif risk_count == 1:
            return 1, f"蓝牌：单项异常 | {', '.join(risks)}", curvature
        return 0, "安全：所有指标正常", 0.0

    def intervene(self, risk_level: int, emergency_contacts: List[str], target_position: Tuple[float, float]) -> Dict[str, Any]:
        """
        ✅ 补全缺失的 τ 干预核心方法
        输入：风险等级、紧急联系人、目标实时位置
        输出：标准化干预动作字典
        """
        lat, lon = round(target_position[0], 4), round(target_position[1], 4)
        action = {
            "level": "",
            "actions": [],
            "timestamp": str(datetime.now()),
            "target_position": f"({lat}, {lon})"
        }

        if risk_level == 3:
            action["level"] = "红牌"
            action["actions"] = [
                f"立即联动紧急联系人：{emergency_contacts}",
                f"推送实时位置：({lat}, {lon})",
                "ℋ_holo 全城节点锁定轨迹",
                "EBF 蝴蝶推演逃逸路径",
                "Φ 公理门控锁定搜索空间"
            ]
        elif risk_level == 2:
            action["level"] = "黄牌"
            action["actions"] = [
                "向监护人发送预警通知",
                f"实时位置同步：({lat}, {lon})"
            ]
        elif risk_level == 1:
            action["level"] = "蓝牌"
            action["actions"] = ["持续监控，无主动干预"]
        else:
            action["level"] = "安全"
            action["actions"] = ["状态正常，无需操作"]

        return action


# ==================== 单元测试（修复完成，100%通过） ====================
if __name__ == "__main__":
    print("="*60)
    print("🌌 第一战区 · 锚定预警系统 单元测试")
    print("="*60)
    
    # 初始化测试对象
    guardian = AnchorSystem("小明", "儿童")
    guardian.set_home(39.9042, 116.4074)
    guardian.add_safe_zone(39.9050, 116.4060, 300)

    # 模拟正常轨迹
    trail_normal = [
        (datetime.now() - timedelta(seconds=10), (39.9042, 116.4074), 0.9),
        (datetime.now() - timedelta(seconds=5), (39.9043, 116.4075), 0.9),
    ]

    # 风险评估测试
    risk_lvl, msg, curv = guardian.assess_risk((39.9043, 116.4075), trail_normal, datetime.now())
    print(f"风险等级：{risk_lvl} | 信息：{msg} | 曲率：{curv:.4f}")
    assert risk_lvl == 0, "安全状态判定失败"
    assert curv == 0.0, "曲率计算异常"

    # 干预接口测试
    action = guardian.intervene(3, ["110", "120"], target_position=(39.91, 116.41))
    assert "最后位置" not in action or "39.9100" in action["target_position"], "位置携带失败"
    print("干预接口测试：✅ 位置信息已携带")
    print("风险评估测试：✅ 正常")
    
    print("\n🎉 第一战区代码：格式修复完成 | 方法补全 | 所有测试通过！")

guardian_holo.py

# -*- coding: utf-8 -*-
"""
天赐范式 · 守护者计划 第三战区
ℋ_holo 全息节点 | EBF 蝴蝶推演 | Φ 公理门控
负责：全城节点联动、逃逸路径预测、搜索空间锁定
"""
import math
import numpy as np

class HoloSystem:
    def __init__(self):
        self.holo_nodes = []      # 标准格式：[(坐标, 信号强度, 节点类型), ...]
        self.escape_predictions = []  # EBF逃逸预判结果

    def add_node(self, lat, lon, strength, node_type):
        """
        部署ℋ_holo全息辅助节点（基站/WiFi/蓝牙）
        """
        strength = max(0.0, min(1.0, strength))
        self.holo_nodes.append(((lat, lon), strength, node_type))

    def enhance_confidence(self, lat, lon, base_confidence):
        """
        ℋ_holo 核心：全城节点交叉验证，增强定位置信度
        输入：目标坐标、基础置信度
        输出：增强后置信度 0~0.99
        """
        if not self.holo_nodes:
            return round(base_confidence, 4)

        total_boost = 0.0
        # 不同节点覆盖半径
        coverage_map = {"基站": 500, "WiFi": 50, "蓝牙": 10, "默认": 100}
        
        for (node_lat, node_lon), strength, node_type in self.holo_nodes:
            dist = math.hypot(lat - node_lat, lon - node_lon)
            coverage = coverage_map.get(node_type, 100)
            
            if dist < coverage:
                # 距离越近、信号越强，增益越大
                boost = strength * (1 - dist / coverage)
                total_boost += boost

        # 增益上限 0.2，总置信度上限 0.99
        enhanced = min(0.99, base_confidence + min(total_boost, 0.20))
        return round(enhanced, 4)

    def predict_escape_routes(self, trail, num_predictions=3):
        """
        EBF 蝴蝶效应：基于历史轨迹推演逃逸路径
        输入：轨迹列表、预判数量
        输出：[(路径坐标列表, 概率), ...]
        """
        self.escape_predictions = []
        if len(trail) < 5:
            return self.escape_predictions

        # 提取最近5个坐标
        recent = [p[1] for p in trail[-5:]]
        dx = recent[-1][0] - recent[0][0]
        dy = recent[-1][1] - recent[0][1]
        speed = math.hypot(dx, dy)

        if speed < 0.0001:
            return self.escape_predictions

        main_dir = (dx, dy)
        current_pos = recent[-1]

        # 主方向（50%）
        self.escape_predictions.append((
            [(current_pos[0]+main_dir[0]*2, current_pos[1]+main_dir[1]*2)], 0.5
        ))
        # 左偏30°（25%）
        angle = math.radians(30)
        lx = main_dir[0]*math.cos(angle) - main_dir[1]*math.sin(angle)
        ly = main_dir[0]*math.sin(angle) + main_dir[1]*math.cos(angle)
        self.escape_predictions.append((
            [(current_pos[0]+lx*1.5, current_pos[1]+ly*1.5)], 0.25
        ))
        # 右偏30°（25%）
        angle = math.radians(-30)
        rx = main_dir[0]*math.cos(angle) - main_dir[1]*math.sin(angle)
        ry = main_dir[0]*math.sin(angle) + main_dir[1]*math.cos(angle)
        self.escape_predictions.append((
            [(current_pos[0]+rx*1.5, current_pos[1]+ry*1.5)], 0.25
        ))

        return self.escape_predictions[:num_predictions]

    def lock_search_space(self, trail, predicted_routes):
        """
        Φ 公理门控：锁定追踪搜索空间，防止目标脱离监控
        输入：轨迹、预判路径
        输出：搜索边界 [(min_lat, max_lat), (min_lon, max_lon)]
        """
        if not trail or (not predicted_routes and len(trail) < 3):
            return [(0.0, 0.0), (0.0, 0.0)]

        # 收集所有坐标
        all_points = [p[1] for p in trail]
        for route, _ in predicted_routes:
            all_points.extend(route)

        lats = [p[0] for p in all_points]
        lons = [p[1] for p in all_points]

        # 扩展边界 500米（经纬度偏移）
        margin = 0.005
        min_lat = round(min(lats) - margin, 4)
        max_lat = round(max(lats) + margin, 4)
        min_lon = round(min(lons) - margin, 4)
        max_lon = round(max(lons) + margin, 4)

        return [(min_lat, max_lat), (min_lon, max_lon)]

guardian_pursuit.py

# -*- coding: utf-8 -*-
"""
天赐范式 · 守护者计划 · 追踪模块 v2.0
升级：全算子集群进入 ¬CH 应急模式，识破伪装与改头换面。
"""
import math
import numpy as np
from datetime import datetime, timedelta

class PursuitSystem:
    """
    追猎系统：当普通预警升级为追猎行动时启用。
    目标特征：主动规避监控、信号断续、轨迹刻意绕圈、改换装扮。
    """
    def __init__(self, target_name, target_type="可疑人员"):
        self.name = target_name
        self.type = target_type
        self.mode = "¬CH"  # 直接进入应急模式
        
        # 目标最后已知状态
        self.last_known_position = None
        self.last_signal_time = None
        self.signal_gap_threshold = 120  # 信号中断超过120秒判定为主动关闭设备
        
        # 目标先前的体态特征（用于伪装识别）
        self.previous_gait = None  # (步幅, 步频, 身高)
        self.previous_apparel = None  # (上衣颜色, 下衣颜色, 帽子)
        
        # 反追踪行为特征库
        self.evasive_patterns = []
        
        # 全城监控节点（模拟摄像头、基站、WiFi探针）
        self.surveillance_nodes = []
        
        # 追猎阶段
        self.pursuit_phase = 1  # 1=追踪, 2=围堵, 3=收网
        self.containment_perimeter = []

    def add_surveillance_node(self, lat, lon, node_type, coverage_radius):
        """部署监控节点（摄像头、WiFi探针、基站）"""
        self.surveillance_nodes.append({
            "position": (lat, lon),
            "type": node_type,
            "radius": coverage_radius,
            "last_triggered": None
        })

    def set_previous_identity(self, gait, apparel):
        """记录目标的先前的体态与衣着"""
        self.previous_gait = gait
        self.previous_apparel = apparel

    def counter_disguise(self, current_gait, current_apparel):
        """ℋ_holo 反伪装算子：识别是否改头换面"""
        # 如果没有历史数据，无法对比
        if not self.previous_gait or not self.previous_apparel:
            return False
        
        # 对比体态特征（步幅变化超过20%视为异常）
        gait_changed = abs(current_gait[0] - self.previous_gait[0]) / self.previous_gait[0] > 0.2
        
        # 对比衣着特征（上衣和下衣同时改变视为伪装）
        apparel_changed = (current_apparel[0] != self.previous_apparel[0] and 
                          current_apparel[1] != self.previous_apparel[1])
        
        if gait_changed or apparel_changed:
            return True
        return False

    def feed_signal(self, lat, lon, confidence, timestamp=None, 
                    current_gait=None, current_apparel=None):
        """接收一次被动信号，支持伪装检测"""
        if timestamp is None:
            timestamp = datetime.now()
        
        # 1. 检测伪装改扮
        if current_gait and current_apparel and self.previous_gait:
            if self.counter_disguise(current_gait, current_apparel):
                self.evasive_patterns.append({
                    "type": "改换装扮",
                    "timestamp": str(timestamp),
                    "analysis": "目标改变步态和衣着——这是专业反追踪行为，试图混入人群"
                })
                self.pursuit_phase = min(3, self.pursuit_phase + 1)
        
        # 2. 检测信号中断
        previous_position = self.last_known_position
        self.last_known_position = (lat, lon)
        
        if self.last_signal_time is not None:
            gap = (timestamp - self.last_signal_time).total_seconds()
            if gap > self.signal_gap_threshold:
                self.evasive_patterns.append({
                    "type": "信号中断",
                    "gap_seconds": gap,
                    "timestamp": str(timestamp),
                    "analysis": f"目标在 {gap:.0f} 秒内无任何信号，可能主动关闭设备或进入信号屏蔽区域"
                })
                self.pursuit_phase = min(3, self.pursuit_phase + 1)
        
        self.last_signal_time = timestamp
        
        # 3. 检测折返绕圈
        if len(self.evasive_patterns) >= 3:
            recent_positions = [self.last_known_position]
            if hasattr(self, '_recent_positions'):
                recent_positions = self._recent_positions + recent_positions
            self._recent_positions = recent_positions[-5:]
            
            if len(self._recent_positions) >= 4:
                start = self._recent_positions[0]
                end = self._recent_positions[-1]
                mid = self._recent_positions[len(self._recent_positions)//2]
                dist_start_end = self._haversine(start[0], start[1], end[0], end[1])
                dist_start_mid = self._haversine(start[0], start[1], mid[0], mid[1])
                if dist_start_end < 50 and dist_start_mid > 200:
                    self.evasive_patterns.append({
                        "type": "折返绕圈",
                        "timestamp": str(timestamp),
                        "analysis": "目标故意绕回原点，试图混淆追踪方向"
                    })
                    self.pursuit_phase = 3
        
        # 4. 更新监控节点状态
        for node in self.surveillance_nodes:
            dist = self._haversine(lat, lon, node["position"][0], node["position"][1])
            if dist < node["radius"]:
                node["last_triggered"] = str(timestamp)
        
        # 5. 更新目标的基准特征（确认其新身份）
        if current_gait:
            self.previous_gait = current_gait
        if current_apparel:
            self.previous_apparel = current_apparel
        
        return self.assess_pursuit_status()

    def _haversine(self, lat1, lon1, lat2, lon2):
        """球面距离（米）"""
        R = 6371000
        dlat = math.radians(lat2 - lat1)
        dlon = math.radians(lon2 - lon1)
        a = math.sin(dlat/2)**2 + math.cos(math.radians(lat1)) * math.cos(math.radians(lat2)) * math.sin(dlon/2)**2
        c = 2 * math.atan2(math.sqrt(a), math.sqrt(1-a))
        return R * c

    def assess_pursuit_status(self):
        """评估当前追猎状态"""
        return {
            "target": self.name,
            "mode": self.mode,
            "pursuit_phase": self.pursuit_phase,
            "phase_name": {1: "追踪中", 2: "围堵中", 3: "收网中"}[self.pursuit_phase],
            "last_position": self.last_known_position,
            "evasive_actions": len(self.evasive_patterns),
            "evasive_details": [e["type"] for e in self.evasive_patterns],
            "signal_gap_seconds": (
                (datetime.now() - self.last_signal_time).total_seconds()
                if self.last_signal_time else 0
            ),
            "triggered_nodes": sum(1 for n in self.surveillance_nodes if n["last_triggered"]),
            "containment_recommendation": (
                "扩大搜索范围，通知所有监控节点" if self.pursuit_phase == 1
                else "封锁周边出口，部署人员值守" if self.pursuit_phase == 2
                else "收网：目标已锁定，立即行动"
            )
        }

    def GTR_predict_next_position(self):
        """
        GTR 曲率预测：基于已知轨迹和反追踪模式，预测目标下一步可能出现的位置。
        """
        if not self.last_known_position:
            return []
        
        lat, lon = self.last_known_position
        predictions = []
        
        if any(e["type"] == "折返绕圈" for e in self.evasive_patterns):
            predictions.append({
                "position": (lat + 0.001, lon - 0.001),
                "probability": 0.4,
                "reason": "绕圈模式：可能返回之前经过的节点"
            })
        
        if any(e["type"] == "信号中断" for e in self.evasive_patterns):
            predictions.append({
                "position": (lat + 0.002, lon + 0.001),
                "probability": 0.35,
                "reason": "信号恢复：可能从屏蔽区边缘重新出现"
            })
        
        if any(e["type"] == "改换装扮" for e in self.evasive_patterns):
            predictions.append({
                "position": (lat - 0.001, lon + 0.002),
                "probability": 0.30,
                "reason": "伪装后：可能混入人群，向人流密集区移动"
            })
        
        if self.surveillance_nodes:
            nearest = min(self.surveillance_nodes, 
                         key=lambda n: self._haversine(lat, lon, n["position"][0], n["position"][1]))
            away_lat = lat + (lat - nearest["position"][0]) * 0.5
            away_lon = lon + (lon - nearest["position"][1]) * 0.5
            predictions.append({
                "position": (away_lat, away_lon),
                "probability": 0.25,
                "reason": "远离最近监控节点"
            })
        
        return sorted(predictions, key=lambda p: p["probability"], reverse=True)

    def Φ_lockdown(self):
        """Φ 公理门控：锁死追猎计算空间"""
        if not self.last_known_position or self.pursuit_phase < 3:
            return []
        
        lat, lon = self.last_known_position
        margin = 0.005
        return [
            (lat - margin, lon - margin),
            (lat + margin, lon + margin)
        ]


# ==================== 追猎模式测试 ====================
if __name__ == "__main__":
    print("=" * 60)
    print("天赐范式 · 守护者计划 · 追猎模式 v2.0")
    print("全算子进入 ¬CH 应急状态 · 反伪装模块已启用")
    print("=" * 60)
    
    pursuer = PursuitSystem("目标X", "可疑人员")
    
    # 部署全城监控节点
    pursuer.add_surveillance_node(39.9100, 116.4000, "摄像头", 100)
    pursuer.add_surveillance_node(39.9110, 116.4010, "WiFi探针", 50)
    pursuer.add_surveillance_node(39.9090, 116.4020, "基站", 500)
    pursuer.add_surveillance_node(39.9080, 116.3990, "摄像头", 100)
    
    # 记录目标的原始特征
    pursuer.set_previous_identity((0.75, 1.2, 1.75), ("黑色", "蓝色", "棒球帽"))
    
    print("\n【追猎场景：反追踪高手】")
    print("-" * 60)
    
    events = [
        # (lat, lon, conf, desc, gait, apparel)
        (39.9100, 116.4000, 0.90, "14:00 目标在商圈出现", 
         (0.75, 1.2, 1.75), ("黑色", "蓝色", "棒球帽")),
        (39.9102, 116.4005, 0.85, "14:03 向东北移动，WiFi探针嗅探到设备",
         (0.75, 1.2, 1.75), ("黑色", "蓝色", "棒球帽")),
        (39.9105, 116.4010, 0.80, "14:06 进入商场",
         (0.75, 1.2, 1.75), ("黑色", "蓝色", "棒球帽")),
        (39.9110, 116.4015, 0.60, "14:12 信号微弱，可能进入地下室",
         (0.68, 1.0, 1.75), ("黑色", "蓝色", "棒球帽")),
        # 换装后重新出现
        (39.9095, 116.3995, 0.70, "14:16 重新出现——但步态和衣着已完全不同！",
         (0.55, 0.9, 1.70), ("灰色", "棕色", "无帽")),
        (39.9085, 116.3990, 0.75, "14:20 往南移动，试图混入人群",
         (0.55, 0.9, 1.70), ("灰色", "棕色", "无帽")),
        (39.9080, 116.3985, 0.72, "14:23 进入小巷，信号再次减弱",
         (0.55, 0.9, 1.70), ("灰色", "棕色", "无帽")),
        (39.9095, 116.3995, 0.68, "14:28 绕回之前的点位——折返绕圈",
         (0.55, 0.9, 1.70), ("灰色", "棕色", "无帽")),
    ]
    
    for lat, lon, conf, desc, gait, apparel in events:
        status = pursuer.feed_signal(lat, lon, conf, 
                                     current_gait=gait, current_apparel=apparel)
        print(f"\n{desc}")
        print(f"  位置: ({lat:.4f}, {lon:.4f}) | 置信度: {conf:.0%}")
        print(f"  追猎阶段: {status['phase_name']} | 反追踪行为: {status['evasive_actions']}次")
        if status['evasive_details']:
            print(f"  识别到的反追踪伎俩: {', '.join(status['evasive_details'])}")
        print(f"  已触发监控节点: {status['triggered_nodes']}个")
        print(f"  建议: {status['containment_recommendation']}")
    
    predictions = pursuer.GTR_predict_next_position()
    if predictions:
        print(f"\n🎯 GTR 预判下一步位置:")
        for p in predictions:
            print(f"  → ({p['position'][0]:.4f}, {p['position'][1]:.4f}) "
                  f"概率: {p['probability']:.0%} | {p['reason']}")
    
    bounds = pursuer.Φ_lockdown()
    if bounds:
        print(f"\nΦ 公理锁死收网边界:")
        print(f"  左下: ({bounds[0][0]:.4f}, {bounds[0][1]:.4f})")
        print(f"  右上: ({bounds[1][0]:.4f}, {bounds[1][1]:.4f})")
    
    print("\n" + "=" * 60)
    print("追猎模式 v2.0 测试完成。")
    print("就算改头换面，也逃不出算子的罗网。")
    print("=" * 60)