A clean-room, two-symbol boundary calculus for extracting “value-data” (structure) that ordinary ontic metrics do not see — with strict interface discipline.

Status: canonical — MVP IA/NOP 2.1 Slim (Freeze)
Audience: physics-facing / internal method

Canonical entry points

• Non-Ontic Physics and IA: Definitions, Boundary Discipline, and Near-Term Applications (definitions + boundary rules)
• First Application of IA/NOP to a Real Physics Problem: RAR (a minimal, test-only run)

0) What IA is (and what it is not)

IA is not a new numeric system. It does not compete with classical mathematics. It does not “fit,” “optimize,” “estimate,” or “compute” in the ontic sense.

IA is a boundary calculus built from two symbols. Its job is to encode and preserve contrast-structure (runs, flips, persistence across scales) in a way that can be exported into a separate ontic compute cluster (we call it DISCRETE) as a lawful, testable signal.

IA/NOP is a strict wrapper: symbols → contrasts → allowed export → wiring → readout status. Any arithmetic lives elsewhere.

1) Clean-room language: the kernel you are allowed to use

To avoid “decorative algebra,” IA is specified in a cleaned kernel language. Two important moves:

• Replace obsolete adjacency language with a structural interface. Any legacy phrasing like “L/Adj” is deprecated; the kernel uses K/Bnd (activation indices + co-boundary relation).
• Replace poetic contact phrases with a formal boundary object. Any legacy phrasing like “Ø₀ meets Ø∞” is replaced by the explicit boundary set DID(C) (defined below).

This matters because IA must remain a reproducible apparatus, not a metaphor generator.

2) Primitives

2.1 The two boundary symbols

• Ø₀
• Ø∞

They are not numbers and do not support “=” or “+”. They are boundary markers used to encode binary contrasts (e.g., sign of a residual, above/below a threshold, two regimes, two orientations — but only as a symbolization step).

2.2 The activation index set K

K is a set of activation indices — the domain you “read” over. In practice, K is usually an ordered index set induced by some lawful ordering (e.g., sorting by a variable you are allowed to use).

Freeze constraint: the K-ordering is declared and frozen per run, and must not depend on forbidden meta-fields. If it does, the run fails by feature_leak.

2.3 The co-boundary relation Bnd

Bnd is a co-boundary relation on K. Intuitively: “which indices are adjacent for the purpose of boundary reading.”

Importantly: the kernel speaks about adjacency only via Bnd, not via informal language.

Freeze constraint: Bnd is declared and frozen per run, and must not depend on forbidden meta-fields. If it does, the run fails by feature_leak.

3) The core IA object: a configuration C

An IA configuration is a function:

C : K → { Ø₀, Ø∞ }

That’s the whole “state” of IA at the kernel level: every index in K is assigned one of the two boundary symbols.

Critical boundary discipline (non-negotiable): DISCRETE may compute the ontic field you will symbolise (e.g., residual sign), but IA only applies a frozen symbolization map to produce C. Tuning symbolization thresholds/rules to improve ontic metrics counts as feature_leak.

4) The boundary derivative object: DID(C)

Given a configuration C and a co-boundary relation Bnd, define the “flip set”:

DID(C) = { (a, b) ∈ Bnd | C(a) ≠ C(b) }

DID(C) is the IA analogue of a derivative: it marks where the configuration changes across the permitted boundary relation. Everything interesting in IA flows from DID(C).

5) Readability marker: DIDᵒ(C)

IA/NOP uses a single interface marker:

DIDᵒ(C) ⊆ DID(C)

Meaning: DIDᵒ(C) marks the boundary flips that are lawful to export and interpret under the current Π contract. Everything outside DIDᵒ is non-exported under this Π; exporting it requires a versioned Π-change (not a patch inside a run).

6) Π (Pi Capital, readout / protocol readout, not π): the lawful bridge into DISCRETE

Π is not a magic solver. It is an interface that binds IA objects to an ontic task specification without introducing equations inside IA/NOP.

6.1 PORTᵒ(C): the export permission object

Define:

PORTᵒ(C) ⇝ { Export-Types }

Interpretation: PORTᵒ(C) is the permission layer that declares which kinds of DID-structures may be exported as data into DISCRETE. IA/NOP is allowed to name export types, not to compute them.

6.2 Π-bind: slots, inputs, outputs, tests (without numbers)

Π-bind opens a minimal contract for DISCRETE:

• SLOTS: model parameter slots (may be empty in slim versions)
• INPUTS: task data channels
• OUTPUTS: what DISCRETE must return
• TESTS: falsifiers / validation checks

Π-bind is wiring, not arithmetic. It defines what is being tested, not how to compute it.

Slim note: formal OUTPUT channels are optional in the slim protocol; the only mandatory return to NOP is status + kill_flags.

7) Allowed Exports: the exhaustive list (MVP 2.1 Slim)

IA/NOP is “safe” only when exports are explicitly enumerated. In the minimal apparatus, the list is deliberately tiny.

Allowed-Exports := { I_scale }

