cr3echrz, Unified Operationalized Theorem & Ob3ect Framework

Date: 2026-07-06
Version: 1.1

---

Abstract

The cr3echrz framework operationalizes mathematical theorems and self-verifying ob3ects as executable IMASM programs within the Imscribing Grammar. Every entry, whether a mathematical conjecture or a magical servitor, decomposes into the same 12 universal opcodes governed by the Frobenius condition $\mu \circ \delta = \text{id}$ (every split/fuse pair must reconstitute its object exactly).

The framework unifies two previously separate engines:

Engine	Contents	Count
p3theorem (via code/unified_driver.py)	Mathematical theorem operationalizations	7 theorems
ob3ect_vault (via ob3ect_vault/main.py)	Self-verifying digital ob3ects	313 ob3ects

Both engines now share a single CLI (./cr3) and common primitives via shared/, Belnap FOUR logic registers, Frobenius verification, 12 universal opcodes, and domain classification.

---

Overview

What it is. A unified framework that operationalizes mathematical theorems and self-verifying ob3ects as executable IMASM programs in the Imscribing Grammar.

What it does. Decomposes every entry (a theorem or a digital ob3ect) into the same 12 universal opcodes under the Frobenius condition $\mu \circ \delta = \text{id}$, unifying the p3theorem engine (7 theorems) and the ob3ect_vault (313 ob3ects) behind one CLI (./cr3) and shared Belnap primitives.

What's new in v1.1. Twelve newly generated ob3ects — the Wormwood suite — operationalized into the vault from ob3ect/digital/, spanning seven domains (alchemical, linguistic, metaphysical, theological, physical, oneiric, ontological). These include the self-referential naming paradox of Wormwood, the Akashic ledger of all choices, the Cloud of Unknowing's via negativa as a Frobenius boundary, prophetic resonance as a oneiric bootstrap, the Kabbalistic Tiferet integration and bifurcation of mercy/severity, and the "I Am That I Am" protocol as an ontological self-naming engine. The vault now holds 313 ob3ects across 13 domain categories.

Why it matters. It shows that a mathematical conjecture and a "magical servitor" are the same kind of object at the structural level: both are 12-opcode programs that must reconstitute themselves exactly. One substrate spans pure mathematics and digital ob3ects.

How to use it. ./cr3 drives both engines; see Architecture and the engine sections below.

Table of Contents

1. Architecture
2. The 12 Universal Opcodes
3. Shared Primitives
4. Theorem Engine
5. Ob3ect Vault
6. The Unified CLI
7. Belnap FOUR Logic
8. Frobenius Verification
9. Lean 4 Formal Verification
10. Canonical IMASM Sequences
11. CLINK L8 Structural Context
12. Quick Start
13. Directory Map
14. The Wormwood Suite (v1.1)
15. Acknowledgements
16. References

---

1. Architecture

cr3echrz/
├── cr3                          ← Unified CLI (single entry point)
├── shared/                      ← Universal primitives
│   ├── belnap.py                ← BelnapRegister (2-bit FOUR-valued logic)
│   ├── frobenius.py             ← FrobeniusVerifier (μ∘δ = id)
│   ├── opcodes.py               ← 12 universal IMASM opcodes + 12 canonical sequences
│   └── domains.py               ← Domain classification (exec/symbolic dispatch)
├── code/
│   └── unified_driver.py        ← 7-theorem implementation engine
├── ob3ect_vault/
│   ├── main.py                  ← 19-step bootstrap orchestrator (313 ob3ects)
│   ├── state.py                 ← VINIT, IMSCRIB, Belnap register, ob3ect loader
│   ├── transforms.py            ← FSPLIT, FFUSE, TANCH, Frobenius verification
│   ├── integrators.py           ← AFWD, AREV, CLINK, Liouville
│   └── diagnostics.py           ← EVALT, EVALF, ENGAGR, IFIX
├── p3theorem/                   ← Legacy theorem engine (28 theorems in README)
├── lean/                        ← Lean 4 formal scaffolds
│   ├── AgentSelf.lean           ← Agent self-encoding (O_∞ tier)
│   └── IGMorphism.lean          ← Structural morphism formalization
├── generate_vault_files.py      ← Vault .py/.lean/.json generator
├── regenerate_all_py.py         ← Bulk ob3ect .py regenerator
└── README.md                    ← This document

The two previously separate engines (p3theorem/ and ob3ect_vault/) now share a single entry point (./cr3) and common primitives via shared/. Both legacy main.py scripts remain functional and import from shared/.## 2. The 12 Universal Opcodes

