File size: 19,881 Bytes

4bc8ea5
 
 
 
c29b25a
 
4bc8ea5

---
license: agpl-3.0
tags:
- snapkitty
- agents
- python
---

> Source: [github.com/SNAPKITTYWEST/carry-agent](https://github.com/SNAPKITTYWEST/carry-agent)

<p align="center">
  <img src="docs/firecarry.png" alt="CARRY — CARTO's Evil Twin Made of Curry" width="360px" />
</p>

<h1 align="center">CARRY</h1>
<h3 align="center">Adversarial Twin of CARTO</h3>

<p align="center">
  <strong>CURRY_CRYSTAL_C3 Triad + Braid Topology + Sovereign Quantum Simulator</strong><br />
  7-state DAG-locked pipeline · Entropy-gated transitions · Tau-Prolog logic kernel<br />
  Fibonacci anyons · ICP governance · BLAKE3 WORM audit chain<br />
  <em>The FSM tells you WHERE you are. The braid tells you WHETHER you got there honestly.</em>
</p>

<p align="center">
  <img src="https://img.shields.io/badge/lang-Rust-orange?style=flat-square" />
  <img src="https://img.shields.io/badge/logic-Tau--Prolog-blue?style=flat-square" />
  <img src="https://img.shields.io/badge/proof-Braid_B₃-purple?style=flat-square" />
  <img src="https://img.shields.io/badge/quantum-Fibonacci_Anyons-cyan?style=flat-square" />
  <img src="https://img.shields.io/badge/formal-Lean_4_%2B_Agda-blueviolet?style=flat-square" />
  <img src="https://img.shields.io/badge/tests-14%2F14_PASS-brightgreen?style=flat-square" />
  <img src="https://img.shields.io/badge/sorry-0-brightgreen?style=flat-square" />
  <img src="https://img.shields.io/badge/license-AGPL--3.0-green?style=flat-square" />
</p>

---

<p align="center">
  <img src="docs/carry_brand_banner.png" alt="CARRY FSM — Adversarial Twin System + Deterministic Compiler Engine" width="100%" />
</p>

---

```
 ██████╗ █████╗ ██████╗ ██████╗ ██╗   ██╗
██╔════╝██╔══██╗██╔══██╗██╔══██╗╚██╗ ██╔╝
██║     ███████║██████╔╝██████╔╝ ╚████╔╝
██║     ██╔══██║██╔══██╗██╔══██╗  ╚██╔╝
╚██████╗██║  ██║██║  ██║██║  ██║   ██║
 ╚═════╝╚═╝  ╚═╝╚═╝  ╚═╝╚═╝  ╚═╝   ╚═╝

  ╔═══════════════════════════════════════════════╗
  ║  B R A I D   T O P O L O G Y   R U N T I M E ║
  ║  σ₁ · σ₂ · σ₁  =  σ₂ · σ₁ · σ₂             ║
  ║  Yang-Baxter holds. The chain is honest.      ║
  ╚═══════════════════════════════════════════════╝

  strand 0 ──╲  ╱── σ₂ crossing
  strand 1    ╲╱
              ╱╲
  strand 2 ──╱  ╲── σ₁ crossing
              │
              ▼
         [C3 at pos 0]
         writhe = +2
         INVARIANT HOLDS
```

---

## What Is CARRY?

CARRY is the **adversarial twin** of [CARTO](https://github.com/SNAPKITTYWEST/cartographer-agent).

**CARTO** is the sovereign mapping agent — it models terrain, constructs pipelines, and produces outputs it claims are valid.

**CARRY** attacks those outputs. If CARRY cannot break CARTO's pipeline, the pipeline is honest. CARRY is the red team that never sleeps — a formal adversary baked into the architecture itself rather than run as a separate audit process.

The relationship:

```
  CARTO                           CARRY
  ─────                           ─────
  Maps terrain              ←→    Attacks the map
  Claims pipeline is valid  ←→    Tries to falsify the claim
  Produces WORM output      ←→    Verifies the WORM seal
  GOTO (push semantics)     ←→    COME-FROM (pull semantics)
  Forward evolution (U)     ←→    Reversed evolution (U†)
```

The braid topology encodes this duality formally: every GOTO crossing has a matching COME-FROM crossing. The writhe invariant proves that authority was transferred through the correct sequence of crossings — not just that it arrived at the right place, but that it took the right path.

If the path is wrong, the braid is wrong. If the braid is wrong, the proof is rejected. No exceptions.

---

## Braid Authority Transfer

```
INITIAL:      Curry ──── Crystal ──── C3
              [0]         [1]         [2]   (authority = pos 0)

After σ₂:     Curry ──── C3 ──── Crystal
              [0]        [1]      [2]       (C3 crosses OVER Crystal)

After σ₁:     C3 ──── Curry ──── Crystal
              [0]      [1]        [2]       (C3 crosses OVER Curry)

Writhe W(β) = (+1) + (+1) = +2
C3 at position 0 → AUTHORITY TRANSFERRED
INVARIANT HOLDS ✓
```

```
  BRAID WORD: σ₂ · σ₁
  ─────────────────────
  Curry ────\────────────────
              \
  Crystal ────X──\────────── σ₂: C3 over Crystal
              /   \
  C3 ─────── /────X────────  σ₁: C3 over Curry
                   \
                    ▼
                 C3 at pos 0
                 W = +2 ✓
```

---

## Architecture

```
  ╔══════════════════════════════════════════════════════════════╗
  ║                    CARRY STACK                               ║
  ╠══════════════════════════════════════════════════════════════╣
  ║  FORMAL LAYER        Lean 4 + Agda                          ║
  ║                      13 invariants · 0 sorry                ║
  ║                      state_preservation proved              ║
  ║                      duality_involution proved              ║
  ╠══════════════════════════════════════════════════════════════╣
  ║  QUANTUM LAYER       Fibonacci Anyon Simulator              ║
  ║                      B₃ braid group · φ = 1.6180           ║
  ║                      StateVector + DensityMatrix engines    ║
  ║                      ICP 6-stage governance pipeline        ║
  ║                      ASP declarative constraint solver      ║
  ║                      6052 cycle-accurate emulator           ║
  ╠══════════════════════════════════════════════════════════════╣
  ║  GOVERNANCE LAYER    Conditional Dual DAG                   ║
  ║                      GOTO ↔ COME-FROM duality               ║
  ║                      state preserved across ALL transitions ║
  ║                      BLAKE3 WORM audit chain                ║
  ╠══════════════════════════════════════════════════════════════╣
  ║  RUNTIME LAYER       Rust (carry-fsm crate)                 ║
  ║                      7-state DAG-locked FSM                 ║
  ║                      Entropy ≤ 0.20 gate                    ║
  ║                      Tau-Prolog logic kernel                ║
  ╚══════════════════════════════════════════════════════════════╝
```

---

## 7-State Quantum FSM

```
  ┌──────┐    ┌─────────┐    ┌──────────┐    ┌─────────┐
  │ INIT │───▶│ PREPARE │───▶│ ENTANGLE │───▶│ COMPUTE │
  └──────┘    └─────────┘    └──────────┘    └────┬────┘
                                                   │
  ┌────────┐    ┌────────┐    ┌────────┐           │
  │ COMMIT │◀───│ VERIFY │◀───│MEASURE │◀──────────┘
  └───┬────┘    └────────┘    └────────┘
      │
      └──▶ PREPARE (loop) ─── or ─── COMMIT (terminal)

  Any state ──▶ HALTED  (emergency)
  Any state ──▶ CYCLE_LIMIT  (budget exhausted, absorbing)

  Theorem (Lean 4, zero sorry):
    Halted and CYCLE_LIMIT are ABSORBING STATES.
    No transition exits them. Ever.
```

---

## The Quantum Module

CARRY ships a full first-principles quantum simulator:

```
runtime/quantum/
├── core.rs          StateVector |ψ⟩ + DensityMatrix ρ engines
│                    Born rule measurement · noise models
│                    H X Y Z S T Rx Ry Rz CNOT CZ SWAP
├── fsm.rs           7-state governance FSM (proved absorbing terminals)
├── agents.rs        Primary + Partner agent pairs
│                    Qubit ownership: pairwise disjoint (proved INV-7)
├── dag.rs           Execution DAG + provenance hash chain
├── icp.rs           Integrity Constraint Protocol
│                    6 stages: Setup→Observe→Validate→Check→Execute→Verify
│                    HALT on any constraint breach
├── asp.rs           Answer Set Programming constraint solver
│                    QubitControl · Entangled · AgentControls rules
├── topological.rs   Fibonacci anyon simulator
│                    B₃: σ₁ σ₂ σ₁⁻¹ σ₂⁻¹ · φ ≈ 1.6180 (golden ratio)
│                    Fusion rules: tau⊗tau → {vacuum, tau}
├── ftb.rs           Fibonacci-Taylor Braid synthesis [RESEARCH_HYPOTHESIS]
├── gitc.rs          Governance Invariant Topological Cycle
├── emulator_6052.rs Cycle-accurate 6052 emulator · MAX_CYCLE hard budget
└── benchmarks.rs    Bell · GHZ · Teleportation · Deutsch · Grover · QFT
```

Reference circuits:

```
  Circuit          Qubits  Gates  Expected state
  ────────────     ──────  ─────  ──────────────────────────
  Bell             2       2      (|00⟩ + |11⟩) / √2
  GHZ-3            3       3      (|000⟩ + |111⟩) / √2
  Teleportation    3       7      State transfer protocol
  Deutsch-Jozsa    2       5      Constant/balanced oracle
  Grover-2Q        2       12     Amplitude amplification
  QFT-3Q           3       10     Quantum Fourier Transform
  ────────────────────────────────────────────────────────
  14/14 tests PASS · all circuits SUCCESS
```

---

## Formal Verification Layer

```
runtime/quantum/
├── QuantumSpec.agda          Dependent-type specification
│                             Transition s s' encoded in the TYPE
│                             Illegal transitions: unrepresentable
│
├── QuantumInvariants.lean    13 machine-checked invariants
│                             INV-1:  norm preserved by unitary gates
│                             INV-3:  cycle counter strictly monotone
│                             INV-4:  FSM confined to DAG edges
│                             INV-5:  Halted/CycleLimit absorbing ✓
│                             INV-7:  agent qubit ownership disjoint
│                             INV-9:  Fibonacci fusion rules correct
│                             INV-12: GITC invariant_holds iff all checks pass
│                             ... 13 total · 0 sorry
│
└── QuantumReference.fs       F# executable reference backend
                              7 conformance tests
                              Bell state · FSM terminal · ownership
```

The key post-quantum security property (ADR-002):

```
  theorem state_preservation :
      Step P (l₁, s₁) (l₂, s₂) → s₁ = s₂

  The governance layer is FORMALLY INERT with respect to state.
  A quantum adversary with full control of the navigator
  CANNOT touch the cryptographic state.
  Not policy. TYPE.
```

---

## Trust Gate Invariants

```
  ╔═══════════════════════════════════════════════════════════╗
  ║  GATE         RULE                    BLOCKS              ║
  ╠═══════════════════════════════════════════════════════════╣
  ║  Entropy      entropy ≤ 0.20          Acting on noise     ║
  ║  Writhe       W(β) ≥ 2               Incomplete transfer ║
  ║  Reidemeister σ·σ⁻¹ rejected         Fake crossings      ║
  ║  V1 Trust     active ≡ trusted        Untrusted execution ║
  ║  Absorbing    Halted stays Halted     Re-entry after HALT ║
  ║  Cycle        cycle ≤ max_cycle       Infinite loops      ║
  ╚═══════════════════════════════════════════════════════════╝
```

---

## Repository Structure

```
carry-agent/
│
├── Cargo.toml                    carry-fsm crate (AGPL-3.0)
│
├── runtime/
│   ├── carry-fsm.rs              Core FSM library (7-state DAG)
│   ├── braid.rs                  B₃ braid topology module
│   ├── main.rs                   carry-cli binary
│   │
│   └── quantum/                  ◀ SOVEREIGN QUANTUM SIMULATOR
│       ├── core.rs               StateVector + DensityMatrix + gates
│       ├── fsm.rs                Quantum governance FSM
│       ├── agents.rs             Primary/partner agent pairs
│       ├── dag.rs                Execution DAG + provenance
│       ├── icp.rs                Integrity Constraint Protocol
│       ├── asp.rs                ASP constraint solver
│       ├── topological.rs        Fibonacci anyon simulator
│       ├── ftb.rs                Fibonacci-Taylor Braids [HYPOTHESIS]
│       ├── gitc.rs               Governance Invariant Topological Cycle
│       ├── emulator_6052.rs      Cycle-accurate 6052 emulator
│       ├── benchmarks.rs         Reference circuit suite
│       ├── mod.rs                Module root
│       │
│       ├── QuantumSpec.agda      ◀ Dependent-type spec (Agda)
│       ├── QuantumInvariants.lean ◀ 13 invariants, 0 sorry (Lean 4)
│       └── QuantumReference.fs  ◀ F# conformance backend
│
├── kernels/
│   ├── carry-kernel.pl           Original Prolog transition table
│   └── tau-prolog/
│       ├── braid_kernel.pl       Braid logic engine (ISO Prolog)
│       └── crossing_table.pl     Crossing-to-DAG lookup
│
├── logic/
│   └── constraint-graph.xml      Constraint graph specification
│
├── modules/
│   └── carry-manifest.json       Full manifest (layers, DAG, rules)
│
└── docs/
    ├── firecarry.png             Avatar
    ├── carry_brand_banner.png    Architecture diagram
    ├── braid_animation.svg       Animated braid crossing proof
    └── CARRY_ARCHITECTURE.md     Architecture specification
```

---

## Run It

```bash
# Full pipeline (FSM + braid proof)
cargo run --bin carry-cli

# Quantum benchmark suite
cargo run --bin carry-cli -- quantum benchmark

# Quantum governance verification (ICP + ASP)
cargo run --bin carry-cli -- quantum verify

# Fibonacci anyon topological simulation
cargo run --bin carry-cli -- quantum topology

# All 14 tests
cargo test

# Inspect FSM state
cargo run --bin carry-cli -- quantum inspect
```

Expected output:

```
═══════════════════════════════════════════════════════════════
  CARRY PIPELINE: BOTH PROOFS DISCHARGE
  FSM: DETERMINISTIC_COMPILATION_COMPLETE
  BRAID: INVARIANT_HOLDS (writhe=2, C3 at pos 0)
═══════════════════════════════════════════════════════════════

┌─ QUANTUM BENCHMARK SUITE ──────────────────────────────────┐
  Circuit: Bell            Qubits: 2 | Gates: 2  | Status: SUCCESS
  Circuit: GHZ-3           Qubits: 3 | Gates: 3  | Status: SUCCESS
  Circuit: Teleportation   Qubits: 3 | Gates: 7  | Status: SUCCESS
  Circuit: Deutsch         Qubits: 2 | Gates: 5  | Status: SUCCESS
  Circuit: Grover-2Q       Qubits: 2 | Gates: 12 | Status: SUCCESS
  Circuit: QFT-3Q          Qubits: 3 | Gates: 10 | Status: SUCCESS
═══════════════════════════════════════════════════════════════
```

---

## The Math

**B₃ braid group** — generators σ₁, σ₂, Yang-Baxter:

```
  σ₁ · σ₂ · σ₁  =  σ₂ · σ₁ · σ₂
```

**Writhe invariant** for canonical pipeline β = σ₂ · σ₁:

```
  W(β) = (+1) + (+1) = +2
  π(β): C3 → position 0
  Invariant: W(β) ≥ 2  ∧  π(β)(C3) = 0
```

**Fibonacci anyons** — golden ratio quantum dimension:

```
  φ = (1 + √5) / 2 ≈ 1.6180
  tau ⊗ tau → vacuum  w.p.  1/φ²  ≈ 0.382
  tau ⊗ tau → tau     w.p.  1 - 1/φ² ≈ 0.618
```

**Z₂ duality** (proved in Lean 4 + Agda, from order-of-symmetry):

```
  D ∘ D = id          (duality is an involution)
  D(P) ≠ P            (no fixed points — orbit size exactly 2)
  GOTO ↔ COME-FROM    (structural mirrors, Z₂ group of order 2)
```

**State preservation** (proved, 0 sorry):

```
  Step P (l₁, s₁) (l₂, s₂) → s₁ = s₂
  The navigator cannot touch the payload. By type. Not by policy.
```

---

```
  ╔═════════════════════════════════════════════╗
  ║  CARRY: The adversarial twin that proves    ║
  ║  your pipeline is honest.                   ║
  ║                                             ║
  ║  The compiler says it runs.                 ║
  ║  The braid says it's real.                  ║
  ║  The Lean proof says it stays real.         ║
  ╚═════════════════════════════════════════════╝
```

---

## License

AGPL-3.0-only  
Copyright (C) 2026 Ahmad Ali Parr, Jessica L. Williams / SNAPKITTYWEST

<p align="center">
  <img src="docs/firecarry.png" alt="Firecarry" width="80px" />
</p>

### 💼 Commercial License

Snapkitty code is free and open under **AGPL-3.0** for open-source use. Building a commercial product or service? A **proprietary commercial license** from Snapkitty Collective LLC lets you ship this code without the AGPL's source-sharing and network-use obligations.

**[→ Get a commercial license](mailto:A.parr@belespritdaccord.uk?subject=Commercial%20license:%20carry-agent)** · A.parr@belespritdaccord.uk