Skip to main content

68  Coil Attention, Cyclic Memory, and Recurrence Contracts

68.1 Chapter status

Field	Value
Chapter ID	coil-attention-cyclic-memory-and-recurrence-contracts
Part	Part III - Routing, Compression, Representation, and Substrates
Status	conceptual
Manuscript maturity	v0.3 manuscript draft
Last updated	2026-08-03
Primary source records	coil_attention_memory, circle_ai_contract_suite, theseus_circle_transfer, vcm_public, ext_universal_transformer_2019, ext_recurrent_transformer_2026, ext_dynamic_compute_recurrent_transformers_2026
Claim label	Design rationale
Evidence level	argument
Source queue	primary: coil_attention_memory, circle_ai_contract_suite; supporting: theseus_circle_transfer, vcm_public, verification_bandwidth; external variants: ext_transformer_xl_2019, ext_compressive_transformer_2019, ext_retnet_2023
Source loading state	source notes: coil_attention_memory, circle_ai_contract_suite, theseus_circle_transfer, vcm_public, ext_universal_transformer_2019, ext_recurrent_transformer_2026, ext_dynamic_compute_recurrent_transformers_2026; raw cache: vcm_public
Test state	cyclic_memory_contract.valid.json passes repository-level protocol fixture validation for memory authority, VCM packet refs, state-carry boundary, stale-read policy, admission state, baseline refs, probe requirements, authority non-widening, residuals, and non-claims; AsiStackProofs.CoilAttentionMemory implements finite alias-boundary and coverage/freshness quality-promotion gates plus negative cases for hidden aliasing, structure-only quality promotion, missing recurrence budget/exit/fallback records, and stale reads admitted as fresh without residual escrow; python3 scripts/validate_cyclic_memory_contracts.py passes on 3 valid and 6 expected-invalid synthetic structural-memory fixtures for alias visibility, sparse-coverage fallback, recurrence budget/exit, stale-read residualization, structural-quality non-promotion, and support-state non-promotion; python3 scripts/validate_circle_cyclic_memory_receipt_slice.py validates one Circle cyclic-memory receipt slice with CC-AI-CONTRACT-MEMORY-001, same-residue events [7, 15, 23, 31], same-residue windings [0, 1, 2, 3], max_alias_load=4, and 3 passed in 2.51s; python3 scripts/validate_circle_kv_cache_receipt_slice.py validates one Circle KV-cache receipt slice with CC-AI-CONTRACT-KV-001, kind kv_cache_ring_buffer, theorem IDs AIM-T0103, AIM-T0104, AIM-T0149, theorem_count=54, strict receipt fingerprint bfebf150ce45d1eb124ea553bf2ba8c62008751ebec9f8600b83cc09e0526a46, stale_probe_first_stale_token=12, sink-window policy fields, 5 passed in 1.27s, and no-promotion decision circle_kv_cache_receipt_no_change.json; python3 scripts/validate_circle_recurrence_receipt_slice.py validates one Circle recurrence receipt slice with CC-AI-CONTRACT-RECURRENCE-001, kind recurrence_schedule, theorem IDs AIM-T0026, AIM-T0130, AIM-T0159, theorem_count=64, strict receipt fingerprint 571edd5dce4f7b64441806de323295218a3e2293b3b540dd4772ba34b9371515, active/inactive token work fields, whole-period shift invariants, 2 passed in 2.37s, and no-promotion decision circle_recurrence_receipt_no_change.json; python3 scripts/validate_circle_sparse_attention_receipt_slice.py validates one Circle sparse-attention receipt slice with CC-AI-CONTRACT-SPARSE-001, kind sparse_attention_coverage, theorem IDs AIT-T0104, AIT-T0172, theorem_count=141, strict receipt fingerprint c23809cef9b821b1e4f9cabf53fcac724a0757bf3f86594e1d12710fe0cd9ec1, coverage_complete=false, first_uncovered_lag=5, uncovered_lag_count=109, covered_lag_count=10, complete_repair_window=119, complete_repair_window_additional_local_slots=115, complete_repair_window_minimal_for_declared_stride_family=true, complete_repair_window_minimal_witness_lag=119, interval_repair_plan_step_count=6, lag_collision_pair_count=0, query_collision_pair_count=0, 10 passed in 1.87s, and no-promotion decision circle_sparse_attention_receipt_no_change.json. No deployed KV-cache behavior, deployed recurrence behavior, deployed sparse-attention behavior, sparse-attention coverage success, serving throughput, memory savings, paging correctness, retrieval-quality, long-context, model-quality, reasoning-quality, speed, memory-scaling, deployment, transfer, ASI, or support-state-transition claim is made.

68.2 Drafting guardrail

Cyclic memory earns a route only through structural facts that downstream consumers can check: coverage, freshness, aliasing, recurrence budget, exit, and fallback. Those facts can govern admission without standing in for retrieval quality, reasoning quality, longer usable context, speed, memory reduction, or model improvement.

Proof-carrying receipts preserve finite structural boundaries. Memory and recurrence need that same receipt discipline because the tempting overclaim is semantic: a slot is fresh, a lag is covered, or a loop exits, therefore the model must remember or reason better. The ASI Stack keeps those facts useful by treating them as guardrails for admission, fallback, and residual handling rather than as task-success evidence.

The chapter is therefore about admission control for memory structures. A cyclic or sparse mechanism may be allowed to participate in a task only when its structural contract matches the task’s authority, freshness, coverage, and fallback requirements.

68.3 Human Reading Path

Concrete lens. The simpler cache checks only residue and returns fluent stale content. The governed path binds winding and request version, contains every suffix after stale detection, and preserves fallback.

Proof-carrying receipts become especially important for memory and recurrence, where structural language can sound like semantic understanding. Cyclic memory, sparse coverage, freshness, lag, and recurrence schedules need records before anyone treats them as reasoning quality.

A fresh slot is not a true belief, and a covered lag is not a solved task. Recurrence contracts should preserve structural facts, authority limits, and fallback paths while leaving semantic claims to verification and evidence.

That boundary lets cyclic memory remain useful without overselling it. Structural guarantees can improve admission, fallback, and routing decisions while still requiring separate tests for retrieval quality, reasoning quality, and task success. A loop earns trust when freshness, coverage, lag, exit conditions, and downgrade paths are visible to later consumers.

The contract protects the idea by refusing to let structure impersonate understanding. Useful recurrence should make memory easier to audit, not harder to question. The loop becomes architectural when its guarantees stay separate from its hopes, and when each later use can tell whether it is relying on a proven structural fact, a useful heuristic, or an untested expectation.

68.4 Problem

Long context and recurrence can fail in quiet ways: stale reads, duplicate requests, uncovered lags, alias collisions, non-terminating loops, overthinking, or hidden work. Coil Attention and Memory contributes a useful frame: finite cyclic structures can make some of these hazards visible, but visibility is not the same thing as quality.

