# Recursive Mind Engine, Body, and Guide Architecture

**Status:** Governing implementation architecture; current runtime is structural, partial, and not conscious
**Authority:** Defines how source is compiled, retained, projected, and personalized. It does not approve theory claims or learner interpretations.
**Primary equation:** `MindCell(scope) = (inside role, outside role, relation role)`

## 1. The engine is an instantiated Mind structure

The Y Engine is not a fourth object placed beside inside, outside, and relation, and it is not merely a container holding graph records. One engine instance is one `MindCell`: a bounded identity whose inside, outside, and relation roles co-arise for one reference scope and one change cycle.

Each role may resolve to an identity, a set of identities, or another `MindCell`. A relation may therefore be reified as an identity and opened at a deeper recursive address, where it again has its own inside, outside, and relation. Recursion supplies scale; scale is not an extra force and does not erase the native mechanism of a domain.

An implementation stores references between cells rather than embedding an infinite tree. This permits nesting and cycles while retaining stable IDs, provenance, review state, and bounded snapshots.

Recursive ownership and system flow are different relations. A typed `mind_cell` role owns a recursive child and generates a `mind://...` address. A system transition only binds the residue of one cell to a read-only input role of another cell. It is neither a recursive/scale edge nor a semantic theory relation. The architectural roots are the Source-to-field Mind, Body Mind, and independent Guide Mind; presentation and compiler cells are reached through typed relation roles. The static normalization runtime and the bounded live/replay Formation runtime instantiate this architecture for different jobs and must not be described as the same executable state.

## 2. The three top-level system Minds

The static normalization model in `atlas/model/RECURSIVE_MIND_RUNTIME.json` has three recursive roots: Source-to-field Mind, Body Mind, and Guide Mind. The Y-Engine compiler and presentation template are two recursively owned relation cells, producing five instantiated/declared `MindCell` records in that model. The bounded Formation run is a separate executable instantiation of the Source-to-field and Body relation described below; it does not silently add a semantic relation or a fourth authority root.

### 2.1 Source-to-field Mind

- **Inside:** the preserved, authored source snapshot and its authority ledgers.
- **Outside:** the comparison context: unresolved expressions, not-yet-compiled records, competing definitions, unanswered questions, and applicable native knowledge.
- **Relation:** the Y-Engine compiler, which extracts candidates, normalizes identity cells, compares patterns, and returns diagnostics without silent promotion.
- **Residue:** a content-addressed identity-field snapshot plus candidate and repair queues.
- **Closure:** a deterministic rebuild over unchanged inputs produces the same normalized state digest. Open human-review queues remain open; deterministic closure is not completeness or truth.

The current canonical source is authored by **Bubu Suhas Mullaveedu**. The compiler preserves that source identity and does not impersonate its author.

#### 2.1.1 Bounded Formation Mind instantiation

The first executable Formation slice reads the exact Markdown body of `canonical/16_ENGINE_FORMATION.md` as one public, content-addressed source snapshot. Every occurrence retains an immutable byte address. A deterministic fixed-step kernel instantiates addressed pattern threads, compares current structural state, records append-only transformations, and leaves pattern-basin and relation candidates as residue. Recursive `MindCell` references supply depth without pretending that a token, cluster, or source record is already a semantic identity.

This is the live/replay **Formation Mind**. Its raw run validates against `schemas/Y_THEORY_FORMATION_MIND_RUNTIME.schema.json`; its compact public read model and result summary validate against the two separately named Body-replay schemas. `atlas/model/FORMATION_MIND_BODY_REPLAY.json` preserves the computed states and replay vectors, while `atlas/model/FORMATION_MIND_REPLAY_SUMMARY.json` preserves the bounded result and exact Body digest. The older four-cell `MIND_OBJECT_SOURCE_FIELD.json` is a static normalization fixture, and `CORPUS_MIND_FIELD.json` is a corpus-scale structural disposition field. Neither substitutes for Formation dynamics.