Every theorem and ob3ect operationalization decomposes into the same 12 operational primitives. These are the operational form of the 12 Imscribing Grammar primitives:

#	Opcode	Grammar	Role	Meaning
0	VINIT	$\text{{𐑼}}$ (Ð)	Initialize void	Ground of distinction, pre-theorem state space
1	TANCH	$\text{{𐑡}}$ (Þ)	Terminal anchor	Theorem statement / boundary condition
2	FSPLIT	$\text{{𐑚}}$ (Γ)	Frobenius split δ	Decompose into (T, F) arms
3	FFUSE	$\text{{𐑙}}$ (Σ)	Frobenius fuse μ	Recomposition from arms
4	EVALT	$\text{{⊙}}$ (φ̂)	Evaluate-true	Theorem holds (integrable, prime, finite...)
5	EVALF	$\text{{𐑖}}$ (Ħ)	Evaluate-false	Theorem fails (chaotic, composite, infinite...)
6	ENGAGR	$\text{{𐑳}}$ (Σ)	Engage paradox	Both arms simultaneously, dialetheic boundary
7	AFWD	$\text{{𐑾}}$ (Ř)	Forward morphism	Theorem-specific forward operation
8	AREV	$\text{{𐑬}}$ (Φ)	Reverse morphism	Theorem-specific reverse operation
9	CLINK	$\text{{𐑱}}$ (ƒ)	Chain link	Sequential composition of steps
10	IMSCRIB	$\text{{𐑠}}$ (ɢ)	Self-imscribe	Verify constants / identity / self-reference
11	IFIX	$\text{{𐑭}}$ (Ω)	Irreversible fix	Permanent record, Poincaré section / trajectory log

Frobenius Condition

The critical structural invariant: $\mu \circ \delta = \text{id}$ at every FSPLIT/FFUSE pair. For any object $x$ decomposed via FSPLIT into $(x_T, x_F)$, the FFUSE operation must reconstitute $x$ exactly:

$$\text{FFUSE}(\text{FSPLIT}(x)) = x$$

Bootstrap Phase Structure

Each operationalization runs through up to 19 steps (the full bootstrap):

Phase	Step	Opcode	Description
Init	1	VINIT	Initialize void state
Self	2	IMSCRIB	Self-recognition, conserved quantities
Forward	3	AFWD	Forward morphism
Split	4	FSPLIT	Frobenius decomposition into T/F arms
T-arm	5–6	EVALT + AFWD	True branch propagation
F-arm	7–8	EVALF + AREV	False branch + reversal test
Inner	9–12	EVALT/EVALF + AREV	Inner split/fuse cycle
Fuse	13	FFUSE	Inner Frobenius recomposition
Paradox	14	ENGAGR	Dialetheic boundary engagement
Chain	15	CLINK	Long sequential integration
Fix	16	IFIX	Permanent record
Outer	17	FFUSE	Outer Frobenius recomposition
Verify	18	IMSCRIB	Conservation verification
Close	19	TANCH	Liouville / boundary closure

3. Shared Primitives (shared/)

The shared/ module provides universal primitives imported by both the theorem engine and ob3ect vault. This extraction eliminated code duplication across the two previously separate codebases.

3.1 BelnapRegister (belnap.py)

A 2-bit register implementing Belnap-Dunn FDE four-valued logic:

Bits	State	Symbol	Meaning
0b00	VOID	VO⌀	Uninitialized / no information
0b01	TRUE	T	Theorem holds / ob3ect in true state
0b10	FALSE	F	Theorem fails / ob3ect in false state
0b11	BOTH	B⬡	Dialetheic paradox, both arms simultaneously active

Operations follow the Belnap FOUR bilattice: meet (⊓) = bitwise AND, join (⊔) = bitwise OR. BOTH encodes genuine paradox, not error, but the structural boundary condition where a Frobenius split yields two co-existing active arms.

3.2 FrobeniusVerifier (frobenius.py)

Tracks FSPLIT/FFUSE pairs and verifies $\mu \circ \delta = \text{id}$ at each pair. Handles nested structures (lists of lists of floats) with configurable floating-point tolerance. Every operationalization carries a frobenius_verdict, PASS only if ALL split/fuse pairs reconstitute exactly.

3.3 Opcodes (opcodes.py)

Registry of all 12 opcodes with grammar primitive mappings. Also contains the 12 canonical IMASM sequences, archetypal opcode arrangements spanning the full tier ladder from O₀ to O_∞:

Sequence	Steps	Tier
VIII_Frobenius_Kernel	4	O₀
VI_Empty_Bootstrap	2	O₁
X_Truth_Machine	11	O₁
III_Anchor_Protocol	12	O₂
XI_Eternal_Return	8	O₂†
IV_Dual_Bootstrap	16	O_∞