Memory and attention records must distinguish structural facts from semantic success. A ring buffer can say which slots are live. It cannot prove that the retrieved content is useful. A sparse orbit can say which lags are covered. It cannot prove that arbitrary dependencies were captured.

Cyclic structure itself is not the failure; claim confusion around cyclic structure is. Recurrence can help preserve local state, expose coverage, and create cheap structural checks. It can also hide stale memory, repeated reasoning loops, and false confidence about long-context adequacy. The contract has to make the cheap facts visible while keeping quality claims blocked until retrieval and task evidence exist.

68.5 Why existing approaches are insufficient

Long context, sparse attention, ring buffers, and recursive loops can silently hide stale reads, uncovered lags, duplicate slots, alias collisions, or unbounded work. A residue-only memory slot can hide how many times the address wrapped. A recurrence schedule can reduce active tokens while creating a loop that never exits. A freshness certificate can become false evidence if the task needs semantic coverage rather than slot coverage.

VCM and Verification Bandwidth reinforce the boundary: context admission, context adequacy, freshness, and verification capacity are different things.

The reader-facing distinction is structural memory versus useful memory. Structural memory can say that a slot exists, a version is current, a stride covers a lag, or a recurrence loop has an exit. Useful memory requires the retrieved material to help the task under the current claim, authority, and adequacy boundary. The first kind of fact is necessary for disciplined systems work. The second kind needs workload evidence.

Long-context systems often fail by sounding continuous while their memory contract is broken. A stale cell may still be fluent. A covered lag may still be irrelevant. A recurrence loop may produce more text while making no progress. The contract gives later validators a place to look for those failures before they become invisible inside a model trace.

Finite proofs and learned behavior meet at the sharpest gap. A finite proof can certify a slot property, coverage property, or loop-exit property. It cannot certify that a learned model used the right information in the right way unless a workload-specific evaluation supplies that evidence.

External positioning: Coil Attention now has source-noted recurrence and long-context comparators through ext_transformer_xl_2019, ext_compressive_transformer_2019, and ext_retnet_2023. Transformer-XL grounds segment-level recurrence and positional treatment as an ordinary recurrent-Transformer baseline. Compressive Transformers ground compressed past-memory mechanisms and long-range sequence benchmarks. RetNet grounds the attention/recurrence tradeoff and recurrent or chunkwise computation modes. These sources position Coil Attention against known sequence-memory families, but they do not reproduce any external result here and they do not support a Coil retrieval-quality, reasoning-quality, speed, memory-savings, or long-context claim.

68.6 Core Claim

[coil-attention-cyclic-memory-and-recurrence-contracts.core, label: Design rationale, support: argument] Coil Attention, Cyclic Memory, and Recurrence Contracts owns a memory-object-, state-version-, request-, consumer-, workload-, structural-axis-, budget-, and time-specific State-Carry and Recurrence Admission Lease: a slot read, cyclic address, KV reuse, sparse edge, fanout schedule, or recurrent step may be admitted only when authority, provenance, residue and winding, freshness, coverage, alias and collision state, active work, progress, exit, fallback, expiry, and residuals satisfy the exact consumer contract; structural validity, synthetic fixtures, receipt replay, cache presence, or reduced scheduled work alone confers no retrieval, reasoning, context-length, quality, speed, memory, safety, deployment, transfer, support, or SOTA authority.

Reader claim. A cache hit is safe to reuse only when it names the same state, request, version, and freshness boundary; matching a ring-buffer slot is not enough.

Operational rule. Record residue and winding, test freshness and coverage, cap recurrent work, and keep a working fallback. A missing winding, stale suffix, uncovered lag, or exhausted recurrence budget rejects reuse rather than silently degrading the answer.

68.6.1 Worked stale-cache trace: the fluent answer that must be rejected

Consider a long-context request whose live memory has wrapped around a finite ring. The requested token maps to residue slot 7, but events at logical addresses 7, 15, 23, and 31 all share that residue. A residue-only lookup returns fluent text from the wrong winding. The contract therefore binds the winding and request version before reuse; after stale detection, every suffix is barred from being relabeled fresh and is sent through the declared fallback.

The local finite model makes this boundary inspectable. It contains 40 reachable states and 320 checked transitions, including 24 stale-suffix states and 192 containment transitions. Three mismatch paths reach fallback, while 11 lifecycle mutations and 17 semantic mutations reject attempts to hide aliasing, omit exit or budget state, promote structural coverage to retrieval quality, or admit a stale read as fresh. These are authored finite-state checks, not a long-context quality result. They show why a cache entry needs custody metadata even when its content looks plausible.

The distinct owner is structural admission of a named carried state or recurrent step. VCM retains semantic object and authority truth; Runtime and Serving retain actual cache behavior; Deliberation retains the purpose of extra inference; Resources retain full cost; Verification retains retrieval and reasoning adequacy; Release retains public authority. This lease can refuse an unsafe or structurally invalid reuse, but cannot declare the reused state useful.

Coil and transfer source mappings ground the discussion of cyclic memory slots, winding/provenance, KV freshness, sparse coverage, recurrence schedules, loop exits, transfer gates, governed context boundaries, and explicit non-claims. They do not support learned model-quality, retrieval-quality, long-context, speed, memory-savings, or transfer-result claims in this repository.

68.6.2 Claim-source mapping status

Appendix C records exact passage-reviewed mappings for all seven assigned sources. The mappings support structural contracts for aliasing, freshness, sparse coverage, recurrence schedules, transfer boundaries, governed context, shared-weight recurrence, recurrent KV state, and adaptive compute. They do not establish retrieval quality, reasoning quality, long-context performance, memory savings, speed, or local reproduction of external results.