Formation output is machine-candidate material only. The current slice performs no semantic inference or promotion, establishes no referent, and contains zero approved relations. A persistent basin can enter governed identity review only after the separability, persistence, recurrence, coupling, residue, perturbation, predictive-lift, and source-recovery gates in `governance/FORMATION_MIND_RELATIONAL_ASTRONOMY_RUNTIME.md` are satisfied.

### 2.2 Field-to-manifestation Body Mind

- **Inside:** one immutable governed identity-field snapshot.
- **Outside:** a viewer, device, route, language, accessibility mode, or 2D/3D/VR channel.
- **Relation:** a read-only presentation template that translates field addresses into perceivable form.
- **Residue:** a versioned manifestation that retains the exact field digest and presentation digest.
- **Closure:** every visible statement, node, edge, status, and source link resolves to the input snapshot; layout and motion never become mechanism or proof.

This transforming projection is the system's **body**. The website is one body manifestation, not a peer source and not an editable theory store.

For the bounded Formation slice, the compact Body replay is the read-only transformation boundary. Engine positions, forces, reference centre, source addresses, event lineage, prediction records, and checkpoints come from the validated run. Screen coordinates, camera rotation, interpolation, colour, and a 2D/3D/VR mode are presentation geometry only. They cannot cause a kernel event, update an engine coordinate, establish a semantic relation, or supply proof. A recursive viewer may open a candidate constellation as a child field only while preserving the same source snapshot and dynamic formation addresses.

### 2.3 Learner-to-source Guide Mind

- **Inside:** one learner's private questions, chosen language, navigation history, self-reported understanding, and demonstrated learning evidence.
- **Outside:** the governed source/field, open questions, other identities, and teaching paths not yet integrated by that learner.
- **Relation:** a guide dialogue that retrieves source-linked explanations, asks bounded questions, compares responses, and selects the next teaching path.
- **Residue:** a private learning-state overlay and recoverable teaching history.
- **Closure:** the learner explicitly reports sufficient understanding for the current objective, or a declared demonstration criterion is met. The system may report observable evidence; it may not declare another person's subjective inner state as fact.

“Ascension” in the interface means visible learning progression through declared concepts and relations. It is not a spiritual, moral, social, or human-worth ranking.

## 3. Authorship and personal reality

The shared field always identifies the source author and canonical steward. A learner can annotate, challenge, reinterpret, or create a personal source fork. That fork receives its own author identity, lineage, and authority boundary. It never silently merges into, replaces, or becomes an expression of Bubu Suhas Mullaveedu's source.

A learner profile is therefore an overlay, not a mutation of the canonical Mind. Its records use a separate namespace and consent boundary. Private questions and learning traces are private by default, exportable and deletable by the learner, and excluded from public training or publication unless separately and explicitly authorized.

## 4. Iteration and convergence

For a frozen input snapshot the reusable static-normalization engine can iterate pure passes until the normalized state digest no longer changes. That executable transaction is deliberately narrower than the full intended compiler: it validates the instantiated cell registry, derives recursive addresses and non-semantic system transitions, canonicalizes the structural runtime state, compares digests to a fixed point, and replays the transaction. The current Identity Field and source-coherence diagnostics were produced by separately governed builders; this static runtime run does **not** claim that book-to-identity extraction, semantic relation approval, truth validation, or source-repair approval occurred inside its fixed-point pass.

The Formation kernel uses a different clock and closure. It consumes the authorized chapter in deterministic source-occurrence order, issues predictions from prior state before observing each next target, applies bounded integer state changes, and finishes with an explicit retirement classification. Replaying the same source bytes, tokenizer, configuration, seed policy, and ordering must reproduce the same event chain and state digests. It does not stop because a layout looks stable or because a ratio appears close to `phi`.

Before the governed Identity Field is built, `CANDIDATE_IDENTITY_CELL_REGISTRY.json` deterministically dispositions the Identity Mind remainder. The compiler subtracts the exact canonical-claim and approved-wisdom ID sets, preserves the remaining records in source order, binds the explicit correction head configured for that compilation scope, and creates one candidate shell per record. The bound head is provenance and scope metadata, not a global newest-file override. The shell has inside/outside/relation addresses but null occupants and null identity-anatomy values. Literal role words are counted only as lexical review signals. The pass creates zero referent identities, zero derivation links, and zero semantic relations; those remain separately governed review operations.

