Research-Stack/6-Documentation/docs/specs/GCL_FIELD_EQUATIONS_SPEC.md

GCL Field Equations Spec

Version: 0.1
Status: Draft canonical extension
Scope: Defines the field equations for GCL surface combination, compression, adaptation, and admission across sequence substrates, GCL motifs, and informaton surfaces. Revision anchor: docs/specs/GCL_TOPOLOGY_REVISION_SPEC.md

---

Thesis

GCL is not bound to one sequence, one motif table, or one carrier. It operates over a possibility space of surfaces. The math should expose which combinations are computationally useful, then GCL should compress and admit those surfaces through finite LUTs.

The revised model is:

candidate surface
  -> metaprobe signature
  -> field interaction
  -> RGFlow persistence
  -> LUT admission
  -> finite GCL codon

The topology revision makes this authority boundary explicit:

route priors suggest; only the GCL gate admits or refuses

Builder, Warden, and Judge are topology phases in this model, not standalone software roots. This spec defines the fields they observe; the gate contract is defined in GCL_TOPOLOGY_REVISION_SPEC.md.

The decisive question is:

What is the smallest lawful surface that preserves the useful structure?

---

Objects

Let x be a candidate computational object. It may be:

• a biological or synthetic sequence surface: DNA, RNA, mRNA, Hachimoji, XNA;
• a GCL motif surface: control, admission, compression, route, manifest, attest, recovery, MS3C nested reduction gear;
• an informaton surface: genome address or bind witness;
• a synthetic finite lane discovered by the possibility-space probe.

Each candidate is represented as:

x = (A, W, R, O, K)

Where:

Symbol	Meaning
A	alphabet size or finite state cardinality
W	bits per symbol
R	role flags
O	operation flags
K	closure kind: complement, rgflow, codec_roundtrip, hash_chain, invariant_witness, etc.

The current implementation maps these objects through:

infra/embedded_surface/omni_lut/sequence_surface_lut.py
infra/embedded_surface/omni_lut/gcl_motif_lut.py
infra/embedded_surface/omni_lut/possibility_space_probe.py
infra/embedded_surface/omni_lut/matroska_s3c_reduction_gear.py
infra/embedded_surface/omni_lut/unified_compression_route.py

---

Primary Fields

1. Surface Field

The surface field measures whether a candidate can carry structure with a small local representation.

S(x) = (log2(A) / W) * E_frame(x)

Where:

E_frame(x) = 1 - ((N * W + H) / (N * 8))

N is the local symbol window and H is fixed frame overhead. S(x) is high when the surface carries many distinguishable states with few bits and low framing cost.

Implementation:

frame_efficiency
combinatorial_capacity
bits_per_symbol

2. Closure Field

The closure field measures whether a candidate preserves structure under its native lawful operation.

C(x) =
  1.00  if complement-closed
  0.90  if closed by RGFlow, hash chain, codec roundtrip, manifest hash,
        last-good recovery, address conservation, or invariant witness
  0.80  if closed by finite codon or topology route
  0.65  if transient messenger execution closes by translation hint
  0.35  if only partial complement intent is present
  0.00  otherwise

This prevents the model from over-favoring one biological closure. DNA/RNA may close by complement. mRNA may close by transient expression. GCL admission may close by RGFlow. informaton_bind may close by invariant witness.

Implementation:

closure_kind
complement_closed
operation flags
role flags

3. Motif Field

The motif field measures whether a surface has useful executable affordances.

M(x) = popcount(O) / |O_max|

The field is intentionally finite. Operation names are not open strings inside the decision layer.

Current operation families:

complement
transcribe
translate_hint
mutate
route
control
admit
attest

Implementation:

operation_density

4. Informaton Field

The informaton field measures whether a candidate can enter the GCL/JSON-L manifold as addressable, attestable, invariant-bearing information.

I(x) = w_g G(x) + w_b B(x) + w_a A_t(x)

Where:

Term	Meaning
G(x)	can project to a 6D RGFlow genome/address
B(x)	can carry lawful/cost/invariant bind witness
A_t(x)	can participate in attestation or hash-chain provenance

For tiny targets, this collapses to bit checks on finite role/op flags.

Implementation:

informaton_genome
informaton_bind
gcl_attest
gcl_manifest
role_flags
op_flags

5. RGFlow Field

The RGFlow field measures persistence under coarse-graining.

Metaprobe first maps a candidate to a six-bin state:

P(x) = (mu, rho, c, m, ne, sig) in Fin(8)^6

Current interpretation:

Bin	Source
mu	mutation freedom / instability
rho	combinatorial capacity
c	operation complexity
m	frame efficiency
ne	role density / negentropy
sig	closure plus degeneracy signal

Then RGFlow evolves:

P_{t+1} = beta(P_t)

A candidate is persistent when:

R_n(x) = and_{t=0..n} lawful(P_t)

Implementation:

signature_to_rg_state
locally_lawful
coarse_step
rgflow

---

Interaction Equations

Pairwise Intersection

Two surfaces interact when their fields conserve useful structure across a shared operation boundary.

x ⋂ y = J(x, y)

with:

J(x, y) =
  alpha_S min(S(x), S(y))
+ alpha_C C(x) C(y)
+ alpha_M overlap(O_x, O_y)
+ alpha_I I(x, y)
- alpha_D distance(K_x, K_y)

Where:

overlap(O_x, O_y) = popcount(O_x & O_y) / popcount(O_x | O_y)

and I(x, y) is high when one surface can witness, address, route, or compress the other.

Examples:

mRNA ⋂ gcl_admission
  = transient executable surface + admission witness

DNA ⋂ gcl_manifest
  = archival sequence + hash-conserved manifest