Source	What it supports	Limit
coil_attention_memory	Cyclic memory, KV-cache freshness, sparse-attention coverage, strided fanout, recurrence schedules, loop exits, work budgets, residue/winding/provenance, and alias diagnostics.	Structural source only; Circle cyclic-memory, KV-cache, recurrence, sparse-attention, and strided fanout receipt slices import bounded external-project fixture facts, but no learned-model experiment, retrieval-quality test, search-quality test, routing-quality test, performance test, serving-throughput measurement, memory-savings measurement, paging-correctness result, deployed recurrence-controller result, deployed sparse-attention or fanout result, or long-context result was run.
circle_ai_contract_suite	Theorem-linked contract families and consumer fields for KV-cache freshness, sparse attention, strided fanout, recurrence schedules, cyclic memory residue/winding, multicoil phase, and explicit non-claims.	Separate external Circle receipt slices are recorded for RoPE in docs/circle_external_receipt_slice.md, for cyclic memory in docs/circle_cyclic_memory_receipt_slice.md, for KV-cache ring-buffer structure in docs/circle_kv_cache_receipt_slice.md, for recurrence schedules in docs/circle_recurrence_receipt_slice.md, for sparse-attention gap/fallback structure in docs/circle_sparse_attention_receipt_slice.md, and for finite strided candidate-fanout structure in docs/circle_strided_fanout_receipt_slice.md; the KV, recurrence, sparse, and fanout slices are local external-project structural receipts only, not deployed behavior, serving, paging, search-quality, retrieval-quality, routing-quality, runtime, reasoning-quality, long-context, or support-state results.
theseus_circle_transfer	Report-only transfer discipline for cyclic-memory and recurrence fixtures, with quality/runtime/memory/transfer/failure-case axes separated from deterministic structural smoke checks.	No Circle-to-Theseus consumer, structural smoke workload, proxy benchmark, scored private benchmark, private inference/report artifact, or aggregate feedback handoff was executed or imported.
vcm_public	Governed context boundaries: semantic objects, immutable versions, packets, materializations, source/authority binding, adequacy/admission separation, taint, revocation, invalidation, audit records, and non-success states.	VCM control-plane source only; it does not prove recurrence quality, retrieval quality, long-context performance, learned memory behavior, or arbitrary KV-cache composition safety.
ext_universal_transformer_2019	Shared-weight depth recurrence, parallel self-attention, and adaptive halting as a historical state/progress/stopping comparator.	No local model, checkpoint, halting controller, stability, quality, or efficiency result is imported.
ext_recurrent_transformer_2026	Layerwise recurrent KV memory, exact tiling, effective-depth/width, and autoregressive cache cost as a current comparator.	No local checkpoint, cache, kernel, hardware, quality, context, or production result exists.
ext_dynamic_compute_recurrent_transformers_2026	Difficulty-dependent recurrent compute and complexity-controlled depth as a progress, work, calibration, and overthinking comparator.	No local controller, difficulty label, compute-quality result, generalization result, or reproduction exists.

68.7 Mechanism

Cyclic memory becomes useful when it exposes mistakes that ordinary long-context language hides. coil_attention_memory supplies the structural contract family: residue plus winding, freshness windows, sparse-coverage gaps, recurrence budgets, loop exits, and alias diagnostics. The Circle contract suite supplies theorem-linked receipt language, Theseus transfer keeps structural smoke checks separate from learned-model claims, and VCM keeps context adequacy, authority, taint, invalidation, and admission separate from memory success.

A Cyclic Memory Contract records the finite facts that can be checked while preserving the non-claim that those facts do not prove retrieval, reasoning, speed, memory reduction, or longer usable context. It also records the governing context authority, VCM packet refs, state-carry boundary, admission state, baseline obligations, probe requirements, residuals, and the rule that mapping context into cyclic structures cannot widen authority.

The contract is especially useful at the boundary between VCM and model internals. VCM can say what context object was admitted, which authority labels and adequacy labels came with it, and which versions or taints matter. The cyclic-memory contract can then say how that object was represented in slots, windows, recurrence schedules, and fallback paths. Neither layer gets to claim semantic success alone; together they make the evidence trail inspectable.

The mechanism should be viewed as a chain of custody. A VCM packet enters with address, version, authority, adequacy, and lease state. The memory contract records how that packet was mapped into finite structures. The recurrence contract records how much repeated work was authorized and when it must stop. The evidence ledger records whether those facts were merely structural or were later connected to task performance.

flowchart LR
  A["Memory or attention request"] --> B["Slot / residue mapping"]
  B --> C["Winding and provenance"]
  C --> D["Coverage and freshness checks"]
  D --> E["Recurrence work budget"]
  E --> F{"Structural contract passes?"}
  F -- "yes" --> G["Admit as diagnostic guardrail"]
  F -- "no" --> H["Residual / fallback attention"]
  G --> I["Non-claim boundary"]
  H --> I
  I --> J["Freshness and coverage ledger"]
  J --> K["Consumer decision"]

What the cyclic memory contract shows: The cyclic-memory contract is a chain-of-custody record from request to slot mapping, winding, coverage, freshness, and recurrence budget. Passing the structural contract admits the representation as a diagnostic guardrail, not as proof of retrieval quality or reasoning success.

The contract should record:

• Residue and winding, not residue alone.
• Provenance for reused slots.
• VCM packet refs, memory-authority scope, and state-carry boundary.
• Freshness and stale-read policy.
• Sparse coverage and uncovered lags.
• Recurrence depth, active work, loop exits, and overthinking boundary.
• Fallback to ordinary, local, global, or content-gated attention.
• Admission state, baseline refs, probe requirements, residuals, and non-widening authority policy.
• Non-claims about retrieval, reasoning, speed, and quality.

This makes cyclic structure useful as a diagnostic and governance layer without asking it to carry unsupported semantic claims.

The default failure response should be conservative. If winding is missing, aliasing becomes visible residual risk. If coverage is partial, fallback attention remains available. If a recurrence budget is exhausted, the loop exits instead of continuing as if thinking harder were free. These behaviors are ordinary engineering safeguards, but they are what let a cyclic memory idea become safe enough to test later.

The contract also needs an admission state: admissible as structural guardrail, inadmissible for this task, admissible only with fallback, residualized due to stale or aliased state, or eligible for workload evaluation. These states keep structural readiness separate from semantic success.

68.7.1 Eighteen-stage state-carry lifecycle

The mature lease registers object, state/model version, request, tenant, consumer, workload, authority, rights, axes, budget, and non-claims; binds source/VCM lineage, epochs, model, tokenizer, layout, device, and revocation; records residue plus winding and visible aliases; computes occupancy, collisions, duplicates, overwrites, and ambiguity; checks request- and version- specific freshness; computes exact sparse and fanout gaps, repair, and fallback; binds recurrence state, active work, progress, maximum steps, stopping, and periodicity; reserves complete resources; runs alias, stale, mismatch, gap, duplicate, stagnation, hidden-work, and fallback mutations; issues a least- authority lease; canaries beside ordinary baselines; measures structure, utility, tails, resources, verification, and repair jointly; performs causal ablations; monitors leakage, poisoning, drift, gaps, overthinking, and displaced work; refuses, repairs, recomputes, falls back, quarantines, rolls back, or terminates; invalidates all descendants; reproduces independently and transfers; then expires the lease and assigns every residual.

68.8 Interfaces

Cyclic recurrence is exposed through the Cyclic Memory Contract.

Minimum fields:

• contract_id
• memory_target
• memory_authority_scope
• vcm_packet_refs
• slot_count
• residue_policy
• winding_policy
• state_carry_boundary
• freshness_window
• stale_read_policy
• coverage_claim
• recurrence_schedule
• loop_exit_condition
• fallback_attention
• admission_state
• baseline_refs
• probe_requirements
• authority_non_widening
• residuals
• non_claims
• evidence_refs

VCM context traces expose adequacy and authority labels. Attention and memory modules consume contract fields as guardrails. Benchmark adapters and Theseus transfer lanes decide whether structural facts survive workloads. Proof contracts define only the finite boundary they actually prove.

Twelve owner interfaces preserve Context/VCM, Proof Contract Transport, Runtime and Serving, Routing, Deliberation, Resource Economics, Verification, Security/ Privacy/Rights, Artifacts/Replay, Readiness/Incident, Claims/Evidence, and Release authority. Structural eligibility is useful precisely because it does not absorb these owners.

