cECT Operational Engine

cECT stands for computable Embodied Constructor Theory.

It is a reliability-based operational framework that models knowledge not as passive information, but as physically efficacious capacity: the ability of a system to improve coupling with its environment, accumulate knowledge potential, and admit new tasks only when reliable execution is supported.

This repository contains:

• the cECT operational engine,
• a mathematical foundations paper,
• an AI engineering / LMM companion paper,
• and the Zenodo-linked publication materials.

cECT Extended Minimal Operational Engine

Paper-derived implementation with an axiom-audit layer for CT-1, CT-2, CT-3, and ECT-E.

This repository is the GitHub-ready companion package for the archived software release and two associated papers.

Canonical Zenodo records

Artifact	Role	DOI
Software archive	Citable archived software release	10.5281/zenodo.19627218
Mathematical foundations paper	Formal derivation and theoretical basis of the code	10.5281/zenodo.19626145
LMM / AI-engineering companion paper	Engineering interpretation of cECT for LMM-based agents	10.5281/zenodo.20338895

Use Zenodo as the archival and citable publication record. Use GitHub as the development, companion, and discoverability repository.

Associated papers

This repository includes two companion papers under papers/:

papers/
├─ 01-mathematical-foundations/
│  ├─ README.md
│  └─ knowledge_as_explanatory_physical_capacity_mathematical_foundations.pdf
├─ 02-ai-engineering-companion/
│  ├─ README.md
│  ├─ formalizing_autonomous_task_admission_lmm_companion.pdf
│  └─ formalizing_autonomous_task_admission_lmm_companion.docx
└─ LICENSE-PAPERS.md

1. Mathematical foundations paper

Title: Knowledge as Explanatory Physical Capacity: Toward a Computable Architecture in Constructor-Theoretic Terms - Extended edition with formal derivation of operational variables

DOI: 10.5281/zenodo.19626145

This paper explains how the operational variables Q, M, omega, and KP arise from the constructor-theoretic framing and the embodiment condition. It is the formal theoretical basis from which the code architecture is derived.

2. LMM / AI-engineering companion paper

Title: Formalizing Autonomous Task Admission in Multimodal Agents: A Reliability-Based Meta-Controller for Latent World Models

DOI: 10.5281/zenodo.20338895

This paper translates the same cECT architecture into an AI-engineering framing for Large Multimodal Models (LMMs), agentic AI, task admission, reliability gating, and capability-hallucination control.

How to cite

• If you use the software implementation, cite the software DOI: 10.5281/zenodo.19627218.
• If you discuss the formal derivation of the operational variables, cite the mathematical foundations paper: 10.5281/zenodo.19626145.
• If you discuss the AI-engineering interpretation for LMMs and agentic AI, cite the LMM companion paper: 10.5281/zenodo.20338895.

Machine-readable citation metadata for the software and related papers is provided in CITATION.cff.

Project structure

cect-extended-minimal-operational-engine/
├─ README.md
├─ CITATION.cff
├─ LICENSE
├─ requirements.txt
├─ paper_extended_axiom_audit_engine.py
├─ example_run.py
├─ sample_extended_audit_report.json
├─ package_manifest.json
├─ metadata/
│  └─ zenodo_records.json
├─ papers/
│  ├─ 01-mathematical-foundations/
│  │  ├─ README.md
│  │  └─ knowledge_as_explanatory_physical_capacity_mathematical_foundations.pdf
│  ├─ 02-ai-engineering-companion/
│  │  ├─ README.md
│  │  ├─ formalizing_autonomous_task_admission_lmm_companion.pdf
│  │  └─ formalizing_autonomous_task_admission_lmm_companion.docx
│  └─ LICENSE-PAPERS.md
├─ docs/
│  └─ GITHUB_PUBLICATION_GUIDE_EN.md
├─ .gitattributes
└─ .gitignore

Operational core

The implementation preserves the operational core:

• e_t = S_t - Q_t
• Q_{t+1} = Q_t + l_Q * omega_t * e_t
• M_{t+1} = delta * M_t + l_M * omega_t * (g_t - S_t)
• Delta_t = |e_{t-1}| - |e_t|
• KP_{t+1} = max(0, KP_t + rho_plus * max(Delta_t, 0) - rho_minus * max(-Delta_t, 0))
• omega_{t+1} = clip(omega_t + l_omega * Delta_t)
• A_t = clip(beta_Q * (g_t - Q_t) + beta_M * M_t)
• E_{t+1} = U(E_t, A_t)

What this implementation adds

This version adds the formal audit layer implied by the mathematical foundations paper:

• audit of CT-1, CT-2, CT-3, and ECT-E;
• theorem dependency table for Q, M, omega, and KP;
• derivation trace D1-D7;
• JSON export of operational history and audit history.

Files

• paper_extended_axiom_audit_engine.py - main engine.
• example_run.py - minimal runnable example.
• sample_extended_audit_report.json - sample audit output.
• requirements.txt - Python dependencies.
• CITATION.cff - citation metadata.
• papers/ - associated theoretical and engineering papers.
• metadata/zenodo_records.json - DOI metadata for the three artifacts.

Minimal example

from paper_extended_axiom_audit_engine import ExtendedPaperEngine, Task

engine = ExtendedPaperEngine()
engine.set_environment(2.0)
engine.set_goal(0.0)

engine.add_task(Task(name="reach_zero", target=0.0, tolerance=0.15))
engine.run(steps=10)

print(engine.summary())
engine.export_json_report("extended_audit_report.json")

Important note

This code reflects the extended paper faithfully at the operational level and adds an axiom-audit layer consistent with the formal derivation.

It does not claim that the open operators are fully closed by the theory itself. The following remain overridable on purpose:

• sigma
• U
• OmegaT
• Gamma

This matches the paper's explicit statement that these operators correspond to the particular physics of the implemented constructor.

License

• Software/code: MIT License, see LICENSE.
• Papers: the papers retain the license stated in their respective Zenodo records. See papers/LICENSE-PAPERS.md.

Suggested GitHub repository description

Paper-derived cECT operational engine with Q, M, omega, KP, task admissibility, and an axiom-audit layer; companion repository for Zenodo DOI 10.5281/zenodo.19627218.