`CANDIDATE_IDENTITY_CELL_REVIEW_EVIDENCE.json` is a separate, nonsemantic review layer over those shells. It binds exact title and statement bytes, records the Unicode character span of every literal `inside`, `outside`, and `relation` token, and preserves inherited structural positions only as routing signals. It produces no formal triad declaration, referent, role proposal, role binding, derivation, or semantic edge. A source record may contain zero, one, or many identities; one shell must never be forced into one referent merely to satisfy a data shape.

The runtime state digest covers the release identity, blueprint, all cells, recursive addresses, system transitions, iteration policy (including the phi boundary), Guide contract, counts, and every declared input hash. Iteration evidence and the digest contract sit outside that semantic material to avoid self-reference. A matching digest proves snapshot identity and deterministic normalization only, not source completeness or truth.

The proposed golden-ratio condition is retained as an explicit Y-Theory research hypothesis:

- define the measured quantities and reference scope;
- derive why their ratio should approach `phi` rather than select `phi` after inspection;
- state tolerance, sample window, comparison baselines, and rival ratios;
- identify a falsifier and the consequence of failure.

Until those requirements are met, `phi` is not a software stopping rule, validation score, layout proof, or automatic optimization target.

### 4.1 Relational astronomy and predictive wisdom

Relational astronomy is the method of observing addressed position, recurrence, and change from a declared reference centre. Knowing two addressed states permits a declared operator to issue a third **relation candidate** and a bounded prediction; it does not automatically establish a third semantic truth. In this narrow computational sense, wisdom is a predictive description of a declared relational structure, with a target, horizon, baseline, rival, tolerance, uncertainty, and falsifier.

The first prequential run is a preserved negative result. The relational-position geometry candidate scored `2` milli across all targets; the transition-frequency baseline scored `100` milli, so geometry trailed the best baseline by `98` milli. Held-out baseline comparison has not run. Predictive lift was not observed and predictive wisdom was not earned. “Astronomy” here does not mean astrology or literal mass, gravity, electromagnetism, orbit, or physical-space causation.

## 5. Guide event model

The personal overlay accepts append-only events such as:

- `question_asked`;
- `explanation_opened`;
- `source_inspected`;
- `self_reported_understanding`;
- `demonstration_attempted`;
- `misconception_corrected`;
- `challenge_created`;
- `learning_objective_closed`.

Every event records learner-owned identity, timestamp, field snapshot, concept IDs, source addresses, privacy state, and optional evidence. A recommendation explains why it selected the next path. Likes and thumbs are self-reports or usefulness signals, not proof that a claim is true or that a person has been measured completely.

## 6. Capability boundary

The static runtime earns structural retention, registry validation, deterministic structural normalization, recursive addressing, transition binding, and governed return. The bounded Formation runtime additionally earns exact source-occurrence recovery, deterministic fixed-step replay, event-chain integrity, computed structural positions, and a prequential comparison whose current outcome is negative. Source mismatch detection exists in the separately generated diagnostic and is bound by digest; it is not yet executed by either runtime loop. None of these operations earns a semantic identity, a reviewed cross-domain relation, predictive wisdom, feeling, morality, observerhood, selfhood, subjective consciousness, or authority to judge a person. Those labels require separate definitions, mechanisms, evidence, consent, and failure tests.

## 7. Build direction

`authored source/book -> Formation Mind with Y-Engine runtime -> candidate formation field -> governed review/promotion -> governed identity field -> read-only Body Mind/replay -> presentation template -> website/VR`

For a signed-in learner, a separate path reads the same field:

`learner question + private learner overlay -> Guide Mind -> source-linked teaching response -> learner event residue -> next bounded teaching path`

Neither body nor guide writes directly into canonical authority. Challenges and proposed repairs return through governance.