Baseline obligations belong on the same record. If a cyclic structure is being evaluated, the record should identify ordinary attention, FIFO, LRU, content-gated, slot-only, or slot-plus-winding baselines before anyone claims improvement. Missing baselines should block quality promotion.

The consumer contract is intentionally narrow. A planner may use freshness and coverage facts to decide whether more context is needed; a verifier may use loop exits and fallback declarations to reject a recurrence trace; a benchmark may use the same record to compare cyclic memory against ordinary attention. None of those consumers may convert structural coverage into semantic adequacy without separate evidence.

68.9 Invariants

• Residue-only aliasing remains visible.
• Full structural coverage is not semantic coverage.
• Recurrence budgets include exits and guardrails.
• Stale reads fail closed or enter residual escrow.
• Contract readiness is not downstream task success.

Alias honesty governs the cyclic-memory record: if a slot can refer to more than one historical item, the record must preserve winding or provenance instead of pretending the residue alone is enough.

Non-widening memory authority keeps representation changes from becoming policy changes. Mapping a governed context packet into slots, recurrence traces, or compressed attention cannot expand its authority, lease, permitted use, or adequacy claim.

Recurrence traces must preserve refresh, eviction, and exit decisions when later reasoning depends on remembered state.

The full invariant set additionally requires exact lease scope; authority and rights non-widening; visible winding, collisions, and overwrites; separation of presence, freshness, adequacy, utility, and readiness; request/model/tokenizer/ layout binding; exact coverage gaps and repair; unique fanout accounting; typed recurrent state, progress, maximum work, stopping, and fallback; no self- extension; complete denominators; structural work savings kept distinct from measured benefit; visible tails and leakage; executable fallback; descendant invalidation; independent reproduction; separate evidence transitions; no private-result inference; and owned residuals.

68.10 Failure modes

• Alias hiding.
• Overthinking or non-terminating recurrence loops.
• Uncovered sparse-attention lags.
• Freshness facts treated as retrieval-quality evidence.
• No ordinary baseline controls.

Alias hiding should block or mark residual risk. Recurrence loops should hit an exit. Sparse gaps should route to local or content-gated repair. Freshness should remain a structural fact, not a semantic success claim. Missing baselines should block quality promotion.

Structural adequacy laundering is the core cyclic-memory trap. A system proves that a slot is fresh, a sparse lag is covered, or a recurrence loop exits, then uses that structural fact as if it proved task adequacy. The ledger should force an explicit bridge from structure to workload before promotion.

The matched failure set also includes cross-request, tenant, model, tokenizer, policy, or epoch reuse; freshness-to-truth confusion; averages hiding gaps and repair; duplicate fanout inflation; stagnating or self-extending recurrence; modeled work called speed; hidden maintenance and fallback cost; censored failures; fixtures called learned results; weak baselines; shared defects; poisoned, revoked, private, or deletion-targeted descendants; broken fallback; Circle receipt generalization; imported recurrent-model results; and lock-in after governance cost exceeds benefit.

68.11 Minimum Viable Implementation

Cyclic memory should first be represented as a cyclic memory contract record. The repository fixture records memory target, memory-authority scope, VCM packet refs, slot count, residue and winding policies, state-carry boundary, freshness window, stale-read policy, coverage claim, recurrence schedule, loop exit, fallback, admission state, baseline refs, probe requirements, authority non-widening, residuals, non-claims, and evidence references.

The cyclic-memory fixture is a structural receipt only. It shows that the book can represent the cyclic-memory claim without blurring it into model quality or runtime memory performance.

The dedicated cyclic-memory harness now extends that receipt with synthetic behavior traces: one slot reuse with winding preserved, one stale read residualized, one recurrence schedule that exits and falls back, plus expected-invalid traces for hidden aliasing, sparse gaps without fallback, recurrence without exit, stale-read admission without residual escrow, structural-quality promotion, and support-state promotion. It also recompiles and independently reconstructs the finite Lean lifecycle. The consumer checks sixteen complete-address round trips, both dropped-coordinate collision controls, seven accepted fresh transitions, all eight trace splits, three stale mismatch/fallback paths, forty reachable states through 320 transitions, twenty-four stale-suffix states through 192 contained transitions, eleven rejecting event mutations, and seventeen semantic mutations. A later workload harness can then ask whether those structural protections improve task behavior.

The exact current minimum is one schema-valid record, three valid and six expected-invalid synthetic traces, five external Circle structural receipt slices for cyclic memory, KV freshness, recurrence scheduling, sparse gaps, and strided fanout with explicit no-promotion boundaries, and a 34-declaration Lean surface with an independent lifecycle consumer. It is adequate only for the authored finite address, freshness, fallback, and recurrence semantics. It proves no deployed cache, sparse attention, recurrence controller, useful memory, retrieval, reasoning, context length, latency, memory, independent reproduction, transfer, or chapter-core result.

68.12 Mature Research Target

Coil memory is useful only when it becomes a memory-admission and recurrence-control plane. It makes slot, lag, freshness, aliasing, active-work, and loop-exit facts available to the stack without confusing those facts with retrieval quality or reasoning success.

Coil memory earns a mature role by exposing structural guardrails while leaving retrieval quality and reasoning quality to separate evidence. A recurrence contract would bind VCM packet refs, memory-authority scope, residue and winding policies, provenance, state-carry boundaries, freshness windows, stale-read policy, coverage claims, recurrence schedules, work budgets, loop exits, fallback attention, admission state, baseline refs, probe requirements, residuals, and non-claims. The contract is valuable because it makes alias, lag, and recurrence facts visible before a model can use old state as if it were fresh authority.

That control plane would keep several ledgers apart. Alias visibility, sparse coverage, freshness, recurrence exit, work-saving, retrieval quality, reasoning quality, speed, memory reduction, and long-context utility are different claims. VCM would supply address, version, authority, adequacy, taint, and lease state; memory modules would consume contract fields as diagnostics; proof-contract receipts would preserve finite structural facts; benchmark adapters would decide whether those structural protections improve workload behavior. Missing winding becomes visible alias risk, stale reads fail closed or enter residual escrow, coverage gaps route to fallback attention, and exhausted recurrence budgets exit rather than overthink.

68.12.1 Argument-exit campaign

The full attempt runs natural long-context retrieval, tool-state continuity, streaming, cross-document dependency, and recurrent-reasoning workloads against matched full-attention, no-cache/recompute, FIFO/LRU, ordinary retrieval, Transformer-XL-style, compressed-memory, RetNet/state-space, Universal and Recurrent Transformer, fixed-depth, and direct controls. It freezes requests, tenants, model/tokenizer versions, cache layouts, sequence lengths, budgets, seeds, stopping rules, failure states, attacks, evaluator access, and promotion criteria before outcomes.