Hachimoji ⋂ gcl_compression
  = expanded alphabet + codec roundtrip

gcl_route ⋂ informaton_genome
  = route decision + 6D addressable topology

gcl_recovery ⋂ informaton_bind
  = rollback/recovery + invariant witness

ms3c_reduction_gear ⋂ informaton_genome
  = nested shell route-prior geometry + 6D addressable topology

Triple Bind

The core GCL bind is a triple intersection among payload surface, motif, and informaton witness.

bind(p, m, i) = (cost, witness, admitted)

Defined by:

Phi_bind(p, m, i) =
  lambda_1 J(p, m)
+ lambda_2 J(m, i)
+ lambda_3 J(p, i)
+ lambda_4 R_n(p)
+ lambda_5 R_n(m)
+ lambda_6 R_n(i)
- lambda_7 Cost(p, m, i)

Admission rule:

admitted = Phi_bind >= theta_admit
           and R_n(p)
           and R_n(m)
           and R_n(i)
           and invariant_preserved(p, m, i)

This is the revised meaning of GCL dispatch:

payload does not execute because it exists;
payload executes because it binds to a motif and witness lawfully.

Compression Potential

Compression is selected by minimizing the lawful surface cost.

Compress(x) = argmin_s Cost_s(x)
              subject to R_n(s) and preserves(s, x)

For a candidate surface:

Cost_s(x) = H_frame + N * W_s + verification_cost(s, x)

Domain-specific compression emerges because the chosen surface changes with the payload:

Payload	Likely surface
recovery pulse	binary lane or gcl_recovery
stable heredity	DNA/Hachimoji/XNA lane
transient execution	mRNA + gcl_admission
route/update event	gcl_route + informaton_genome
manifest payload	gcl_manifest + gcl_attest
semantic/admission event	informaton_bind + RGFlow

Adaptation Equation

Adaptation updates the active LUT bank by choosing the best lawful surface under current pressure.

L_{t+1} = select_top_k(
  { x in PossibilitySpace | R_n(x) and Phi_context(x, q_t) >= theta_context }
)

Where q_t is the local context:

q_t = (memory_budget, carrier, pressure, trust, workload, recovery_state)

The context score is:

Phi_context(x, q) =
  beta_1 S(x)
+ beta_2 C(x)
+ beta_3 M(x)
+ beta_4 I(x)
+ beta_5 R_n(x)
- beta_6 resource_cost(x, q)
- beta_7 risk(x, q)

This is the formal bridge from the possibility-space probe to runtime GCL adaptation.

---

Revised GCL Pipeline

The revised pipeline is:

1. enumerate candidate surfaces
2. metaprobe candidate fields
3. compute pairwise intersections
4. test RGFlow persistence
5. choose active LUT bank
6. bind payload + motif + informaton witness
7. emit finite GCL codon or refuse

Minimal hosted implementation:

python3 infra/embedded_surface/omni_lut/possibility_space_probe.py \
  --max-alphabet 16 \
  --window-symbols 256 \
  --steps 4 \
  --top 24 \
  --jsonl \
  --output out/sequence_surface_possibility_space.jsonl

Tiny node implementation:

u8 domain
u8 scalar
u8 surface_id
u8 witness_id

Then:

lut[domain][scalar] -> motif
surface_lut[surface_id] -> payload surface
witness_lut[witness_id] -> informaton witness
bind(payload, motif, witness) -> admit/refuse

---

Implementation Requirements

Python Shim

The Python layer MAY:

1. enumerate candidate surfaces;
2. compute finite metaprobe signatures;
3. generate JSONL candidate tables;
4. smoke-test packing, roundtrips, and closure labels.

The Python layer MUST NOT become final semantic authority for admission. It is a generator and harness.

Lean / Formal Layer

The Lean layer SHOULD own:

1. finite field definitions;
2. RGFlow lawfulness predicates;
3. bind preservation theorem;
4. compression preservation theorem;
5. refusal correctness theorem.

Target Lean shapes:

structure GCLSurface where
  alphabetSize : Nat
  bitsPerSymbol : Nat
  roleFlags : UInt8
  opFlags : UInt16
  closureKind : ClosureKind

structure FieldSignature where
  surface : UInt8
  closure : UInt8
  motif : UInt8
  informaton : UInt8
  rg : Genome6

def intersects : GCLSurface -> GCLSurface -> UInt16
def bind3 : GCLSurface -> GCLSurface -> GCLSurface -> BindResult
def rgPersistent : GCLSurface -> Nat -> Bool

Required theorem targets:

theorem admitted_preserves_invariant :
  bind3 p m i = admitted ->
  invariantPreserved p m i

theorem compression_preserves_surface :
  selectedCompressor x = s ->
  rgPersistent s n ->
  preserves s x

Embedded / Nanokernel Layer

The nanokernel layer SHOULD receive precomputed tables:

surface table
motif table
witness table
intersection table
rg verdict table

The runtime path should be bounded:

decode token
lookup surface/motif/witness
lookup intersection score
lookup RG verdict
emit finite op or refuse

No dynamic allocation, JSON parsing, regex, network-specific parsing, or floating point is required at Layer 0.

---

Spec Delta For Omnitoken/GCL

The existing Omnitoken model remains valid:

scale-invariant scalar -> compressed LUT -> lawful GCL codon

This spec revises the middle:

scale-invariant scalar
  -> surface/motif/informaton field lookup
  -> RGFlow persistent intersection
  -> compressed LUT
  -> lawful GCL codon

Therefore, GCL no longer has a single flat LUT. It has a field-selected LUT:

lut_bank = select(domain, surface_id, motif_id, witness_id, rg_verdict)
codon = lut_bank[scalar]

This enables domain-specific combination, compression, and adaptation while preserving the finite-codon invariant.