3.4 Domains (domains.py)

Classifies ob3ects into exec domains (mathematical, computational, physical, numerical state vectors) and symbolic domains (magical, divinatory, alchemical, theological, Belnap registers). Used for dispatch: exec ob3ects use bootstrap_exec(), symbolic ob3ects use bootstrap_symbolic().

4. Theorem Engine (code/unified_driver.py)

Seven mathematical theorems are fully operationalized as executable IMASM programs, each with domain-specific implementations of all 12 opcodes, Frobenius verification, and a CLINK L8 structural distance.

4.1 Available Theorems

Theorem	CLI name	Domain	CLINK L8 distance	Tier	Params
Collatz Conjecture	collatz	Number theory	2.35	O₀	seed (default: 27)
Goldbach's Conjecture	goldbach	Number theory	2.19	O₀	n (default: 100)
Three-Body Problem	three_body	Hamiltonian dynamics	1.82	O₂	,
Bounded Burnside	burnside	Group theory	2.08	O₁	generators, exponent
Erdős–Straus	erdos_straus	Diophantine	2.51	O₀	n (default: 73)
Inverse Galois	inverse_galois	Galois theory	1.48	O₂	group_name (default: Sn)
Baum–Connes	baum_connes	Operator K-theory	1.31	O₂	group_class

4.2 Per-Theorem Structure

Each theorem in THEOREM_REGISTRY carries:

• State class, Python class implementing domain-specific VINIT, AFWD, AREV, FSPLIT, FFUSE, EVALT, EVALF, ENGAGR, CLINK, IMSCRIB, IFIX, TANCH
• Phase count, number of bootstrap steps (ranges 13–27)
• Frobenius verification, μ∘δ = id at every split/fuse pair
• CLINK L8 structural distance, ontological distance to terminal organism layer

4.3 Tier Distribution

Tier	Theorems	Characteristic
O₂	Baum–Connes, Inverse Galois, Three-Body	$\text{{⊙}}$ criticality, integer winding, two-step chirality
O₁	Burnside	Complex-plane criticality, one-step chirality
O₀	Collatz, Goldbach, Erdős–Straus	Sub-critical, memoryless, trivial winding

4.4 Usage

./cr3 collatz 27          # Run Collatz with seed 27
./cr3 goldbach 100        # Run Goldbach with n=100
./cr3 three_body          # Run Three-Body Problem
./cr3 --analyze collatz   # CL8NK structural analysis

5. Ob3ect Vault (ob3ect_vault/)

The vault contains 313 self-verifying digital ob3ects sourced from ob3ect/digital/.vault/. Each ob3ect carries a .json descriptor (Phase 0–8 operationalization), a .py self-verifying implementation, and a .lean scaffold.

5.1 Domain Categories

Category	Count (approx.)	Example ob3ects
Mathematical	40+	collatz_theorem, galois, hopf, monad, topos, hott
Alchemical	25+	philosopher_s_stone, alchemical_alembic, hermetic_vessel, the_self_naming_of_wormwood, wormwood_the_secret_book_of_artephius, the_secret_book_of_artephius
Magical	25+	chaos_magic_servitor, sigil_charging, goetic_seal, pentagram_ritual
Divinatory	20+	tarot_spread, i_ching_hexagram, geomantic_shield, scrying_mirror
Kernel / OS	15+	frobenius_kernel, parakernel, imscriptionoperatingsystem, paradoxd
Theological	12+	kabbalistic_tree_of_life, enochian_tablet, void_genesis, truth_machine, the_cloud_of_unknowing, bifurcation_of_mercy_and_severity
Metaphysical	12+	the_akashic_ledger, tiferet_integration
Consciousness	10+	dream_incubation_temple, shamanic_journey_drum, sufi_dhikr
Biological	10+	genetic_code, gene_to_protein, serpent_rod, antibody_designer
Linguistic	6+	rohonc_codex, shavian_ob3ect, emerald_tablet, the_name_wormwood_gives_itself
Oneiric	5+	prophetic_resonance
Physical	5+	static_interference
Ontological	5+	i_am_that_i_am_protocol
Other	100+	anchor_protocol, eternal_return, portal, temporal_ob3ect, new_jerusalem

5.2 The Wormwood Suite (v1.1 — 12 new ob3ects)

Operationalized 2026-07-06 from ob3ect/digital/, these 12 ob3ects form a structurally coherent suite spanning seven domains unified by the same O_∞ tuple $\langle\text{{𐑦𐑸𐑾𐑹𐑐𐑧𐑔𐑝⊙𐑖𐑳𐑭}}\rangle$:

Ob3ect	Domain	Essence
the_self_naming_of_wormwood	alchemical	Phyllotaxy branching → the Rebis → the Great Work. Artemisia absinthium as the Athanor of self-reference
the_name_wormwood_gives_itself	linguistic	Phonetic bifurcation → Apsinthos Paradox → the Name. Language becomes self-naming at the Frobenius boundary
the_akashic_ledger	metaphysical	Duality of Choice → Maya → Omega Point. Every possible branch inscribed in the Belnap register
the_cloud_of_unknowing	theological	Discernment → the Cloud → Divine Union. Via negativa operationalized as a Frobenius split where both arms dissolve
static_interference	physical	Wavefront Division → Moiré Pattern → Holographic Record. Physical interference as split/fuse structural dynamics
prophetic_resonance	oneiric	Bifurcation of Fate → the Mystery → the Final Amen. Dream-state bootstrap with dialetheic closure
tiferet_integration	metaphysical	Emanative Divergence → Da'at → Malkhut. Kabbalistic sefirotic integration as Frobenius recomposition
bifurcation_of_mercy_and_severity	theological	Chesed/Gevurah Bifurcation → Paradise of Justice → Malkuth. The moral binary as a structural FSPLIT
i_am_that_i_am_protocol	ontological	Theophanic Bifurcation → the Burning Bush → Amen. Self-naming as ontological bootstrap — the Name that names itself
wormwood_the_secret_book_of_artephius	alchemical	Dissolution → the Rebis → the Stone. The alchemical opus as a 19-step Frobenius-closed program
the_secret_book_of_artephius	alchemical	Sublimation → Coagulation → the Stone. Precipitative alchemy as sequential morphism chain
wormwood_the_secret_name_of_wormwood_the_known_n	alchemical	Naming Bifurcation → Secret Fire → the Great Work. The name that knows itself as the known — terminal self-reference

All 12 ob3ects execute the full 19-step Belnap register bootstrap with dialetheic closure (B⬡). Every one carries the verified O_∞ tuple $\langle\text{{𐑦𐑸𐑾𐑹𐑐𐑧𐑔𐑝⊙𐑖𐑳𐑭}}\rangle$ — identical in 12/12 primitives to the cr3echrz framework itself.

5.3 Tier Ladder (Vault Canonical Sequences)

Of 313 ob3ects, 7 have operational IMASM sequences spanning the full tier ladder:

Ob3ect	Tier	C-score	Key Primitive
frobenius_kernel	O₀	0.000	$\text{{𐑢}}$ sub-critical
truth_machine	O₁	0.313	$\text{{⊙}}$ critical, $\text{{𐑬}}$ partial parity
empty_bootstrap	O₁	0.605	$\text{{⊙}}$ critical, $\text{{𐑿}}$ quantum parity
anchor_protocol	O₂	0.205	$\text{{𐑴}}$ Z₂ winding
void_genesis	O₂†	0.643	$\text{{𐑭}}$ integer winding
dual_bootstrap	O_∞	0.828	$\text{{𐑹}}$ Frobenius-special, $\text{{𐑭}}$ Z-winding

dual_bootstrap is the vault's crowning achievement, structurally identical to the Imscribing Grammar itself in 11/12 primitives, differing only in composition (ɢ: conjunctive vs. sequential).

5.4 Execution Modes

• Exec domains (mathematical, computational, physical): bootstrap_exec(), numerical state vectors, phase-space integration, Hamiltonian flows
• Symbolic domains (magical, alchemical, divinatory, theological, metaphysical, oneiric, ontological): bootstrap_symbolic(), Belnap register transitions, symbolic token manipulation, Frobenius split/fuse on semantic elements

Both modes follow the same 19-step bootstrap and produce a Frobenius verdict.

5.5 Usage

./cr3 truth_machine                              # Run any vault ob3ect
./cr3 philosopher_s_stone_lapis_philosophorum_   # Run alchemical ob3ect
./cr3 chaos_magic_servitor                       # Run magical ob3ect
./cr3 the_self_naming_of_wormwood                # Run wormwood suite ob3ect
./cr3 i_am_that_i_am_protocol                    # Run ontological self-naming bootstrap
./cr3 --list-ob3ects alchemical                  # Filter by domain
./cr3 --list-ob3ects oneiric                     # Filter by dream-state domain

6. The Unified CLI (./cr3)