The campaign measures structural integrity, stale/alias/cross-request leakage, coverage and repair, duplicates and effective fanout, progress and overthinking, useful retrieval, reasoning and task outcomes, calibration, latency and tails, memory, bandwidth, energy, verifier and operator burden, fallback success, recovery, safety, rights, and residuals jointly. Causal ablations remove winding, provenance, freshness checks, sparse repair, recurrence state, progress, stopping, or fallback under matched resources. Independent cache and recurrence implementations and evaluators reproduce the result before transfer across tasks, lengths, models, hardware, organizations, attacks, and time.

The recurrence contract is still a proposed control surface. The core remains at argument until the natural campaign clears strong-baseline, joint-burden, causal, fallback/recovery, independent-reproduction, and heterogeneous-transfer gates. Positive structural axes do not automatically move retrieval, reasoning, context-length, efficiency, safety, deployment, support, or SOTA claims.

68.13 Codex test plan

Test	Purpose	Status
Cyclic memory contract fixture validation	Validate that a memory contract records memory-authority scope, VCM packet refs, slot count, residue and winding policies, state-carry boundary, freshness and stale-read policy, coverage claim, recurrence schedule, loop exit, fallback attention, admission state, baseline refs, probe requirements, authority non-widening, residuals, non-claims, and evidence references.	implemented; passing via python3 scripts/validate_protocol_examples.py
Hidden alias negative case	Prove that a reused cyclic slot with missing residue or winding and no visible alias residual rejects the finite alias-boundary predicate.	implemented in AsiStackProofs.CoilAttentionMemory.reused_cyclic_slot_without_winding_or_residual_rejected; no alias behavior or retrieval-quality claim
Structure-only quality-promotion negative case	Prove that sparse coverage and freshness facts with no semantic-quality evidence cannot satisfy quality-promotion validity when retrieval quality is promoted.	implemented in AsiStackProofs.CoilAttentionMemory.structure_only_retrieval_quality_promotion_rejected; no retrieval-quality claim
Recurrence admission negative case	Prove that enabled recurrence missing work-budget, exit-condition, or fallback records rejects the finite recurrence-admission predicate.	implemented in AsiStackProofs.CoilAttentionMemory.recurrence_without_budget_exit_or_fallback_rejected; no recurrence-exit behavior claim
Stale-read residual negative case	Prove that a stale read admitted as fresh without residual escrow rejects the finite stale-read admission predicate.	implemented in AsiStackProofs.CoilAttentionMemory.stale_read_admitted_as_fresh_without_residual_rejected; no KV-cache freshness behavior claim
Arbitrary-run lifecycle invariant suite	Prove complete cyclic-address round trips and injectivity; custody, budget, zero-authority, stage-coherence, and recurrence-monotonicity preservation across arbitrary finite event lists; stale-path exclusion of fresh consumption across arbitrary suffixes; and absorbing closure. Independently exhaust every transition reachable from fresh and three single-coordinate-mismatch roots and reject targeted semantic mutations.	implemented in AsiStackProofs.CoilAttentionMemory; passing via python3 scripts/validate_cyclic_memory_contracts.py over 40 reachable states, 320 transitions, 24 stale-suffix states, 192 contained suffix transitions, 11 rejecting event mutations, and 17 semantic mutations; authored finite semantics only
Cyclic alias visibility test	Check that reused slots record winding or provenance, or expose a visible alias residual.	implemented by python3 scripts/validate_cyclic_memory_contracts.py; synthetic structural traces only; no retrieval-quality or learned-memory claim
Sparse coverage gap test	Check that uncovered lags are recorded and routed to fallback.	implemented by python3 scripts/validate_cyclic_memory_contracts.py; no sparse-attention quality or runtime behavior claim
Recurrence budget and exit test	Check that recurrence schedules include active work limits, exit conditions, fallback, and exited records.	implemented by python3 scripts/validate_cyclic_memory_contracts.py; no recurrence-quality or model-behavior claim
Freshness stale-read rejection test	Check that stale reads fail closed or enter residual escrow.	implemented by python3 scripts/validate_cyclic_memory_contracts.py; no KV-cache freshness or retrieval-quality claim
Circle cyclic memory receipt-slice validation	Check that the local external Circle cyclic-memory receipt slice surfaces CC-AI-CONTRACT-MEMORY-001, theorem IDs AIM-T0001, AIM-T0002, AIM-T0004, AIM-T0005, same-residue events [7, 15, 23, 31], same-residue windings [0, 1, 2, 3], max_alias_load=4, strict receipt fingerprint a25d841aff585b59519919cad25d89a3f76cd8ddb11fb1549d593f7f2f09c62a, and 3 passed in 2.51s without promotion drift.	implemented by python3 scripts/validate_circle_cyclic_memory_receipt_slice.py; structural external-project receipt only; no retrieval-quality, long-context, model-quality, speed, memory-scaling, deployment, transfer, ASI, or support-state-transition claim
Circle KV-cache receipt-slice validation	Check that the local external Circle KV-cache receipt slice surfaces CC-AI-CONTRACT-KV-001, kind kv_cache_ring_buffer, theorem IDs AIM-T0103, AIM-T0104, AIM-T0149, theorem_count=54, required recommendations KV-DROP-STALE-REQUEST-TOKEN and KV-USE-SINK-ROLLING-WINDOW-REQUEST, strict receipt fingerprint bfebf150ce45d1eb124ea553bf2ba8c62008751ebec9f8600b83cc09e0526a46, stale_probe_first_stale_token=12, sink_tokens_retained_by_policy=true, sink_window_exact_policy=true, sink_window_tokens_distinct=true, sink_prefix_disjoint_from_live_window=true, sink_tokens_outside_ordinary_rolling_window=true, 5 passed in 1.27s, and no-promotion decision circle_kv_cache_receipt_no_change.json without promotion drift.	implemented by python3 scripts/validate_circle_kv_cache_receipt_slice.py; structural external-project receipt only; no deployed KV-cache behavior, serving throughput, memory-savings, paging correctness, retrieval-quality, long-context, model-quality, deployment, transfer, ASI, or support-state-transition claim
Circle recurrence receipt-slice validation	Check that the local external Circle recurrence receipt slice surfaces CC-AI-CONTRACT-RECURRENCE-001, kind recurrence_schedule, theorem IDs AIM-T0026, AIM-T0130, AIM-T0159, theorem_count=64, required recommendations RECURRENCE-USE-ACTIVE-TOKEN-WORK-SCHEDULE and RECURRENCE-REUSE-WHOLE-PERIOD-SHIFT, strict receipt fingerprint 571edd5dce4f7b64441806de323295218a3e2293b3b540dd4772ba34b9371515, active_token_count_trace=[8, 6, 4, 2, 1], inactive_token_count_trace=[0, 2, 4, 6, 7], total_active_token_work=21, total_inactive_token_work=19, scheduled_work_saving=19, post_period_multi_extension_scheduled_work_saving=43, periodic_shift_required_steps_invariant=true, periodic_shift_active_at_step_invariant=true, 2 passed in 2.37s, and no-promotion decision circle_recurrence_receipt_no_change.json without promotion drift.	implemented by python3 scripts/validate_circle_recurrence_receipt_slice.py; structural external-project receipt only; no deployed recurrence behavior, reasoning-quality, retrieval-quality, learned-memory, convergence, long-context, model-quality, deployment, transfer, ASI, or support-state-transition claim
Circle strided fanout receipt-slice validation	Check that the local external Circle strided fanout receipt slice surfaces CC-AI-CONTRACT-FANOUT-001, kind strided_candidate_fanout, theorem IDs AIT-T0001, AIT-T0002, AIT-T0003, AIT-T0173, theorem_count=4, context_length=12, stride=5, gcd=1, predicted_reach=12, full_coverage=true, candidate_budget=12, unique_candidate_count=12, effective_candidate_budget=12, duplicate_count=0, candidate_budget_shortfall=0, effective_budget_matches_unique_candidates=true, effective_budget_reaches_predicted_reach=true, 3 passed in 4.65s, 1 passed in 2.77s, and no-promotion decision circle_strided_fanout_receipt_no_change.json without promotion drift.	implemented by python3 scripts/validate_circle_strided_fanout_receipt_slice.py; structural external-project receipt only; no search-quality, retrieval-quality, routing-quality, sparse-attention-quality, model-quality, throughput, latency, optimal-schedule, deployment, transfer, ASI, or support-state-transition claim

