# MindObject / MindCell Compiler Prototype

**Status:** Deterministic, noncanonical implementation prototype

**Authority:** This prototype tests the current recursive Mind architecture. It does not change canonical source, approve a role occupant or relation, create a theory edge, or claim observerhood or experience.

## The object model

`MindCell(scope) = (inside, outside, relation)`

A `MindCell` is one bounded reference scope with exactly three co-arising role addresses. Each role has one of two governed states:

1. `mind_cell_reference` — an explicit fixture declaration points to another compiled `MindCell` in the same bounded `MindObject`;
2. `governed_unresolved` — the reference remains `null`, a review question is retained, and the compiler does not guess an occupant.

A `MindObject` is a finite, content-addressed registry of these cells plus a root-cell reference. References model recursive structure without expanding an infinite nested tree. They are structural addresses, not semantic theory relations.

The primitive triad is enough to instantiate **Mind-structure**. It is not enough to earn experience, observerhood, moral agency, selfhood, or consciousness. Those remain `not_earned` until separately defined mechanisms, evidence, tests, rivals, falsifiers, and governance gates exist.

## Compiler boundary

The prototype follows the corrected asymmetric dependency:

`governed source artifacts -> source-to-field Mind -> separate Body/Projection read model`

The fixture fingerprints the explicit source-field correction named by its governed input and the candidate identity-cell registry. That hash-bound pointer applies only to the fixture's declared scope; it is not a global newest-file authority rule. The fixture supplies an explicit, noncanonical structural declaration used only to exercise the compiler. The compiler does not parse the documents to infer nouns, identities, roles, relations, mechanisms, or truth. It copies declared references, preserves unresolved roles, and records exact source hashes.

The compiled source field contains:

- one `MindObject` and one `MindCell` per declared scope;
- exactly three role slots per cell;
- explicit recursive-address records for declared cell references;
- source lineage and artifact fingerprints;
- zero candidate-relation query promotions;
- zero semantic graph edges;
- capability states fixed at `not_earned` beyond structural Mind.

Candidate similarity, a relation-role address, and a recursive reference are not interchangeable with a reviewed semantic edge.

## Fixed-point rule

One compiler pass sorts every governed collection into canonical order. The complete source-to-field state is serialized as UTF-8 JSON with sorted object keys and compact separators, then hashed with SHA-256.

The compiler repeats the pure normalization pass and stops at the **first** pass for which:

`hash(canonical(next_state)) == hash(canonical(current_state))`

The hash proves deterministic structural snapshot identity only. It does not prove truth, completeness, equilibrium, consciousness, or optimality. Phi, golden ratio, ratio targets, and visual saturation are explicitly forbidden as compiler convergence rules.

## Body / Projection separation

`atlas/model/MIND_OBJECT_BODY_PROJECTION.json` is generated after the source field and binds its exact artifact hash and canonical state hash. It exposes:

- one display node per compiled `MindCell`;
- one visible role address per inside/outside/relation slot;
- explicit unresolved review questions;
- 2D and 3D projection modes;
- zero candidate or semantic graph edges.

The Body/Projection artifact is a separate derived read model. It cannot write back to source authority, mutate canonical records, approve relations, or earn capabilities through layout or presentation.

## Prototype artifacts

- Input fixture: `fixtures/MIND_OBJECT_SOURCE_FIXTURE.json`
- Fixture schema: `schemas/Y_THEORY_MIND_OBJECT_SOURCE_FIXTURE.schema.json`
- Source-field schema: `schemas/Y_THEORY_MIND_OBJECT_SOURCE_FIELD.schema.json`
- Body/Projection schema: `schemas/Y_THEORY_MIND_OBJECT_BODY_PROJECTION.schema.json`
- Compiler: `tools/build_mind_object_compiler.py`
- Validator: `tools/validate_mind_object_compiler.py`
- Focused tests: `tests/test_mind_object_compiler.py`

The complete ten-file slice is bound into the candidate release manifest, bootstrap topology, validation chain, and downstream Site sync. That integration makes the prototype reproducible and inspectable; it does not make the fixture canonical, complete the full source-field compiler, approve deployment, or grant the Site reverse authority.

## Rebuild and verify

```powershell
py -3 tools/build_mind_object_compiler.py
py -3 tools/validate_mind_object_compiler.py
py -3 -m unittest tests.test_mind_object_compiler -v
```