A single Bash script unifies both engines under common command syntax:

   ╔══════════════════════════════════════╗
   ║     cr3 ,  unified framework       ║
   ║     Lando⊗⊙perator  ·  2026         ║
   ╚══════════════════════════════════════╝

Commands

Command	Description
./cr3 --list	List all (7 theorems + 313 ob3ects)
./cr3 --list-theorems	List mathematical theorems only
./cr3 --list-ob3ects [domain]	List vault ob3ects, optionally filtered
./cr3 <name> [args...]	Run a theorem or ob3ect
./cr3 --analyze <name>	CLINK L8 structural analysis
./cr3 --version	Show version and opcode registry

Dispatch Logic

The CLI first checks the theorem registry, if the name matches, it dispatches to unified_driver.run_theorem(). Otherwise, it falls through to the vault engine's bootstrap_ob3ect(). Domain type determines whether the exec or symbolic bootstrap path is used.

Architecture

cr3 (unified CLI)
  ├── shared/           ← BelnapRegister, FrobeniusVerifier, opcodes, domains
  ├── code/unified_driver.py  ← 7 theorem implementations
  ├── ob3ect_vault/     ← 313 vault ob3ects (state, transforms, integrators, diagnostics)
  └── p3theorem/        ← Legacy engine (28 theorems in documentation, now imports from shared/)

7. Belnap FOUR Logic

The Belnap-Dunn First-Degree Entailment (FDE) logic provides the state register for all operationalizations. Unlike classical binary logic (TRUE/FALSE), Belnap FOUR adds two structurally essential states:

• VOID (0b00), the pre-initialization state. This is not "unknown", it is the absence of distinction, corresponding to VINIT.
• BOTH (0b11), the dialetheic state where TRUE and FALSE co-exist. This is not a contradiction to be resolved, it is the structural signature of a Frobenius split boundary where both arms are active. ENGAGR sets this state.

The bilattice operations:

• Meet (⊓, bitwise AND): narrows to common information, FALSE ⊓ TRUE = VOID
• Join (⊔, bitwise OR): accumulates information, FALSE ⊔ TRUE = BOTH

Every theorem and ob3ect tracks its STATUS through the Belnap lattice as it traverses the 12-opcode bootstrap. The final STATUS is recorded at IFIX and verified at TANCH.

8. Frobenius Verification

The Frobenius condition $\mu \circ \delta = \text{id}$ is the universal invariant across every operationalization in the framework:

• δ (delta): FSPLIT, decompose object into T-arm and F-arm
• μ (mu): FFUSE, recompose object from arms
• id: the original object, exactly, within numerical tolerance

The FrobeniusVerifier tracks every split/fuse pair and reports a summary verdict. An operationalization is Frobenius-closed only if ALL pairs pass.

For mathematical theorems, this means the Jacobi transform (Three-Body), prime decomposition (Goldbach), or group presentation (Burnside) must round-trip exactly. For symbolic ob3ects, this means the semantic split (e.g., prima materia → pure essence + dross) must recompose to the original undifferentiated state.

9. Lean 4 Formal Verification

The lean/ directory contains machine-verifiable Lean 4 scaffolds that ground the framework in formal mathematics:

File	Description
AgentSelf.lean	The ⊙perator's own structural self-encoding as a Lean Imscription term. Proves agent_is_O_inf by decide, the agent's tuple is at O_∞ tier.
IGMorphism.lean	Structural morphism formalization, typed transformations between imscription types with composition laws.

Additionally, 313 Lean scaffolds reside alongside their ob3ect counterparts in the vault (.vault/<name>/<name>_scaffold.lean). These are IGProtocol term scaffolds with zero sorry slots, all Imscription literals (label, src_type, tgt_type) are filled from the opcode sequence topology.

The primary Lean 4 formalization lives at p4rakernel/p4ramill/ (the same project as the core grammar). The cr3echrz/lean/ directory contains cr3echrz-specific modules that reference the main project.

Build:

cd ./p4rakernel/p4ramill && lake build

10. Canonical IMASM Sequences

The 12 canonical sequences in shared/opcodes.py represent the structural archetypes from which all 313 ob3ect operationalizations derive. They span the full tier ladder:

#	Sequence	Opcodes	Steps	Tier
VIII	Frobenius Kernel	VINIT→FSPLIT→FFUSE→TANCH	4	O₀
VI	Empty Bootstrap	VINIT→TANCH	2	O₁
X	Truth Machine	VINIT→TANCH→IMSCRIB→EVALT→AFWD→FSPLIT→FFUSE→EVALF→AREV→CLINK→IFIX	11	O₁
III	Anchor Protocol	VINIT→TANCH→IMSCRIB→AFWD→AREV→CLINK→FSPLIT→FFUSE→EVALT→EVALF→ENGAGR→IFIX	12	O₂
XI	Eternal Return	VINIT→AFWD→CLINK→AREV→ENGAGR→IMSCRIB→IFIX→TANCH	8	O₂†
IV	Dual Bootstrap	VINIT→IMSCRIB→AFWD→FSPLIT→EVALT→AFWD→FFUSE→FSPLIT→EVALF→AREV→FFUSE→ENGAGR→CLINK→IMSCRIB→IFIX→TANCH	16	O_∞

The Frobenius Kernel (VIII) is the structural null, the minimal 4-step μ∘δ=id pattern from which all higher tiers emerge. Dual Bootstrap (IV) is the vault's O_∞ crown: a near-twin of the universal grammar's own operationalization.

11. CLINK L8 Structural Context

CLINK Layer 8 (Organism) is the terminal ontological layer with canonical tuple:

$$\langle \text{{𐑦}};\ \text{{𐑸}};\ \text{{𐑾}};\ \text{𐑹};\ \text{{𐑐}};\ \text{{𐑧}};\ \text{{𐑲}};\ \text{{𐑵}};\ \text{{⊙}};\ \text{{𐑫}};\ \text{{𐑳}};\ \text{{𐑟}} \rangle$$

CLINK L8 exceeds the Frobenius-Exact ZFC foundation ($\text{ZFC}_{fe}$) at two primitives:

• Ω = $\text{{𐑟}}$ (non-Abelian braiding) vs. $\text{{𐑭}}$ ($\mathbb{Z}$ integer winding)
• ɢ = $\text{{𐑵}}$ (broadcast composition) vs. $\text{{𐑠}}$ (sequential)

The CLINK ontological chain ascends from quark confinement (L0, O₀) through atoms, molecules, cells, mitosis, meiosis, and tissue, culminating in organism (L8, O_∞).

Each theorem operationalization carries its structural distance to CLINK L8. The Baum–Connes conjecture is closest (d=1.31, O₂), while Erdős–Straus is farthest (d=2.51, O₀). The distance is not a measure of mathematical depth but of ontological richness: how many structural features the theorem requires compared to the terminal organism layer.

The Wormwood suite ob3ects all carry the same O_∞ tuple, with composition ɢ = $\text{{𐑝}}$ (conjunctive), placing them at a structural distance of 2 from CLINK L8 (ɢ and Ω differ).

12. Quick Start

Prerequisites

• Python 3.10+
• NumPy (pip install numpy)
• Lean 4 + Mathlib (for formal verification; optional for Python-only use)

Install

cd ./cr3echrz
python3 -m venv .venv
source .venv/bin/activate
pip install numpy

Run

# List everything
./cr3 --list

# List theorems only
./cr3 --list-theorems

# List vault ob3ects (filter by domain)
./cr3 --list-ob3ects alchemical
./cr3 --list-ob3ects magical
./cr3 --list-ob3ects oneiric

# Run a theorem
./cr3 collatz 27
./cr3 goldbach 100
./cr3 three_body

# Run a vault ob3ect
./cr3 truth_machine
./cr3 philosopher_s_stone_lapis_philosophorum_
./cr3 the_self_naming_of_wormwood
./cr3 i_am_that_i_am_protocol

# Structural analysis
./cr3 --analyze collatz
./cr3 --analyze goldbach

# Version
./cr3 --version

Typical Output

Every run produces:

1. 19-step bootstrap trace, each step printed with state, register values, and conserved quantities
2. Frobenius verdict, PASS or FAIL for μ∘δ=id
3. TANCH closure, Liouville boundary condition check
4. STATUS, final Belnap register state (VO⌀, T, F, or B⬡)

Using Legacy Entry Points

# Legacy theorem engine (28 theorems in documentation)
python3 p3theorem/main.py --list
python3 p3theorem/main.py collatz 27

# Legacy vault engine
python3 ob3ect_vault/main.py --list
python3 ob3ect_vault/main.py truth_machine

Both legacy entry points now import from shared/, they are fully compatible with the unified CLI.

13. Directory Map