The implemented fixture row validates schema consistency, the implemented Lean rows validate bounded finite-record negative cases, and the dedicated harness validates synthetic structural traces only. None of the implemented rows is a retrieval-quality, long-context, performance, or learned-memory result. A future workload harness must still link command, environment, workload, baselines, result summary, and non-claims before any quality claim can move.

68.13.1 Formalization hooks

Tag	Module	Target	Status
lean:coil_memory.alias_boundary.operational_invariant	AsiStackProofs.CoilAttentionMemory	A reused cyclic slot with missing residue or winding and no visible alias residual fails the finite alias-boundary predicate.	implemented
lean:coil_attention.coverage_not_quality.failure_blocks_promotion	AsiStackProofs.CoilAttentionMemory	A retrieval-quality record that promotes from sparse coverage and freshness while semantic-quality evidence is absent fails the finite quality-promotion predicate.	implemented
lean:coil_memory.versioned_freshness_and_recurrence.lifecycle	AsiStackProofs.CoilAttentionMemory	A finite cyclic-memory lifecycle proves residue-only addressing non-injective and complete residue-plus-winding encoding injective; preserves custody, budget safety, zero support/effect authority, freshness-stage coherence, and recurrence monotonicity across arbitrary event lists; composes traces; confines stale classifications away from fresh consumption across arbitrary suffixes; and makes closure absorbing.	implemented

These Lean hooks are implemented as finite-record predicates and a finite transition system over cyclic memory addressing, exact freshness, fallback, and bounded recurrence. The public negative-case hooks reject reused slots with missing residue/winding and no visible residual and reject structure-only retrieval-quality promotion. The lifecycle hook additionally proves that residue-only addressing is non-injective while complete residue-plus-winding encoding round-trips and is injective; rejected events preserve the entire state; every finite event list preserves memory/request/address/budget custody, the recurrence bound, zero support/effect authority, freshness-stage coherence, and monotone recurrence steps; event batches compose; every suffix after stale detection excludes fresh validation and consumption; and closure absorbs every suffix. These results do not prove retrieval quality, deployed KV-cache behavior, sparse-attention coverage, recurrence utility, freshness reporting, long-context improvement, memory savings, or learned-model quality.

The module contains 34 theorem declarations: four retained negative cases and thirty address/lifecycle results. The two former assumption-restating projections remain retired. The lifecycle is authored finite semantics, so it does not prove that a deployed cache reports true epochs or positions, that cross-request isolation is complete, that recurrence is useful, or that retrieval quality improves. Runtime refinement, concurrent invalidation, semantic adequacy, liveness beyond the bounded witness, natural workloads, independent reproduction, and transfer remain Project Theseus or empirical obligations.

68.14 Source crosswalk

Source ID	Title	Layer	Planned use	Readiness
coil_attention_memory	Coil Attention and Memory	cyclic_attention_memory	Proof-linked cyclic memory, KV-cache freshness, sparse-attention coverage, recurrence schedules, loop-exit certificates, work budgets, and alias diagnostics.	source note available
circle_ai_contract_suite	Circle Calculus AI Contract Suite	proof_carrying_ai_contracts	Theorem-linked AI contract families for RoPE, KV-cache freshness, sparse attention, recurrence schedules, strided fanout, cyclic memory, multicoil phase, cyclic mixers, and seed-rule regeneration.	source note available
theseus_circle_transfer	Theseus Circle Calculus Transfer Lane	proof_contract_transfer	Report-only bridge from Circle finite fixtures into private Theseus benchmark design with explicit quality/runtime/memory/transfer/failure-case claim boundaries.	source note available
vcm_public	Virtual_Context_Memory_v1	memory_context	Public VCM release. Governed protocol for compiled working context.	source note available; local raw cache available
ext_transformer_xl_2019	Transformer-XL: Attentive Language Models Beyond a Fixed-Length Context	sequence_memory_recurrence	External comparator for segment-level recurrence, relative positional treatment, and long-dependency language modeling.	source note available; results not reproduced
ext_compressive_transformer_2019	Compressive Transformers for Long-Range Sequence Modelling	sequence_memory_recurrence	External comparator for compressed past memories, long-range sequence modeling, and memory-mechanism baselines.	source note available; results not reproduced
ext_retnet_2023	Retentive Network: A Successor to Transformer for Large Language Models	sequence_memory_recurrence	External comparator for the recurrence/attention boundary, recurrent inference, and chunkwise recurrent computation.	source note available; results not reproduced
ext_universal_transformer_2019, ext_recurrent_transformer_2026, ext_dynamic_compute_recurrent_transformers_2026	Foundational and current recurrent Transformers	adaptive_recurrence	Comparators for shared-weight depth, recurrent KV memory, adaptive allocation, online halting, and extrapolation limits.	source notes available; no cyclic-memory correctness, local capability, or efficiency result

The crosswalk keeps memory claims structural. coil_attention_memory supplies alias, freshness, sparse-coverage, and recurrence-budget contracts; circle_ai_contract_suite supplies theorem-linked contract family context; theseus_circle_transfer supplies the report-only transfer boundary; and vcm_public ties these records back to governed context adequacy. The external comparators source-note ordinary recurrent, compressed-memory, and retention baselines. None of these records supports learned retrieval or reasoning quality in this repo.

68.14.1 Concrete Circle Cyclic-Memory Receipt Boundary

The Circle cyclic-memory slice gives this chapter one concrete proof-contract receipt instead of only source-note vocabulary. In the local external Circle checkout at commit 63b0f511, the command PYTHONPATH=. python3 scripts/cyclic_memory_certify.py --format json emitted a ready cyclic_memory_residue_winding fixture for CC-AI-CONTRACT-MEMORY-001. The fixture records bank_size=8, event_index=23, event_count=32, residue_slot=7, winding=2, same_residue_events=[7, 15, 23, 31], same_residue_windings=[0, 1, 2, 3], and max_alias_load=4.