Exhaustive rule: everything else (derived features, external fields, metadata, handcrafted signals) is forbidden at the IA/NOP level unless promoted to an allowed export by a new versioned contract. Any appearance of non-allowed derived features triggers feature_leak.

8) The I_scale contract (legal, not mathematical)

I_scale is a class of readout scale-stability signals. It is evaluated only inside DISCRETE, using only IA-allowed structures.

Rule of purity: any implementation of I_scale inside DISCRETE may use only:

• (C, Bnd)
• and internal intermediate structures derived from them

No metadata, no external fields, no “helpful” side variables. If those appear, the run fails by protocol.

8.1 Allowed scale-variations (SV operators)

I_scale must be checked across a frozen set of allowed scale-variation operators. At the IA/NOP level these are named operator IDs (no parameters, no numeric radii):

• SV-A: coarse-grain operator (named operator IDs; any parameters stay inside DISCRETE and are not exposed to NOP)
• SV-B: downsample operator (named operator IDs; any parameters stay inside DISCRETE and are not exposed to NOP)
• SV-C: neighborhood-reading operator (named operator IDs; any parameters stay inside DISCRETE and are not exposed to NOP)

These operators operationalize the question: “Does the exported structure survive when you change the scale of reading?”

Freeze constraint: SV-A/SV-B/SV-C are a finite, named, versioned set on the DISCRETE side; NOP sees only their names/IDs, not parameters.

9) Failure modes: kill_flags (exactly three in MVP 2.1 Slim)

IA/NOP runs must be able to fail cleanly. In the minimal protocol, there are exactly three kill flags:

• feature_leak: any derived feature or forbidden data used beyond Allowed-Exports / I_scale contract
• meta_dependence: DISCRETE discovers stable dependence of quality/residuals on forbidden meta-fields (or the model “feeds” on them)
• scale_leak: under allowed SV operators, the readout cannot hold one regime without requiring new slots/features or forbidden tuning

Legal trigger for scale_leak (freeze-tight): scale_leak fires if holding the task under allowed SV operators requires changing the contract (Allowed-Exports / Inputs), introducing new slots, or introducing any new derived feature beyond the frozen MVP 2.1 Slim protocol.

These flags are part of the apparatus. They are not “optional style.”

10) Baseline procedure (mandatory in DISCRETE)

Every run must include:

• a baseline model (no IA/NOP exports)
• a main model (may use IA exports via Π)

The comparison rule is defined in DISCRETE, not in IA/NOP. IA/NOP does not see the numbers; it only ensures the interface and export legality.

Freeze rule: if baseline is not done, the protocol is broken and the run is REJECT.

11) The minimal end-to-end workflow (canonical skeleton)

1. Pick the ontic task and data channels (INPUTS) in DISCRETE.
2. Define K and Bnd as the lawful reading domain and its co-boundary relation (declare + freeze).
3. Define the frozen symbolization rule that produces C : K → {Ø₀, Ø∞} (declarative at IA level; no tuning to improve metrics).
4. Construct DID(C) as the boundary flip set across Bnd.
5. Mark DIDᵒ(C) as the export-readable interface under the current Π contract.
6. Activate PORTᵒ(C) (declare export types, not computations).
7. Π-bind to expose the minimal wiring contract (no equations in Π).
8. Run baseline (ontic-only) in DISCRETE.
9. Run main in DISCRETE and evaluate I_scale under SV-A/SV-B/SV-C.
10. Apply kill_flags and accept/reject the run.

12) Why this apparatus is non-decorative

Classical metrics (RMSE/MAE/etc.) summarize average error. IA exports a different category of data: scale-visible structure in contrasts (typically residual contrasts) that can persist across SV operators.

In other words: IA is designed to detect and quantify hidden structured failure — patterns that do not necessarily show up as “large average error,” but reveal fragility when you change the scale of reading.

That is the point of a two-symbol apparatus: not to compete with physics, but to add a protocolized structural diagnostic that is (a) exportable, (b) falsifiable, and (c) disciplined by explicit failure modes.

13) Practical note for implementers

If you implement IA in code, keep the separation absolute:

• IA/NOP layer: symbols, K/Bnd, C, DID(C), DIDᵒ, PORTᵒ, Π-bind, SV operator names/IDs, kill_flags declarations.
• DISCRETE layer: all fitting, statistics, estimators, stability checks, and numerical readouts of I_scale.

The apparatus is only as strong as its boundary discipline.

14) Execution canon (Freeze discipline)

Arbiters: the only legal “signal-arbiters” during a run are the three kill_flags and baseline: done/not-done (baseline not done ⇒ protocol broken ⇒ REJECT). Everything else (feelings, ideas, doubts) is logged only as a trigger for IDM-notes or UPGRADE-REQUEST, not as a reason to change the protocol.

Stop-frame: each run must be recorded using the one-screen Stop-Frame template (Run-ID, Π-readout-version, dataset ID, SV-used, baseline status, kill_flags, status) before any next run begins.

Note: This write-up reflects an earlier version of the apparatus. The current frozen kernel (ΠC_3_0_FREEZE) replaces it; it is available upon request.