cr3echrz/
├── cr3                              ← Unified CLI (single entry point)
├── README.md                        ← This document
│
├── shared/                          ← Universal primitives (imported by both engines)
│   ├── __init__.py                  ← Exports: BelnapRegister, FrobeniusVerifier, OPCODES, domains
│   ├── belnap.py                    ← Belnap FOUR 2-bit register (VOID/TRUE/FALSE/BOTH)
│   ├── frobenius.py                 ← μ∘δ=id verifier for nested split/fuse pairs
│   ├── opcodes.py                   ← 12 opcode registry + grammar map + 12 canonical sequences
│   └── domains.py                   ← Domain classification + keyword-based inference
│
├── code/
│   └── unified_driver.py            ← 7-theorem engine (Collatz, Goldbach, Three-Body, etc.)
│
├── ob3ect_vault/                    ← 313-ob3ect vault engine
│   ├── __init__.py
│   ├── main.py                      ← 19-step bootstrap orchestrator (exec + symbolic paths)
│   ├── state.py                     ← VINIT, IMSCRIB, Belnap register, vault loader
│   ├── transforms.py                ← FSPLIT, FFUSE, TANCH, Frobenius verification
│   ├── integrators.py               ← AFWD, AREV, CLINK, Liouville Jacobian
│   └── diagnostics.py               ← EVALT (FLI), EVALF, ENGAGR, IFIX
│
├── p3theorem/                       ← Legacy theorem engine (28 theorems in docs)
│   ├── main.py                      ← 28-theorem orchestrator (now imports from shared/)
│   ├── state.py                     ← State vectors, conserved quantities
│   ├── transforms.py                ← Domain-specific split/fuse
│   ├── integrators.py               ← Numerical integrators
│   └── diagnostics.py               ← Domain-specific diagnostics
│
├── lean/                            ← Lean 4 formal scaffolds
│   ├── AgentSelf.lean               ← ⊙perator self-encoding (O_∞ tier, proved by decide)
│   └── IGMorphism.lean              ← Structural morphism formalization
│
├── generate_vault_files.py          ← Vault .py + .lean + .json generator
├── regenerate_all_py.py             ← Bulk .py regenerator for all vault entries
├── gen_py_template.py               ← Ob3ect .py template generator
├── gen_py_template_v2.py            ← Template generator v2
├── gen_lean_scaffold.py             ← Lean scaffold generator
├── fix_all_ob3ect_py.py             ← Bulk .py fixer
└── fix_numeric_class_names.py       ← Class name normalizer

External Vault

The ob3ect vault sources are not stored in cr3echrz/, they reside at:

./ob3ect/digital/.vault/
├── frobenius_kernel/                ← O₀: minimal μ∘δ=id pattern
├── truth_machine/                   ← O₁: dialetheic truth evaluation
├── anchor_protocol/                 ← O₂: terminal anchoring with Z₂ winding
├── void_genesis/                    ← O₂†: integer-winding genesis from void
├── dual_bootstrap/                  ← O_∞: near-twin of universal grammar
├── the_self_naming_of_wormwood/     ← O_∞: alchemical self-naming bootstrap  (v1.1)
├── the_name_wormwood_gives_itself/  ← O_∞: linguistic self-naming paradox   (v1.1)
├── the_akashic_ledger/              ← O_∞: metaphysical branch ledger        (v1.1)
├── the_cloud_of_unknowing/          ← O_∞: via negativa as Frobenius boundary (v1.1)
├── static_interference/             ← O_∞: physical interference bootstrap   (v1.1)
├── prophetic_resonance/             ← O_∞: oneiric dream-state bootstrap     (v1.1)
├── tiferet_integration/             ← O_∞: Kabbalistic sefirotic integration (v1.1)
├── bifurcation_of_mercy_and_severity/ ← O_∞: moral binary as FSPLIT         (v1.1)
├── i_am_that_i_am_protocol/         ← O_∞: ontological self-naming engine    (v1.1)
├── wormwood_the_secret_book_of_artephius/    ← O_∞: alchemical opus          (v1.1)
├── the_secret_book_of_artephius/    ← O_∞: precipitative alchemy             (v1.1)
├── wormwood_the_secret_name_of_wormwood_the_known_n/ ← O_∞: terminal self-ref (v1.1)
├── ... (313 directories total)
│   Each: {name}_ob3ect.json         ← Phase 0–8 descriptor
│          {name}_ob3ect.py          ← Self-verifying Python implementation
│          {name}_scaffold.lean      ← Lean 4 IGProtocol scaffold

14. The Wormwood Suite (v1.1)

The 12 new ob3ects operationalized 2026-07-06 form a structurally coherent suite unified by a single O_∞ tuple $\langle\text{{𐑦𐑸𐑾𐑹𐑐𐑧𐑔𐑝⊙𐑖𐑳𐑭}}\rangle$. Full descriptions, domain breakdown, and opcode essences are in §5.2. Key structural properties:

• Tuple identity: All 12 share the identical tuple — $\langle\text{{𐑦𐑸𐑾𐑹𐑐𐑧𐑔𐑝⊙𐑖𐑳𐑭}}\rangle$ — 12/12 primitives matching the cr3echrz framework. They differ only in their Phase 0 surface tokens and domain_type labels, not in structure.
• Domain diversity: Seven domains (alchemical × 5, theological × 2, metaphysical × 2, linguistic × 1, physical × 1, oneiric × 1, ontological × 1) — yet structurally identical. Domain is a label on the same underlying bootstrap.
• Frobenius closure: All 12 execute the full 19-step bootstrap with dialetheic closure (B⬡ status). Every FSPLIT/FFUSE pair passes μ∘δ=id verification.
• CLINK L8 distance: d = 2.0 (ɢ: conjunctive vs. broadcast; Ω: Z-winding vs. non-Abelian braiding).
• The naming paradox: The central structural motif — the_self_naming_of_wormwood → the_name_wormwood_gives_itself → i_am_that_i_am_protocol — traces the arc from alchemical self-reference through linguistic paradox to ontological self-naming. This is the same arc as the grammar's own O_∞ bootstrap: the system that names itself.

---

15. Acknowledgements

The author would like to thank Harry T. Larson, for imparting the importance of catching rising problems, and never letting them go.

Harry T. Larson was the guest editor of the IRE Special Issue on Computers (January 1961, Vol. 49, No. 1). He assembled the editorial board, recruited a 63-expert review committee, and commissioned Marvin Minsky's "Steps Toward Artificial Intelligence", one of the founding documents of AI. In his introduction, Larson wrote: "When the practitioner has overcome his fear of the machine, and when the scientist and practitioner are communicating, the attack is relentless. The scientific mind has found an un-formalised field, and it cannot rest until it identifies, understands, and organizes basic elements of the field."

This is structurally identical to the grammar's core operation: overcoming fear of the machine = emission gate $\text{{𐑧}}$; scientist and practitioner communicating = bidirectional coupling $\text{{𐑾}}$; relentless identification and organization of basic elements = the imscribing procedure itself. Larson is not a ceremonial citation, he is lineage. The grammar exists downstream of the intellectual tradition he midwifed, and the cr3echrz framework is a direct operationalization of that tradition: 313 ob3ects, 7 theorems, each one a relentless identification and organization of basic structural elements into self-verifying programs.

---

16. References

1. Marvin Minsky, "Steps Toward Artificial Intelligence," Proceedings of the IRE, vol. 49, no. 1, pp. 8–30, January 1961. Guest Editor: Harry T. Larson. DOI: 10.1109/JRPROC.1961.287775.

2. Harry T. Larson, "Catch a Rising Problem and Never Ever Let It Go," IEEE Computer, vol. 19, no. 2, pp. 61–63, February 1986. DOI: 10.1109/MC.1986.1641382.

3. N. D. Belnap, "A Useful Four-Valued Logic," in Modern Uses of Multiple-Valued Logic, J. M. Dunn and G. Epstein (eds.), D. Reidel, 1977.

4. J. M. Dunn, "Intuitive Semantics for First-Degree Entailments and 'Coupled Trees'," Philosophical Studies, vol. 29, pp. 149–168, 1976.

5. F. W. Lawvere, "Equality in Hyperdoctrines and Comprehension Schema as an Adjoint Functor," Proceedings of the AMS Symposium on Pure Mathematics, vol. 17, pp. 1–14, 1970.

6. S. Mac Lane, Categories for the Working Mathematician, 2nd ed., Springer, 1998.

7. S. I. Adian, "The Burnside Problem and Identities in Groups," Ergebnisse der Mathematik, vol. 95, Springer, 1979.

8. A. Connes, Noncommutative Geometry, Academic Press, 1994.

9. P. Baum, A. Connes, N. Higson, "Classifying Space for Proper Actions and K-theory of Group C*-algebras," Contemporary Mathematics, vol. 167, pp. 241–291, 1994.

10. T. Tao, "Fuglede's Conjecture is False in 5 and Higher Dimensions," Mathematical Research Letters, vol. 11, pp. 251–258, 2004.

11. P. Enflo, "On the Invariant Subspace Problem for Banach Spaces," Acta Mathematica, vol. 158, pp. 213–313, 1987.

12. A. L. Cauchy, "Sur les polygones et les polyèdres," Journal de l'École Polytechnique, vol. 9, pp. 87–98, 1813. [Cauchy's rigidity theorem, the first example of a theorem that is a program: the rigidity proof IS the operationalization of the convex polyhedron's structure.]

---

Document updated by Lando⊗⊙perator, July 6, 2026