The strict Circle receipt command accepted theorem IDs AIM-T0001, AIM-T0002, AIM-T0004, and AIM-T0005, required recommendations MEMORY-ATTACH-WINDING-ALIAS-PROVENANCE and MEMORY-AUDIT-FINITE-ALIAS-LOAD, and recorded contract fingerprint a25d841aff585b59519919cad25d89a3f76cd8ddb11fb1549d593f7f2f09c62a. The Circle CLI test command reported 3 passed in 2.51s. The ASI-side validator python3 scripts/validate_circle_cyclic_memory_receipt_slice.py checks these facts against docs/circle_cyclic_memory_receipt_slice.md and the tracked result record.

This receipt is useful because it shows the exact structural point: residue slot 7 is not enough without winding 2 and the alias class [7, 15, 23, 31]. It does not promote any chapter core claim above argument, does not create a support-state transition, and does not prove retrieval quality, reasoning quality, model quality, context length, speed, memory scaling, throughput, paging correctness, deployment safety, transfer, or ASI.

68.14.2 Concrete Circle KV-Cache Receipt Boundary

The Circle KV-cache slice gives the chapter one concrete ring-buffer receipt boundary without turning it into a serving or retrieval claim. In the local external Circle checkout at commit 63b0f511, the bounded KV-cache commands emitted and accepted a kv_cache_ring_buffer fixture for CC-AI-CONTRACT-KV-001. The receipt records cache_size=16, current=31, token=20, slot=4, current_slot=15, lag=11, retained=true, next_overwrite_token=36, live-window start 16, live-window length 16, batch tokens [20, 24, 29, 31], batch slots [4, 8, 13, 15], all_non_future=true, all_retained=true, tokens_distinct=true, slots_distinct=true, ordered_live_window_subrequest=true, duplicate_free_live_window_subrequest=true, and stale_requested_count=0.

The same receipt records the sink and stale-token boundary: stale_probe_first_stale_token=12, sink_tokens=[0, 1, 2, 3], sink_tokens_retained_by_policy=true, sink_window_exact_policy=true, sink_window_tokens_distinct=true, sink_prefix_disjoint_from_live_window=true, and sink_tokens_outside_ordinary_rolling_window=true. The strict Circle receipt accepted theorem IDs AIM-T0103, AIM-T0104, and AIM-T0149, recorded theorem_count=54, required recommendations KV-DROP-STALE-REQUEST-TOKEN and KV-USE-SINK-ROLLING-WINDOW-REQUEST, and recorded contract fingerprint bfebf150ce45d1eb124ea553bf2ba8c62008751ebec9f8600b83cc09e0526a46. The Circle CLI test command reported 5 passed in 1.27s. The ASI-side validator python3 scripts/validate_circle_kv_cache_receipt_slice.py checks these facts against docs/circle_kv_cache_receipt_slice.md, the tracked result record, and no-promotion decision circle_kv_cache_receipt_no_change.json.

This receipt is useful because it makes stale-token and sink-window policy bookkeeping inspectable. It does not promote any chapter core claim above argument, does not create a support-state transition, and does not prove deployed KV-cache behavior, serving throughput, memory savings, paging correctness, retrieval quality, reasoning quality, model quality, context length, speed, memory scaling, deployment safety, transfer, benchmark performance, or ASI.

68.14.3 Concrete Circle Sparse-Attention Receipt Boundary

The Circle sparse-attention slice gives the chapter one concrete coverage-gap receipt boundary without turning it into an attention-quality claim. In the local external Circle checkout at commit 63b0f511, the bounded sparse commands emitted and accepted a sparse_attention_coverage fixture for CC-AI-CONTRACT-SPARSE-001. The fixture records sequence_length=120, strides=[7, 13], path_length=3, local_window=4, candidate_budget_per_query=10, full_attention_budget=120, coverage_complete=false, covered_lag_count=10, uncovered_lag_count=109, and first_uncovered_lag=5.

The same receipt records the repair and fallback boundary: the first uncovered interval is [5, 6], complete_repair_window=119, complete_repair_window_additional_local_slots=115, complete_repair_window_covers_context=true, complete_repair_window_minimal_for_declared_stride_family=true, complete_repair_window_minimal_witness_lag=119, interval_repair_plan_step_count=6, interval_repair_plan_final_window=119, interval_repair_plan_covers_context=true, lag_collision_pair_count=0, and query_collision_pair_count=0. The strict Circle receipt accepted theorem IDs AIT-T0104 and AIT-T0172, recorded theorem_count=141 in the contract-ready digest, required recommendations SPARSE-LOCAL-FIRST-INTERVAL-REPAIR and SPARSE-DENSE-LOCAL-COMPLETE-FALLBACK, and recorded contract fingerprint c23809cef9b821b1e4f9cabf53fcac724a0757bf3f86594e1d12710fe0cd9ec1. The Circle CLI test command reported 10 passed in 1.87s. The ASI-side validator python3 scripts/validate_circle_sparse_attention_receipt_slice.py checks these facts against docs/circle_sparse_attention_receipt_slice.md, the tracked result record, and no-promotion decision circle_sparse_attention_receipt_no_change.json.

This receipt is useful because it makes the failure boundary inspectable: the declared local-window plus stride-family pattern does not cover all positive lags, and the Circle record names the first repair and dense-local fallback instead of pretending the sparse pattern succeeded. It does not promote any chapter core claim above argument, does not create a support-state transition, does not prove sparse-attention coverage success, and does not prove deployed sparse-attention behavior, retrieval quality, reasoning quality, long-context quality, model quality, speed, memory savings, deployment safety, transfer, benchmark performance, or ASI.

68.14.4 Concrete Circle Strided Fanout Receipt Boundary

The Circle strided fanout slice gives the chapter one concrete candidate-cycle receipt boundary without turning it into a search, retrieval, or routing-quality claim. In the local external Circle checkout at commit 63b0f511, the bounded fanout commands emitted and accepted a strided_candidate_fanout fixture for CC-AI-CONTRACT-FANOUT-001. The fixture records context_length=12, stride=5, start_index=0, path_length=12, gcd=1, predicted_reach=12, full_coverage=true, candidate_budget=12, unique_candidate_count=12, effective_candidate_budget=12, duplicate_count=0, candidate_budget_shortfall=0, effective_budget_matches_unique_candidates=true, and effective_budget_reaches_predicted_reach=true.

The same receipt records the finite orbit and path boundary: orbit=[0, 5, 10, 3, 8, 1, 6, 11, 4, 9, 2, 7] and candidate_path=[7, 2, 9, 4, 11, 6, 1, 8, 3, 10, 5, 0]. The strict Circle receipt accepted theorem IDs AIT-T0001, AIT-T0002, AIT-T0003, and AIT-T0173, recorded theorem_count=4, required recommendations FANOUT-USE-FULL-COVERAGE-STRIDE-CYCLE and FANOUT-AUDIT-DUPLICATE-COLLAPSED-BUDGET, and recorded contract fingerprint d4c878563747da9c9f1f55cd689f04e2a0a8e31ce9429a138341ec4e27ee3799. The Circle CLI test command reported 3 passed in 4.65s, and the contract-ready recommendation test reported 1 passed in 2.77s. The ASI-side validator python3 scripts/validate_circle_strided_fanout_receipt_slice.py checks these facts against docs/circle_strided_fanout_receipt_slice.md, the tracked result record, and no-promotion decision circle_strided_fanout_receipt_no_change.json.

This receipt is useful because it makes candidate fanout accounting inspectable: the declared finite stride covers the declared candidate context and the duplicate-collapsed budget equals the unique candidate count. It does not promote any chapter core claim above argument, does not create a support-state transition, and does not prove search quality, retrieval quality, routing quality, sparse-attention quality, reasoning quality, model quality, context length, throughput, latency, runtime speed, memory savings, deployment readiness, deployment safety, transfer, benchmark performance, safety, optimal scheduling, or ASI.

68.14.5 Concrete Circle Recurrence Receipt Boundary

The Circle recurrence slice gives the chapter one concrete loop-schedule receipt boundary without turning it into a reasoning or long-context claim. In the local external Circle checkout at commit 63b0f511, the bounded recurrence commands emitted and accepted a recurrence_schedule fixture for CC-AI-CONTRACT-RECURRENCE-001. The receipt records loop_period=5, sample_index=8, max_loops=7, required_steps=4, exit_step=4, overthinking_boundary=5, active_token_count_trace=[8, 6, 4, 2, 1], inactive_token_count_trace=[0, 2, 4, 6, 7], total_active_token_work=21, total_inactive_token_work=19, full_loop_token_work=40, scheduled_work_saving=19, and post_period_multi_extension_scheduled_work_saving=43.

The same receipt records the whole-period shift boundary: periodic_shift_base_token=7, periodic_shift_passes=3, periodic_shift_amount=15, periodic_shifted_token=22, periodic_shift_required_steps_invariant=true, periodic_shift_recurrence_budget_invariant=true, periodic_shift_training_free_budget_invariant=true, periodic_shift_exit_step_invariant=true, periodic_shift_overthinking_boundary_invariant=true, and periodic_shift_active_at_step_invariant=true. The strict Circle receipt accepted theorem IDs AIM-T0026, AIM-T0130, and AIM-T0159, recorded theorem_count=64, required recommendations RECURRENCE-USE-ACTIVE-TOKEN-WORK-SCHEDULE and RECURRENCE-REUSE-WHOLE-PERIOD-SHIFT, and recorded contract fingerprint 571edd5dce4f7b64441806de323295218a3e2293b3b540dd4772ba34b9371515. The Circle CLI test command reported 2 passed in 2.37s. The ASI-side validator python3 scripts/validate_circle_recurrence_receipt_slice.py checks these facts against docs/circle_recurrence_receipt_slice.md, the tracked result record, and no-promotion decision circle_recurrence_receipt_no_change.json.

This receipt is useful because it makes active token work, scheduled work saving, and whole-period shift reuse inspectable. It does not promote any chapter core claim above argument, does not create a support-state transition, and does not prove deployed recurrence behavior, reasoning quality, retrieval quality, learned-memory behavior, convergence, model quality, context length, speed, memory savings, deployment safety, transfer, benchmark performance, or ASI.

68.15 Summary

Cyclic memory contracts make structural facts visible: residue, winding, freshness, coverage gaps, recurrence depth, active token work, loop exits, and fallback. They do not prove retrieval or reasoning quality.

Coil attention stays useful only when it stays honest. Structural guardrails can protect the stack only when their non-claims are preserved. The same boundary applies to adapters, RoPE-style phase banks, and cyclic mixers, where parameter counts and exact phase facts are easy to overread.

A memory contract should make the cheap fact and the hard claim impossible to confuse. Slot freshness, coverage, and loop exit are cheap facts; retrieval quality, reasoning quality, and useful long context are hard claims. The architecture should welcome cyclic memory ideas when they improve inspectability, but it should refuse to turn structure into performance mythology. A cyclic trace can tell a verifier which positions were covered, whether recurrence terminated, which fallback triggered, and where phase assumptions entered. That information is useful precisely because it narrows the claim. Once the boundary is preserved, cyclic memory can be tested as a specialist candidate rather than sold as a general route to intelligence.

68.16 Evidence reconciliation (2026-07-16)

The invariant protocol, field meanings, and inference limits are stated once in Living Book Methodology. This packet contains only the chapter-specific projection; its authoritative per-atom rows are the coil-attention-cyclic-memory-and-recurrence-contracts slice of experiments/claim_family_terminal_coverage/results/result.json.

The core remains blocked after full attempt at argument support. The strongest family attempt was KERC canonical-language and hierarchical-residual campaign. Its exact boundary is: The historical broad-efficiency transition is N1: the frozen implementation was inadequate, so broader KERC remains untested; two narrow finite observations survive, with no semantic, multilingual, production, energy, or core claim. Across 73 atoms, the terminal ledger records 73 blocked_after_full_attempt.

Chapter-specific field	Value
Family / atom denominator	CF-06 / 73 atoms
Terminal dispositions	73 blocked_after_full_attempt
Core	coil-attention-cyclic-memory-and-recurrence-contracts.core: blocked_after_full_attempt at argument
Core attempted / missing lanes	causal, empirical, executable, formal, source-synthesis / normative, transfer
Attempted local lanes	causal, empirical, executable, formal, source-synthesis
Missing or unproved lanes	normative, transfer
Strongest family bundle	KERC canonical-language and hierarchical-residual campaign (natural_work_and_end_to_end): A 192-record bilingual templated compiler/runtime study with 64 held-out records, five seeds, eight baseline families, 13 ablations, and 20 attacks.
Negative controls	surface and kernel-native baselines; 13 ablations; 20 attacks; ten laundering mutations.
Accepted transitions	none
Maximum inference	The historical broad-efficiency transition is N1: the frozen implementation was inadequate, so broader KERC remains untested; two narrow finite observations survive, with no semantic, multilingual, production, energy, or core claim.
Reproduction / next burden	Replay scripts/validate_p4_m8_kerc_campaign.py and scripts/validate_claim_family_terminal_program.py; fill the named atom-specific lanes under a new prospective protocol.

68.17 Handoff

Cyclic memory contracts preserve structural facts at the memory boundary; cyclic adapters and mixers need the same separation between exact structure and empirical behavior. CoilRA, MultiCoil RoPE, and Cyclic Mixers moves that discipline into position encodings, adapters, route heads, and block-cyclic substrates. It requires ordinary baselines, diagnostics, resource costs, workload fit, and failure cases before cyclic structure can influence adoption.