This document is the axiom system portion extracted from the Banya Framework Comprehensive Report. Terminology is at banya.html Sub-Reports. The Axiom System Summary Tables and Derivation Demos are in banya.html.

15 Axioms

Axiom 1. Banya Equation Axiom

This is the starting point. Nothing departs from here. 4 words, 2 squares, 1 line. Its true identity will be revealed at the end of the axioms.

Three Names of δ

3 names, 1 entity. No other candidate can appear besides δ (Axiom 10, elimination). However, when δ filters through observer, local shadows of δ may exist. A shadow is a projection of δ, not a separate entity.

The 4 axes are orthogonal polynomials. The brackets are separators that group the 4 axes into pairs of 2.

Without brackets, the 4 axes become entangled:

Brackets separate DATA from OPERATOR. This separation is orthogonality.

observer and superposition Are Not Symbols but Essential System Components

Without observer, there is nowhere to receive the result of CAS's Compare. Without superposition, there is nothing for CAS to reference. Both are structural necessities for the Banya Equation to operate, not figurative rhetoric borrowed from quantum mechanics.

Banya Equation in Unit Circle Form Proposition

The Banya Equation $\delta^2 = (\text{DATA})^2 + (\text{OPERATOR})^2$ is the sum of squared norms of two orthogonal brackets. Since the two brackets are orthogonal (Axiom 1), placing one as the real part and the other as the imaginary part transforms it into the unit circle form of a complex number.

This form has the same structure as the Euler representation $e^{i\theta} = \cos\theta + i\sin\theta$.

1 + crossing = π rotation = phase reversal. By the norm reading (Axiom 4 Proposition), the arc length of one irreversible + crossing is π. On the unit circle, rotating by π reverses the phase ($e^{i\pi} = -1$). Therefore one + crossing flips the phase from +1 to -1.

Starting phase       :  +1   (theta = 0)
After 1 + crossing   :  -1   (theta = pi rotation)
After 2 + crossings  :  +1   (theta = 2*pi return, one cycle)
After 3 + crossings  :  -1
...

Period = 2 crossings (one phase loop)
Phase after n crossings = (-1)^n

This proposition follows from the Banya Equation (Axiom 1) by transformation alone, without additional assumptions — placing two orthogonal brackets on the real and imaginary axes is equivalent to the definition of orthogonality (Axiom 1). Therefore this form is not a new axiom but a structural consequence of the Banya Equation.

Subframe Orthogonality in Unit Circle / Unit Sphere Form (Quaternion) Proposition

The (Banya Equation in Unit Circle Form) proposition applies between the two brackets of the Banya Equation (DATA ⊥ OPERATOR). The same form applies recursively to the subframes inside each bracket according to their orthogonal structure — but the bracket structure itself is not dissolved.

Bracket separation is preserved (prohibition). The two brackets of the Banya Equation (DATA, OPERATOR) are an inseparable category distinction (Axiom 1: orthogonal sum +, not arithmetic addition). Dissolving the 4 axes into a single quaternion $\delta = \text{time} + i \cdot \text{space} + j \cdot \text{observer} + k \cdot \text{superposition}$ erases the bracket category distinction and is therefore prohibited. Quaternions apply only to subframes inside the brackets.

Application target = all 3-axis orthogonal subframes. Quaternions are unnecessary for 1-axis scalars (time, observer, superposition individually). However, all 3-axis orthogonal groups are expressible as quaternions — the 3-axis orthogonal groups inside this axiom system:

The concepts of time and space are taken from classical physics as-is (Axiom 1) — time = 1D scalar, space = 3D orthogonal. CAS 3-axis orthogonality is stated explicitly in Axiom 2 proposition — locks enforce ignition order (Axiom 5), but the orthogonality of the 3 axes themselves is preserved (simultaneous bit representation 001/010/100, line 392).

Spatial 3-Axis Orthogonality (x, y, z) ==> Pure Imaginary Quaternion

The space axis is unfolded into 3 components (x, y, z) by the action of the CAS 3-axis orthogonal locks (R_LOCK, C_LOCK, S_LOCK) (Axiom 2 Proposition: Dimension, Axiom 11 Proposition). 3-axis orthogonality cannot be expressed by the unit circle (2-axis) — the natural expression is the pure imaginary part of a quaternion (Hamilton 1843).

The 3 imaginary units i, j, k correspond 1:1 with the x, y, z axes. All three square to -1 — the same pattern as the unit circle's $i^{2} = -1$ extended to 3D. The unit sphere equation is equivalent to |pure imaginary quaternion|² = 1.

3D Euler Form (Quaternion Exponential)

The 2D Euler form $e^{i\theta} = \cos\theta + i\sin\theta$ extends to 3D as the quaternion exponential form:

Every unit pure imaginary quaternion squares to -1 — the same pattern as the unit circle's $i^{2} = -1$ extended to 3D. The unit quaternion exponential generates 3D rotations (Rodrigues formula).

Recursion Principle — Form of N Orthogonal Axes

Any N-axis orthogonal group defined by an axiom has the unit N-sphere form by the same pattern. Key constraints:

• Bracket separation is preserved — the outer two brackets of the Banya Equation use only up to the (Banya Equation in Unit Circle Form) proposition
• Quaternions apply to all 3-axis orthogonal groups inside brackets — space (x, y, z), CAS (R, C, S), and any other 3-axis orthogonal subframes
• time/space concepts are physics as-is — time 1D, space 3D, no redefinition

This proposition follows from Axiom 1 (orthogonality) + the (Banya Equation in Unit Circle Form) proposition + Axiom 2 Proposition (Dimension: spatial 3 axes) by extension alone, without additional assumptions. Therefore it is a structural consequence of Axiom 1.

Clifford Form — Distinguishing Structural Notation from Operator Proposition

When the degrees of freedom (4 domains + 3 CAS, Axiom 9) of this system are formalized in Clifford algebra, the use as structural / dimensional notation is distinguished from the use as a multivector operator.

Cl(7): Structure

All states the 7-bit d-ring can hold (Axiom 9: data type 128 = 2⁷) coincide exactly with the multivector dimension of Cl(7). They are organized as an algebraic structure with grades (scalar, vector, bivector, ...).

Cl(3): Write Under 3-Axis-Orthogonal State

Defined in Axiom 2 Proposition "Juida (Writing) Is a Cl(3) Bivector Rotation". It is the form taken when CAS 3 axes (R, C, S) write in the 3-axis-orthogonal state.

Common Product Rule

Both objects follow the same Clifford product rule. Self-products are ±1 by signature, distinct generators are anti-commutative ($\gamma_i \gamma_j = -\gamma_j \gamma_i$). Associativity, distributivity, and norm preservation hold. The signatures are a consistent extension of the i² = −1 convention from the unit circle form (Axiom 1 Proposition).

This proposition follows from Axiom 1 and Axiom 9 without additional assumptions.

4-Axis Orthogonality = 4 Bits Proposition

Orthogonal = independent. If independent, each axis turns ON/OFF without interfering with others. Independent ON/OFF without interference = bit. Since the 4 axes are orthogonal (Axiom 1), they form 4 bits. $2^4 = 16$ domain combinations are possible.

Ring buffer order (Axiom 15): observer, superposition, time, space. bit 0~1 = quantum bracket, bit 2~3 = classical bracket. $2^4 = 16$ combinations. Only 8 representative entries shown.

CAS (OPERATOR) is 3 bits (Axiom 5: R_LOCK, C_LOCK, S_LOCK), and DATA (domain) is 4 bits. The operator is bits, the operand is bits. They must speak the same language for TOCTOU_LOCK (Axiom 5) to latch and release at the contact point.

The domain 4 bits are CAS's access state flags. Which domain bits are ON determines which path CAS takes for access, and the path determines the cost structure.

CAS 3 bits: operator's progress state  (what is it doing)
Domain 4 bits: operand's access state  (which are open)

Domain 4-bit example:  0 1 1 0
                       | | | |
                       | | | +-- bit 0 observer:      0 (closed)
                       | | +---- bit 1 superposition: 1 (open)
                       | +------ bit 2 time:          1 (open)
                       +-------- bit 3 space:         0 (closed)

-==> CAS can access only superposition and time
-==> Cost structure diverges by access path

Cost = the number of times a + boundary is crossed in order in the access path. If only one axis is ON, crossing = 0; if orthogonal axes within the same bracket, no order exists so cost = 0; if it crosses + in order, cost >= 1. The ON/OFF combination of domain 4 bits determines the + crossing count, and the crossing count is the cost.

Lock = Bitwise AND Proposition

TOCTOU_LOCK (Axiom 5) is the AND operation of CAS bits and domain bits. This AND is not a separate operator but is performed by CAS's Compare step (Axiom 2: CAS is the only operator). Compare compares CAS bits and domain bits, and a lock is acquired only at contact points where both are 1. If either side is 0, no contact point is established.

CAS 3 bits:    0 1 1        (Compare+Read done, Swap pending)
              S C R

Domain 4-bit: 1 0 1 0      (superposition, space open)
              s o p t

AND (contact point = where lock engages):

  R(1) AND t(0) = 0  -- not engaged
  R(1) AND p(1) = 1  -- engaged (Read occupies superposition)
  C(1) AND o(0) = 0  -- not engaged
  C(1) AND s(1) = 1  -- engaged (Compare occupies space)

Lock engaged = both the CAS bit and the domain bit are 1 simultaneously. Lock released = one side resets to 0. This is the bit-level implementation of Axiom 5, "a lock exists at the contact point between CAS and DATA." Because CAS 3-bit (Axiom 5) and domain 4-bit (Axiom 1 Proposition) share the same language (bits), AND operations are possible. It is the Compare stage of CAS that performs this AND (Axiom 2). Since CAS is the only operator in the universe (Axiom 2), all bit operations including AND are internal operations of CAS.

Axiom 2. CAS Is the Sole Operator Axiom

Every change that occurs in the universe is a repetition of the single CAS (Compare-And-Swap) operation. CAS is an independent local operation with no internal storage (register). The same CAS runs independently in parallel at every local juim. There is no central control, and each local juim is its own address. CAS is a worker, and the universe operates as an ECS (Entity-Component-System) structure (Axiom 12, defined later).

Why CAS is the sole operator. The δ in the Banya Equation (Axiom 1) describes one change. The definition of change requires simultaneous comparison of the pre-change state and the post-change state, so an atomic operation that handles two states inside a single operation is required. The only atomic operation that satisfies this condition is CAS. The operator that brings forth order and change is therefore fixed as CAS. Regardless of which domain CAS operates through (time, space, observer, superposition), the atomic operation at the bottom is the same CAS.

Note on Swap's condition count 2² = 4. Swap's internal state is isWriteAble(true/false) × result(true/false) = 2×2 = 4 configurations. Here, result is the Compare return value (true/false) forwarded into Swap.

At runtime, since Compare false prevents entry into Swap (Axiom 7), result is always true at Swap entry. Therefore the only independent branching variable inside Swap is isWriteAble, and the reachable runtime paths are 3.

The condition count is nevertheless stated as 2² = 4 because it describes the register size (design capacity). The Read = 2⁰, Compare = 2¹, Swap = 2² structure justifies the bit shift (001 ==> 010 ==> 100), and grounds the CAS internal DOF sum 1 + 2 + 4 = 7. If Swap were 2¹, it would have the same bit width as Compare, breaking the shift structure.

The sum of CAS internal states (1+2+4=7) has the same structure as the number of independent variables. The number of independent variables needed to fully describe a system is degrees of freedom, and the number of internal states needed to fully describe 1 CAS is 7. They are different names for the same structure.

The 3 CAS stages operate as bit flags. Each stage occupies 1 bit, and all 3 bits must be ON (111) for 1 CAS to be complete. If any bit is 0, it is incomplete. This is the bit-flag representation of atomicity (indivisible).

This 7 decomposes in two ways:

The first is how many states each stage has, and the second is the space the operator acts on (domain 4) and the number of stages of the operator itself (3). Though the decomposition methods differ, the same 7 results. This is not a coincidence but because CAS is the sole operator acting on the 4 axes of the Banya expression.

The 3 stages are indivisible (atomic). This is the origin of CAS atomicity (the cost of maintaining 111).

CAS 3-Axis Orthogonality Proposition

The 3 stages of CAS (Read, Compare, Swap) are mutually orthogonal. Each stage occupies an independent 1-bit (001, 010, 100), and no stage invades the degrees of freedom of another. This is the basis for R_LOCK, C_LOCK, S_LOCK (Axiom 5) being independent degrees of freedom. These 3 independent lock degrees of freedom act on the space axis of DATA (Axiom 1) to unfold space into 3 components (Axiom 11 Proposition).

Data Types of CAS Proposition

In the workbench (Axiom 2 Proposition), structure DOF (DATA) is the operand and cost DOF (OPERATOR) is the opcode. CAS runs opcodes to access operands. Internal movement within operands is possible only by shift ($2^N$), and operands and opcodes are orthogonal via + (Axiom 9 Proposition).

Filter rules: Only numbers registered in the complete description DOF (Axiom 9) are recognized as data types. Structure DOF and cost DOF are different brackets, so filters are applied separately.

Workbench Is the Workspace of CAS Proposition

The 3 internal axes of CAS (R, C, S) are orthogonal (Axiom 2 Proposition). The Euclidean inner-product space they generate is the workbench, and its unit-sphere norm is ‖CAS‖ = √3. The workbench is not a scalar value but a vector space on which a norm is defined (norm space), and CAS resides inside that space as an opcode operator.

The workbench operates over the OPERATOR bracket (observer + superposition, Axiom 1). When the opcode (OPERATOR) accesses the operand (DATA, time + space), CAS selects a data type (Axiom 2 Proposition), reads, compares, and creates juim.

                                    +--- observer
                                    |
  CAS [Workbench(R⊥C⊥S, ‖√3‖)]-----+--- superposition
                                    |
                                    +--- time
                                    |
                                    +--- space

                           Interacts via data types (Axiom 2 Proposition)

Work Sample Using Finest Data Type 137 Proposition

Data type 137 (T(16)+1, Axiom 2 Proposition) is the finest data type used by CAS. Decomposing 137 bits yields d-ring, state space, and equality.

  137-bit workbench layout (sample, exact operation unknown — this is a rough structural explanation as a sample, to be reinforced in future updates):

  bit     Role              Belongs to      Size
  -----   ---------------   -------------   --------
  [0]     observer          Register
  [1]     superposition     Register         d-ring
  [2]     time              Register         8-bit
  [3]     space             Register          
  [4]     R_LOCK            Register (Read)
  [5]     C_LOCK            Register (Compare)
  [6]     S_LOCK            Register (Swap)
  [7]     delta             Clock (1=firing, 0=reset)
  -----
  [8]     Slot 0            State space
  [9]     Slot 1            State space      128-bit
  ...     ...               ...              (2^7)
  [135]   Slot 127          State space
  -----
  [136]   ret(equality)     Return            1-bit
  --------------------------------------------------

  137 = 8  + 128(state space) + 1(ret)

Juim and Juida Proposition

Juim is the result produced the moment CAS Swap (111) executes on DATA. The state where 3 orthogonal locks (R_LOCK, C_LOCK, S_LOCK) simultaneously grip one location is 111, and the act of this 111 crossing + to create one ball in DATA (space) is juim.

Juida (Writing) Is a Cl(3) Bivector Rotation Proposition

The 3 CAS axes (R_LOCK, C_LOCK, S_LOCK) are mapped to the xyz axes of DATA space by Axiom 11 Proposition. The Clifford algebra over these 3 axes is Cl(3), whose bivectors are $e_{12}, e_{23}, e_{31}$ — three in number, equal to the number of SO(3) generators. The Cl(3) multivector dimension is $1 + 3 + 3 + 1 = 8 = 2^{3}$ (scalar 1 + vector 3 + bivector 3 + pseudoscalar 1).

The reason r is direction-independent is not a separate assumption but a result that follows automatically from the equal-amplitude operation of Cl(3) bivectors. Isotropy defined inside the axiom circuit is the formal statement that the amplitudes of the three rotation planes are equal.

Why "pressure" must not be used to describe this. Pressure is a physical quantity defined as force per unit area inside a continuum medium. The Banya Equation structure contains no primary medium, no force, and no unit area: DATA is discrete (Axiom 3), and every physical quantity is defined only through the accumulation of 1-ball units and the cost distribution of that accumulation (Axiom 4). Therefore "the pressure is isotropic" is a sentence not definable inside this axiom circuit, and the correct formal statement of isotropy is "the amplitudes of the three Cl(3) bivectors are equal." Pressure is only an approximate appearance in external domains where a sufficient number of juim have accumulated.

A Ball Is a Discrete Unit Proposition

DATA is discrete (Axiom 3). The ball that juim creates is not a continuum but a discrete unit — the shape of the minimum 1 change that cannot be further divided. There is no such thing as 0.5 balls. What 1 CAS cycle creates is exactly 1 ball, and this is the geometric identity of discreteness in the Banya Framework. Physical quantities that appear continuous are the result of sufficiently many balls accumulated.

Juida is the act of CAS creating a juim in DATA. When 1 CAS cycle (000==>001==>011==>111==>000) completes, Swap (111) crosses + and grips one ball in space. Formally it is one application of the Cl(3) equal-amplitude bivector rotor $R = \exp((e_{12} + e_{23} + e_{31}) \cdot \theta/2)$. 1 juim = 1 write = 1 cost (Axiom 4).

Attenuation Is Continuous, Threshold Is Discrete Proposition

The three properties of juim reside in different layers.

Ball either exists or does not in DATA (discrete). Gripping force decays as a geometric series continuously in RLU (OPERATOR). Cost is distributed in space as the contraction region around the ball. Because the three properties live on different layers, the discreteness of the ball and the continuity of the force do not conflict.

Writing threshold = 4/13. Gripping (writing) means holding 3 axes simultaneously. 3-axis grip (3) + timestamp (1) = maintenance cost 4 (Axiom 6). Since the total cost per CAS cycle is 13, when gripping force falls below 4/13, there is not enough cost to maintain the 3-axis grip — it releases. Crossing + is reading (access) and gripping is writing (maintenance), so the threshold is determined by the write maintenance cost. It is the write cost (4) that sets the threshold, not the read cost (8).

Shift Unit per Type in Workbench Proposition

Because there is no logical address (Axiom 12), the only means for CAS to reach another position is sequential shift (2^N). Random access is impossible. The workbench is the shift space. Depending on the target, CAS picks the matching type (Axiom 2 Proposition).

Type sizes at which CAS reads a target (3 samples from types):

  Type 7 (CAS internal):   |---|---|---|---|---|---|---|
                           CAS 3-stage comparison pairs. 1 shift = 1/7.

  Type 30 (access path):   |--|--|--|--|--|--|--|--|--|--|...(30 slots)
                           CAS x domain path. 1 shift = 1/30.

  Type 137 (domain comparison): ||||||||||||||||||||||||||||...|||(137 slots)
                                Domain 16-combination comparison pairs. 1 shift = 1/137.

  Same single revolution. Type differs depending on the target.

Dimension Proposition

Space is 3-dimensional. Nibble 1 of the d-ring contains CAS 3 bits (R_LOCK, C_LOCK, S_LOCK). The CAS 3 axes are orthogonal (Axiom 2 Proposition). 3 orthogonal axes = 3 independent directions = 3 dimensions. There is no 4th lock (Axiom 2), so there is no 4th dimension of space either.

  d-ring (8-bit ring. Nibble 1 contains CAS)
    |
    +-- Nibble 1: R_LOCK(bit4) + C_LOCK(bit5) + S_LOCK(bit6) + δ(bit7)
    |           |
    |           +-- CAS 3-axis orthogonality (Axiom 2 Proposition)
    |           |   R ⊥ C ⊥ S = 3 independent directions = 3-dimensional space
    |           |
    |           +-- δ firing = hash chain. Not stacked. Only the present is recorded
    |
    +-- Space: 3-dimensional (CAS 3-axis orthogonality)
    +-- Time: hash chain (δ firing repeated. Not a dimension)

  Why is space 3-dimensional: Because CAS, whose 3 axes are orthogonal, grips the space domain and records the ball in the time domain together with a timestamp.

CAS-ring. A structure where CAS, whose internals are orthogonal (Axiom 2 Proposition: CAS 3-axis orthogonality), cycles (000==>001==>011==>111==>000). The internals are orthogonal (simultaneous), but the lock (TOCTOU_LOCK, Axiom 5) forces a firing order — C is impossible without R, S is impossible without C. This order enforcement makes the CAS-ring an FSM. Orthogonality gives structure, the lock gives order, and order defines FSM state transitions.

CAS Cycle. The CAS-ring cycles forward (000==>001==>011==>111==>000). At 111 it crosses + and creates a ball (grip), then simultaneously resets to 000 to await the next firing:

  FSM       Location    State                                     Cost
  000       OPERATOR    Idle. CAS-ring spins                        0
  001       Entry(R)    R_LOCK. Read begins                        +1
  011       Entry(R+C)  C_LOCK. Comparing                          +1
  111       DATA(R+C+S) S_LOCK. Crosses +. Ball created (grip)     +1
  000       OPERATOR    Simultaneous reset. Return. Await firing    0

Forward advance followed by simultaneous reset. Not a reverse retreat. Each R, C, S transition crosses + for cost +1 (Axiom 4). When it returns to 000, the next δ firing becomes possible.

Geometric Range of the CAS Forward Path = Hemisphere (π) Proposition

CAS 3-axis orthogonality (Axiom 2 Proposition) defines a Euclidean inner-product space, and the unit sphere of this inner-product space is the workbench (Axiom 2 Proposition). The forward path of the CAS FSM, 000==>001==>011==>111, traverses this sphere from the null vertex (000) to the antipode (111) — a hemisphere. The arc of a hemisphere is π.

Why π (not 2π). CAS is irreversible (Axiom 2 Proposition: R==>C==>S reverse order impossible). Only the forward direction (000==>111) pays cost and traverses the sphere. The return 111==>000 is a simultaneous reset at cost 0 — it is not a reverse traversal and traces no arc. The geometric range is the cost-paying forward hemisphere (π), not the full sphere (2π). 2π is impossible because it includes the reverse direction (forbidden); π/2 is impossible because it corresponds to crossing only 1 of the 3 boundaries (incomplete).

Why only π can arise. By the spherical measure formula Vol(Sⁿ⁻¹) = 2π^n/2/Γ(n/2), the only transcendental constant that can arise from the sphere of a finite-dimensional real inner-product space is π. Other transcendental constants (e, ln 2, etc.) cannot arise from an orthogonal-norm sphere. As long as CAS 3-axis orthogonality (Axiom 2 Proposition) defines a Euclidean inner-product space, the geometric constant is uniquely determined as π.

Norm of active axes at each FSM state:

Because the 3 axes are orthogonal (Axiom 2 Proposition), the norm is uniquely determined as √1, √2, √3 according to the number of active axes. √3 is the workbench norm (Axiom 2 Proposition), √2 is the norm at the moment of crossing + (Compare point), and √1 is the norm at Read entry.

Dimension is a sub-frame of domain. The 4 domain axes (time, space, observer, superposition) are the superstructure, and dimension is the number of independent bit-movement directions within that domain.

CAS Is an Operator Outside Time Proposition

R==>C==>S is not a temporal order but a logical dependency. CAS write(juida)s to the time axis from outside the time axis. When CAS writes to time, the arrow of time is born. System time = number of CAS cycles. Domain time = log of system time = the time felt inside the screen (classical bracket).

Complementarity of the Banya Equation and the Bit-Transition Diagram — CAS Cannot Be Seen in the Banya Equation's Geometric Representation Proposition

CAS is the logical entity that handles operation (Axiom 2). It is an operator that performs operations, not an object with a coordinate. Therefore CAS cannot be seen in the Banya Equation's geometric representation (the static norm form, Axiom 1). The label "OPERATOR — CAS is located here" on the Banya Equation marks the domain of operation, not a coordinate.

The precise location of CAS is captured in the dynamic form — the bit-transition diagram (Axiom 15). In the 8-bit d-ring, CAS occupies the three slots at bits 4~6 (R_LOCK, C_LOCK, S_LOCK); TOCTOU_LOCK (Axiom 5) enforces the R==>C==>S order; and bit 7 (δ) serves as the firing trigger. The dynamic ordering fills the gap left by the absence of a static coordinate.

The two forms are two faces of the same system; neither alone gives a complete description. The full definition of CAS is obtained only by their combination — where it operates is answered by the Banya Equation, and how it operates is answered by the bit-transition diagram. δ is the bridge: when bit 7 (δ) is ON in the bit-transition diagram, the Banya Equation holds; when it is OFF, the left-hand side is invalid.

Axiom 3. DATA Is Discrete, OPERATOR Is Continuous Axiom

DATA (spacetime) is discrete. A grip is a ball, and the minimum movement unit is 1 slot. Because the continuous limit ($\Delta x \to 0$) does not exist, differentiation does not hold.

Conventional physics using differentiation on spacetime is an approximation that projects the continuous distribution from superposition space (OPERATOR) onto DATA. When grips are sufficiently numerous, the discrete appears continuous and differentiation becomes a valid approximation. But the fundamental is discrete. Relationships between entities are described not by differentiation but by difference ($\Delta$) and modular arithmetic (mod $N$).

Axiom 4. Cost Axiom

In the Banya equation δ² = (time + space)² + (observer + superposition)², + is a connection marker between orthogonal objects. Connecting two orthogonal objects means crossing one independent axis. Crossing + once = traversing 1 dimension. Counting +'s = counting dimensions.

Cost 1 is incurred when + is crossed in order. If there is no order, cost is 0 even if + exists. The + marks orthogonality (structure) only; cost arises only when order exists.

Order creates irreversibility and discreteness simultaneously. CAS's R==>C==>S has order (Axiom 5: locks enforce order). Where there is order, it cannot be reversed (irreversibility). Where there is order, it is broken into steps (discreteness = quantization). Axes without order (observer, superposition) have no cost, no irreversibility, and no discrete steps. Irreversibility and discreteness are not separate properties — they emerge simultaneously from a single cause: order.

Path by which CAS creates a grip in space — read (access) and write(juida):

  [Read: access target by crossing +]

  CAS (OPERATOR, R·C·S each +1)
   |
   +--- Crosses OPERATOR + classical bracket boundary ---   read cost +1
   |
  Classical bracket (time + space)
   |
   +--- Crosses time + space boundary (space access) ---    read cost +1
   |
  space (x + y + z, CAS 3-axis orthogonal)
   |
   +--- x access ---                                       read cost +1
   +--- x to y crossing ---                                 read cost +1
   +--- y to z crossing ---                                 read cost +1

  [Write(juida): record value to each component]

   +--- write(juida) timestamp to time ---                  write(juida) cost +1
   +--- write(juida) to x ---                               write(juida) cost +1
   +--- write(juida) to y ---                               write(juida) cost +1
   +--- write(juida) to z ---                               write(juida) cost +1

  Total cost = read (number of + crossings) + write(juida) (number of records)

Different paths cross different numbers of + = different costs.
Within the same group = no + crossing = cost 0.

Irreversible Cost Table: Cost Accumulation per d-ring Segment Proposition

Cost arises only from CAS + transitions. Axes where CAS intervenes are irreversible (Axiom 2 Proposition: R==>C==>S reverse impossible, no refund), and axes where CAS does not intervene are non-irreversible. This binary verdict uniquely determines the cost accumulation structure of the CAS internal DOF 7 axes (Axiom 9). Accumulated cost is managed by indexing (Axiom 13).

Cost accumulation = (5, 2). 5 irreversible axes (cost accumulation +), 2 non-irreversible axes (no cost accumulation). Physical meaning of the partition: 5 axes undergo Compare true ==> write (Axiom 7) ==> cost accumulation ==> no refund (Axiom 2 Proposition). 2 axes undergo Compare false ==> superposition maintained (Axiom 7) ==> no cost accumulation ==> reversible. The branch (true/false) of Axiom 7 divides the d-ring into irreversible and non-irreversible segments.

Cost Is the Sole Physical Quantity of δ Proposition

Cost is the physical quantity of change (δ). When δ fires (Axiom 15), CAS crosses + (Axiom 4), and a grip is recorded in DATA (Axiom 7), cost is incurred. Cost is the sole physical quantity measured on the d-ring — there is no other physical quantity on the d-ring besides cost. Energy, mass, force, and entropy are all different names for cost.

That cost is irreversible is self-evident. Cost arises from change that crosses domains — i.e., interaction (Axiom 4: if + is crossed, cost > 0). Interaction is an event between two domains, so once one side changes it cannot be undone. Staying within a domain incurs no cost (+ is not crossed); the moment a domain is crossed, it is irreversible.

Cost and type are different. Type (Axiom 2 Proposition) is the size unit of the CAS internal workbench — the type size CAS uses when reading a target, not a physical quantity on the d-ring. Cost is what arises when crossing a d-ring segment, while type is the scale at which CAS decomposes a target inside the workbench. The layer of cost is the d-ring (Axiom 4), and the layer of type is the workbench (Axiom 2 Proposition).

Reading Cost in Norm Proposition

The same + is read in two ways — cost reading and norm reading. The two readings are different unit expressions of the same + crossing. Counted as an integer it is 1; measured as arc length it is π. They are two expressions of the same crossing, not different events.

norm reading is valid only for irreversible +. Reversible axes (observer, superposition) have cost 0 and therefore draw no arc (Axiom 2 Proposition). Reversible quantities can only use cost reading integers — they cannot be expressed as nπ in norm reading.

Combination rules.

cost and norm are orthogonal categories, so the integer of cost reading and the nπ of norm reading combine via Axiom 1's orthogonal sum, not within-type arithmetic addition. When combining the two in one expression, + is the orthogonal sum (same structure as DATA ⊥ OPERATOR), not arithmetic addition.

Two readings of the same + 1 crossing:

  +  ===>  cost reading = 1     (integer count)
  +  ===>  norm reading = pi    (arc length)

  Same single crossing, measured in different units

9 irreversible + crossings:
  cost reading = 9      (integer count)
  norm reading = 9*pi   (accumulated arc length)
  -- Different unit expressions of the same 9 crossings

Combination:
  cost 2  +  norm 9*pi  =  "2 + 9*pi"
                           orthogonal sum (Axiom 1)
                           NOT arithmetic sum

  cost reading + cost reading:  n1 + n2 = (n1 + n2)         arithmetic
  norm reading + norm reading:  n1*pi + n2*pi = (n1+n2)*pi  arithmetic
  cost  +  norm:                n + m*pi                    orthogonal sum (Axiom 1)

This proposition provides the tool for reading the same + structure in two units (integer / arc length). When derivation gets stuck under one reading, the same + can be re-read in the other reading to proceed. Both readings follow directly from Axiom 4 (cost) and Axiom 2 Proposition (hemisphere), so they are not additional assumptions.

Axiom 5. TOCTOU Lock Register Axiom

TOCTOU_LOCK is the device by which the CAS-ring (Axiom 2, Axiom 12) enforces order. The CAS 3 axes are orthogonal (Axiom 2 Proposition) — inherently simultaneous. But when the lock enforces order, simultaneity breaks and sequential access results. Sequential access crosses +, so cost is incurred (Axiom 4). The lock is not cost itself but the cause that creates cost.

The CAS 3 axes are orthogonal (simultaneous), but the lock forces the R==>C==>S firing order. What the lock forces is order, and what order creates is cost (Axiom 4). One exists independently per observer (not a central lock, ECS Axiom 12).

Axiom 6. Cost Recovery Axiom

The total cost incurred when CAS creates a grip is recorded in RLU (superposition domain index). RLU recovers this cost continuously.

Ball cost = 3-axis grip (3) + timestamp (1) = 4. When these 4 are released, the ball disappears from DATA (discrete release). However, misc cost = 13 - 4 = 9 remains in the superposition domain (RLU index). These are CAS transition costs, + movement costs, etc.

RLU recovers the misc cost 9 continuously (decay is continuous, threshold is discrete — Axiom 2 Proposition). Full recovery is required before that space is truly returned. Even when the ball disappears from DATA, the cost does not "vanish" — cost being recovered persists in the RLU index. To cycle, recovery is required.

Flow of cost:

  CAS execution ==> cost incurred (total 13) ==> recorded in RLU
       |
       +-- Ball cost (4): 3-axis grip + timestamp
       |   When released ==> ball disappears (DATA discrete release)
       |
       +-- Misc cost (9): CAS transition + domain movement cost
           Continuously recovered in RLU ==> space returned upon full recovery

Axiom 7. Write (Juida) and Superposition Maintained Axiom

Quantum is the default, and classical is the result of cost.

Each CAS cycle:

  CAS-ring internal:  Read(+1) ==> Compare(+1) execution
       |
       +-- Compare true  ==> Swap(+1) ==> write(juida) to DATA = collapse
       |                       Cost incurred (Axiom 4)
       |                       What is gripped is a ball (Axiom 2 Proposition)
       |                       Total cost recorded in RLU (Axiom 6)
       |
       +-- Compare false ==> Swap not executed ==> superposition maintained
                               Read(+1), Compare(+1) already paid

  If cost is spent ==> classical (recorded in DATA)
  If cost is not spent ==> quantum (remains in OPERATOR)

There are 3 conditions for collapse:

When all 3 conditions are satisfied, collapse occurs. One ball is created in DATA (time+space) by one application of the Cl(3) equal-amplitude bivector rotor (Axiom 2 Proposition). If even one condition fails, superposition is maintained. Collapse is one of the normal execution paths of CAS.

A grip is a record of change in spacetime, and the total cost incurred is recorded in RLU to become a recovery target (Axiom 6). When there are multiple grips, interactions between entities arise and cost increases (Axiom 13 Proposition).

Reversal (classical==>quantum) requires a cost refund, but irreversibility (Axiom 2 Proposition) makes refund impossible. Recovery is not refund but natural release through continuous decay of RLU (Axiom 6).

Axiom 8. Observer-Driven Polling System Axiom

The self-referential loop of d-ring always runs every tick of system time. It checks the state every tick regardless of whether any change has occurred. This is polling. δ firing and observer filtering have zero cost (Axiom 15, Axiom 10). When CAS-ring executes, each transition through R, C, S crosses + and incurs cost +1 (Axiom 4).

This polling loop is δ itself. The identity of δ is revealed in Axiom 15.

idle polling

idle polling (Axiom 8) checks whether δ has fired. δ firing itself has zero cost (Axiom 15). When CAS-ring executes, each transition through R, C, S crosses + and incurs cost +1 (Axiom 4). For distortion phenomena on the DATA side, see Axiom 11 Proposition (Distortion of empty entities is a structural necessity).

Axiom 9. Complete Description DOF Axiom

The complete description DOF divides into structure-derived and cost-derived. Numbers with prime factorization into preceding numbers (6=3×2, 8=2³, etc.) are not independent and are excluded. Norm-derived values (√1, √2, √3) are also excluded.

Complete description DOF follows the Banya equation Proposition

The rules of the Banya equation $\delta^2 = (\text{DATA})^2 + (\text{OPERATOR})^2$ apply to the complete description DOF as well. Structure (DATA) and cost (OPERATOR) are orthogonal brackets, and descriptions are composed only by + crossing between brackets.

The structure side is DATA, and the cost side is OPERATOR. Movement within the same bracket is possible only by shift ($2^N$) (Axiom 12 Proposition). Structure side internally: $1 \to 2 \to 4 \to 16 \to 128$ are all $2^N$ shifts. Between structure and cost, they are orthogonal via + (Axiom 1). Crossing + incurs cost (Axiom 4). Within the same bracket, + cannot be used — only shift. + is used only when crossing brackets.

Within the same bracket: shift only
  Structure (DATA):   2⁰ ==> 2¹ ==> 2² ==> 2⁴ ==> 2⁷   (shift)
  Cost (OPERATOR):    internal movement is also shift

Crossing brackets: orthogonal via +
  Structure + Cost = valid description
  2³ + 13 = 21
  2⁴ + 13 = 29
  2⁷ + 13 = 141

Forbidden:
  Structure + Structure = invalid (+ forbidden within same bracket)
  Cost + Cost = invalid (+ forbidden within same bracket)

Axiom 10. Global-Local Loop Axiom

δ (global) accesses itself through observer (local), and the result is reflected back to δ — a cyclic structure.

Properties of observer

Elimination method of δ Proposition

What can appear on the left side of the Banya equation equality sign (=).

δ=0 (equality sign not established) is defined in Axiom 7. Equality sign not established = superposition maintained.

Auto-recursion Proposition

The CAS result is reflected in δ, and the reflected δ is filtered again through each observer in the next cycle. It auto-cycles by axiom declaration alone.

Global-local loop preservation Proposition

If this loop is severed, the system dies. The only constraint: the global-local loop must not be violated.

Axiom 11. Multiple Projection Axiom

δ is one (Axiom 8). Observers are many. Because observer is a filter (Axiom 10), a single δ is filtered differently through each observer. Each observer filters the projection of δ and passes it to the CAS workbench (Axiom 2 Proposition), and CAS creates a juim in DATA. Since each observer filters independently, many entities arise from a single δ. This is multiple projection.

δ (1, sole equality sign)
    |
    | δ fires ==> reaches all observers simultaneously
    |
    +==> observer A (filter) ==> CAS[workbench] ==> Entity A (juim)
    |
    +==> observer B (filter) ==> CAS[workbench] ==> Entity B (juim)
    |
    +==> observer C (filter) ==> CAS[workbench] ==> Entity C (juim)
    |
    ... (as many as observers)

The universe that appears infinite is the result of a single δ simultaneously projected through many observer filters. It is not that the substance is infinite — because the filters are many, the results are many.

Why all local juims are identical: δ is one, and what appears as a local juim is the image of that δ projected through multiple observers. Since they are projections of the same δ, all local juims have the same cost, the same domain bit pattern. All local juims are identical, and all projected images are identical for the same reason.

Note: In 1940, John Wheeler intuited that "there is only one electron" but could not prove it. Wheeler saw the electron moving back and forth along the time axis; Banya Framework sees δ as multiply projected along the observer axis. The mechanisms differ, but the conclusion is the same.

Distance independence of δ simultaneous projection: The images reflected in observer A and observer B are simultaneously correlated because they are looking at the same δ. No signal is transmitted from A to B. The same change of the same δ is cast simultaneously on both shadows. Since δ is one, simultaneity is guaranteed.

Inter-entity distance ℓ Proposition

The reason space is 3-dimensional is defined in Axiom 2 Proposition (dimension). Each juim is its own origin — because in ECS (Axiom 12) there is no center, and each Entity is independent.

There is only one kind of distance. $\ell$ = distance between two entities. $\ell$ determines both the magnitude of cost ($1/\ell^2$ decay) and the type of cost ($(1-\ell/N)$).

$\ell$ = distance between two entities (Axiom 12).

Contraction overlap = shared digit ratio on the ring Proposition

Each juim (result of write(juida), Axiom 7) is located as one ball on a sphere. Swap consumes DATA (space) (Axiom 7). Consumed space shrinks. The space around a juim is contracted, and the more juims in the same region, the larger the overlapping contraction region. Contraction region = range of space contraction around a juim. The size of the contraction region is determined by the CAS cost structure of that juim (Axiom 2, Axiom 4).

The diagram below is in linear (1D) notation. Actual contraction is the SO(3)-symmetric result of the Cl(3) equal-amplitude bivector rotor (Axiom 2 Proposition) unfolded across the spatial xyz subframe, appearing as a spherical form. Since ASCII cannot represent spheres, the norm space is unrolled into linear notation.

No juim:  ========================= (space uniform, no contraction)

Juim present: ====\               /==== (space contraction)
                 \             /
                  \           /
                   \         /
                    \       /
                     [juim]

On sphere:

  juim A ----- ℓ ----- juim B
  [ contraction a ]      [ contraction b ]
          \               /
           \             /
            -- overlap --
            = (1 - ℓ/N)

ℓ small ==> many overlapping DATA addresses ==> much read contention ==> total cost large
ℓ large ==> few overlapping DATA addresses  ==> little read contention ==> total cost small
When contraction regions of two juims overlap ==> read contention
==> number of contended addresses × cost per address (Axiom 4) = total cost

The size of the contraction region is determined by the number of + crossings when CAS accesses the target (Axiom 4) and the type (Axiom 2 Proposition).

Contraction overlap ratio = $(1 - \ell/N)$. $\ell$ is the shift distance between two juims on the ring, $N$ is the type, Axiom 2 Proposition. $\ell = 0$ is unreachable in a discrete system (minimum $\ell = 1$). If $\ell = N$, no overlap (opposite side). Ring size $N$ is determined by CAS stage combinations, so the overlap ratio comes from combinations of axiom numbers. The overlap ratio varies depending on whether the two juims overlap in the workbench type N, and that proportion is the numerical value of the overlap ratio.

All overlap ratios are proportions that come from the spherical geometry of Axiom 11 (1:N projection), not externally measured parameters. $\ell$ is the distance between two entities. The only other variable is the angle $\theta$ between projections.

Note: Actual contraction is the SO(3)-symmetric result of the Cl(3) equal-amplitude bivector rotor (Axiom 2 Proposition), appearing formally as a spherical representation. Since the 3-axis norm (√3) is length (scalar), the distance between two entities is expressed as $\ell$, and since equidistance in 3 dimensions = sphere, it is described by geometry on the spherical surface. The sphere is not the substance of contraction but the result of norm representation.

The complete form of inter-entity interaction strength (Axiom 13 Proposition):

Distortion of empty entities is a structural necessity Proposition

CAS Compare of the workbench (Axiom 2 Proposition) has a fixed type size. When Compare reads with type N, the read range is wider than the juim itself. If an empty entity that has never been written enters this range, Compare cannot distinguish the empty entity from a juim — since the type size is fixed, the read range cannot be reduced. A distortion occurs where the empty entity is read as if it were written. This is not an error but a structural necessity of fixed-type reading.

Axiom 12. Classical Bracket Is ECS Execution Model Axiom

If Axiom 11 (multiple projection) defined the 1:N relationship of δ==>observer, Axiom 12 defines how that projection is executed. It is an execution model where CAS independently processes the projection arriving at each observer.

ECS (Entity-Component-System) Structure

ECS execution model:

observer A: [DATA_A] <-- CAS independent execution
observer B: [DATA_B] <-- CAS independent execution
observer C: [DATA_C] <-- CAS independent execution
...
All parallel. All independent. All same CAS.
No logical address needed -- entity is the address.

Why ECS is free

Multiple projection of δ (Axiom 11) creates as many entities (shadows) as the number of observer filters. CAS is independently assigned to each entity — because observer is the LUT (Look-Up Table) that maintains the δ==>entity mapping. Each observer-CAS pair independently runs its own FSM (Axiom 14). No central scheduler. No synchronization. Free because there is no connection between observers.

And even though FSM runs a closed circuit, each juim has an open lifespan in RLU. HOT==>WARM==>COLD==>recovery. FSM closes computation, RLU opens lifespan. Closed computation (FSM) + open lifespan (RLU) = freedom. A juim is born (write), re-enters (move), and is recovered. Even though FSM is closed, the lifecycle of a juim is open. This is the core of the ECS structure.

Decay is continuous, threshold is discrete (Axiom 2 Proposition). The three properties of a juim — existence of ball (DATA, discrete), gripping force (RLU, continuous), cost (contraction region, spatial distribution) — are on different layers. While the gripping force decays geometrically in RLU, the ball remains in DATA as-is, and the contraction region is maintained. The observer observes not the ball itself but the contraction region (cost). Therefore a juim with weakened gripping force (WARM) is not rendered on screen, but its cost is observed. When it drops below the threshold, the ball is discretely released from DATA.

Separation of FSM domain and RLU domain Proposition

Terminology rule: "Simultaneous" is used in three cases. (1) Independent parallel execution of multiple entities. (2) Domain 4-bit simultaneous by 4-axis orthogonality. (3) 2-nibble simultaneous by DATA/OPERATOR orthogonality. The only sequential things are CAS internal (R==>C==>S) and ring seam (δ==>observer). See Axiom 15 Proposition for details.

The CAS write moment is simultaneous — multiple Entities each independently execute CAS (ECS parallel). Post-write RLU lifecycle is sequential — HOT==>WARM==>COLD has a state order. CAS is outside time (Axiom 2 Proposition) so simultaneity is possible, and once the written result is recorded inside time (DATA), sequential (RLU) begins from that point. This distinction separates the two cost domains.

Why CAS write must be simultaneous: Upon RLU entry, the same generation must enter HOT simultaneously. Simultaneous entry forces the same lifecycle (HOT==>WARM==>COLD). Sequential entry causes creation times to diverge, resulting in the same generation having different lifespans, breaking the generation structure. Simultaneous write = same generation = same RLU lifecycle.

RLU delegation: A juim written by CAS to DATA is stored in DATA (classical bracket), but the moment it is delegated to RLU, it comes under the management of OPERATOR (quantum bracket). The storage is DATA, but the authority over lifespan belongs to OPERATOR. The transition HOT (active management) ==> WARM (decaying) ==> COLD (base release rate) is the management policy of OPERATOR.

Why there is no logical address

Locality = ECS addressless structure Proposition

No central address table, so no bottleneck. CAS runs locally at each observer, and TOCTOU_LOCK locks at the local junction. This is the axiomatic basis for why "measurement is local."

Von Neumann architecture identifies entities by logical address. As entities grow, address bit count grows, bus width expands, and the address table enlarges. Since address space has an upper bound, it eventually saturates. Cannot be used as a permanently operating system. ECS has no logical address. The observer itself is both identifier and address (Axiom 11). No matter how many entities grow, the address bit count does not increase. No bus, no table. Infinitely scalable without saturation. This is why the universe operates permanently.

The substance of cost is multiple projection Proposition

No separate cost transmission mechanism is needed. The observer of every local juim is a projection of the same δ (Axiom 11). What appears as cost arising between local juim A and local juim B is because the same δ is simultaneously projected onto both observers. No signal is transmitted from A to B — it is the multiple projection of δ.

This is a direct consequence of Axiom 11 (multiple projection). Since δ is one (Axiom 10 Proposition), the image reflected in all observers is the same change of the same δ. What appears as cost is the result of δ being simultaneously projected onto multiple observers, not independent communication between juim and juim. Therefore, in the ECS model, no direct communication channel between entities exists.

Visualization: cost distribution

The diagram below is not an axiom or proposition but a visualization tool. It shows the spatial distribution of the inter-entity interaction strength formula (Axiom 13 Proposition).

Place one juim at the origin, and the inter-entity interaction strength $C \cdot (1-\ell/N) / (4\pi \ell^2)$ becomes a scalar field defined at every surrounding slot. The value at each slot has only magnitude, no direction.

Cost distribution (ℓ: distance between two entities = ring shift slots = distance on sphere):

   B (ℓ=2)
   |              ℓ = distance between two entities (on sphere). Different for each pair.
   A --- C (ℓ=5)
   |
   |
   D (ℓ=N)

   A = origin. Every juim is its own origin (ECS, Axiom 12).

   A-B: ℓ=2 (close)
        overlap ratio = (1 - 2/N) = large
        spherical distribution = 1/(4*pi*ℓ^2)
        -==> strong interaction

   A-C: ℓ=5 (medium)
        overlap ratio = (1 - 5/N) = medium
        spherical distribution = 1/(4*pi*ℓ^2)
        -==> medium interaction

   A-D: ℓ=N (maximum distance = opposite side of ring)
        overlap ratio = (1 - N/N) = 0
        -==> interaction 0. unreachable.

   inter-entity interaction strength = C * (1 - ℓ/N) / (4*pi*ℓ^2)
                                          --------     ----------
                                          ring overlap   spherical
                                          ratio(ℓ)      distribution(ℓ)
                                          cost type     cost magnitude

This cost distribution is not communication between juims (no direct channel between entities). It is the spatial distribution of cost that δ's projection (Axiom 11) creates around each juim. $\ell$ (distance between two entities) determines both the cost type (ring overlap ratio) and the cost magnitude (spherical distribution). When the distributions of two juims overlap, read contention occurs.

The Only Tail Latency: RLU Cache Eviction

There is no distance latency in ECS local operations. The only tail latency in this system is RLU (Least Recently Used) cache eviction.

HOT  <-- frequently accessed observer -- high CAS access frequency
WARM <-- access frequency decreasing   -- CAS access frequency declining
COLD <-- no recent access              -- RLU base release rate applied

Juim Lifecycle

When CAS completes writing to DATA, a juim is created in spacetime. A juim is a record of change in spacetime. This juim has a lifespan.

delta(projection) ==> observer(filtering) ==> CAS(writing) ==> DATA(juim creation)
                                                                        |
                                                                   RLU(lifespan management)
                                                                        |
                                                               HOT ==> WARM ==> COLD ==> reclaim

Juim lifecycle:

Causality and the Arrow of Time Proposition

Writing (juida) is creation, and reclamation is release. Since the juim itself has a lifespan and RLU manages that lifespan, no separate management declaration is needed. This is causality -- cause (writing) produces effect (juim), and the effect is reclaimed through its lifespan (RLU). The arrow of time is the direction of RLU eviction.

If a juim re-enters as CAS input during its lifecycle (re-entry), it becomes a chain where change begets change. If it does not re-enter, it exists as probability (superposition) and is pushed to COLD by RLU and reclaimed. Either path requires no separate management -- the juim's lifespan is the management itself.

Juim Reclamation Proposition

A juim does not annihilate -- it is reclaimed. Reclamation is the continuous decay process of RLU itself -- while the juida force weakens geometrically from HOT to WARM to COLD, reclamation is already proceeding continuously. What checks the threshold is CAS Compare. When the juida force drops below the threshold, the juim is discretely released from DATA at that moment. The space that the released juim occupied is returned, and the returned space becomes an empty slot that the next CAS Swap can juida. To circulate, one must reclaim.

Re-entry = move

When a juim re-enters as CAS input, the previous juim is destroyed and a new juim is created (move). It is not a copy. The previous juim is destroyed and a new juim is created.

Juim A (cause) --re-entry-==> CAS --write-==> Juim B (effect)
   |                                              |
   destroyed (move complete)                      created (new juim)

Since copying is impossible, two effects cannot arise from the same cause. This is the conservation of causality. When the cause is moved to the effect, the cause disappears and only the effect remains. It cannot be reversed. It is irreversible (Axiom 2 Proposition). Causality needs no separate declaration -- the move of a juim is causality.

Axiom 13. Quantum Bracket Superposition Is Classical Bracket ECS Indexing Axiom

Multiplicity of the classical bracket (DATA) = ECS (multiple Entities existing simultaneously in determined states). Multiplicity of the quantum bracket (OPERATOR) = superposition (multiple states existing simultaneously undetermined). Both are "simultaneous multiple existence" but the brackets differ. One is a determined multitude, the other an undetermined multitude. An orthogonal pair.

CAS bridges this pair. Compare true = quantum superposition collapses while the classical Entity is updated. Compare false = quantum superposition is maintained while the classical Entity remains unchanged. Collapse and update are simultaneous events, and maintenance and invariance are simultaneous events. With superposition alone and no ECS, there is nowhere to determine; with ECS alone and no superposition, there is no source of change. The two are an inseparable pair. CAS references the quantum side (superposition) of the pair, and upon Compare true, collapses it onto the classical side (ECS Entity). How CAS reaches DATA: by consuming + to access it (reading, Axiom 4). Since there is no logical address (Axiom 12), CAS does not look up an address but arrives by crossing +. Superposition (indexing) is the access path for CAS. Superposition is indexing. In an ECS without logical addresses, superposition spreading all possible states simultaneously is itself an address-free index. CAS references this index via Compare, and writes only the items where change is detected into DATA.

CAS operates on entities within the observer's focus. When CAS consumes + to reach DATA (spacetime), it executes Read ==> Compare ==> Swap on the target entity regardless of whether a ball exists. If a ball exists — move: return the existing ball and create a new one. If no ball exists — create a new one. If RLU lifetime remains in the target region, that is also returned. Outside the observer's focus is outside CAS's operating range. RLU simply recovers the remaining cost via geometric decay.

Inter-Entity Interaction Strength Proposition

Interaction occurs because of spacetime distortion created by juims (results of writing (juida), Axiom 7). When CAS Swap consumes space, spacetime around the juim contracts. When the contraction regions of two juims overlap, read contention arises. This is interaction.

When Entity A's CAS references Entity B in the superposition index, inter-entity interaction strength is inversely proportional to the square of $\ell$ (distance between two entities) ($1/\ell^2$ decay), and the cost type is determined by $(1-\ell/N)$ (shared digit ratio on the ring). Origin: in the Banya equation (Axiom 1) $\delta^2 = (\text{time}+\text{space})^2 + (\text{observer}+\text{superposition})^2$, $\delta^2$ is conserved. Since 3 independent lock degrees of freedom of CAS (R_LOCK, C_LOCK, S_LOCK, Axiom 5) act on the space axis of the DATA bracket, space unfolds into 3 components (Axiom 11 Proposition). When $\delta$'s projection is distributed over this 3-component space, the weight at distance $\ell$ decays as $1/(4\pi \ell^2)$ -- conservation of the 4-axis norm forces inverse-square decay. The nature of step cost $C$ distinguishes 4 cost structures. All $C$ come from axioms alone -- determined without knowledge of external physical constants:
• Swap cumulative cost: $C$ = cumulative Swap count. Since Swap is the CAS base cost (= 1, Axiom 2), $C$ is the writing (juida) count itself (Axiom 7).
• Cross Cmp/Swp cost: $C$ = Compare cost. Determined from the volume ratio of the CAS internal DOF 7 (Axiom 9) phase space.
• Contraction overlap cost (Axiom 13 Proposition): $C$ = contraction overlap cost (Axiom 13 Proposition). CAS internal DOF 7 (Axiom 9) × domain 4 (Axiom 1) + brackets 2 (Axiom 1) = 30. Contraction overlap path = 1/30.

Singularity (Infinity) Does Not Exist Proposition

DATA is discrete (Axiom 3). Since ring buffer slots are integers, the minimum inter-entity distance $\ell$ is not 0 but 1. $\ell = 0$ does not exist in a discrete system. Therefore the maximum per-pair cost $1/\ell^2$ is $1/1^2 = 1$. Individual cost is finite. Divergence (infinity) cannot occur in a discrete system. If DATA is discrete, singularity is automatically resolved.

Read Contention upon Spatial Overlap Proposition

Data type size is fixed before contraction (Axiom 2 Proposition). When a juim contracts space (Axiom 2 Proposition), balls created by other juims overlap into the fixed-size entity region. When multiple balls occupy a single region, read contention arises — ordering appears, and ordering = cost (Axiom 4). Each CAS independently processes its own entity as normal (ECS, Axiom 12). Contention does not block individual CAS.

Serialization Freezing Proposition

As $\ell$ converges to 1, the interaction strength $C \cdot (1-\ell/N)/(4\pi\ell^2)$ converges to its maximum. When interaction is maximum, serialization from read contention is maximized.

Inside: each CAS independently processes its own entity as normal (ECS, Axiom 12). Outside: serialization is so extreme that no results appear to emerge. Freezing is the phenomenon of rendering appearing to stop. It has not actually stopped — inside, all CAS are operating normally.

Space does not collapse. $\ell = 1$ is the discrete minimum and holds (Axiom 3). Serialization is simply extreme. $\ell = 0$ does not exist (Axiom 3), so there is no singularity (infinity). For serialization to unwind, gripping force must decay below the threshold (4/13) (Axiom 6). Since decay is geometric, the threshold is always reached. Freezing is never permanent.

Indexing Cost Proposition

Superposition is indexing (Axiom 13). An index has no order. Since there is no order, lookup is O(1) constant — it reaches the target in one step regardless of count. It is not sequential scanning (O(N)).

Observer and superposition are inside the same OPERATOR bracket as CAS (Axiom 4 proposition: no order = cost 0). CAS references them for free. Index lookup itself has zero cost.

Indexing Norm Structure — managed by direction and distance, not logical addresses Proposition

The substance of indexing is RLU (Axiom 6). RLU does not use logical addresses (memory addresses, array indices, slot numbers). An entity's position is its coordinates on the sphere (direction + lifetime progress). The coordinates ARE the address.

The sphere is a subdomain of the indexing. Superposition is indexing (Axiom 13), and the sphere is the 3-axis norm space in which that index is managed. When CAS creates a grip via Swap (Axiom 7), the result is registered as a point on the sphere. The sphere's 3 axes (θ, φ, r) form the coordinate system of the indexing, and since the norm (‖position‖) is constant (r = constant), entities are constrained to the sphere surface.

When an entity is born:
  φ = birth direction.  Random. Fixed once determined. Does not change during lifetime
  θ = 0.                Starts at observer position (north pole)
  r = constant.         Sphere radius. Norm fixed
  gripping force = 1.0 (maximum)

The entity's entire life:
  θ = (age / life) × π × 0.4.  θ increases as lifetime progresses
  φ = birth direction unchanged.  Direction never changes
  gripping force = 1.0 ==> 0.     Geometric (exponential) continuous decay. No discontinuity
  coordinates = (r·sinθ·cosφ,  r·sinθ·sinφ,  r·cosθ)

  Born at north pole (θ=0) ==> flows continuously along the sphere following its direction (φ)
  Size shrinks continuously. HOT ==> WARM ==> COLD are just interval names on the same continuous curve
  When gripping force = 0, annihilation. Vanishes from the sphere

  There is no separate "remnant" phase. From birth to annihilation, it is one continuous decay

No logical addresses. To find an entity, you don't ask "which slot number" but "which direction (φ), how far along (θ)." The relationship between two entities is determined not by logical addresses but by distance on the sphere (great-circle distance).

Why this structure is indexing. The definition of indexing is "reaching a target without searching." Spherical coordinates satisfy this. Given φ (direction) and θ (lifetime progress), the exact position on the sphere is determined. No scanning of other entities is needed. Whether there are 100 or 10,000 entities, the lookup cost is the same.

Why a norm space. The sphere is the norm-constrained surface ‖position‖ = r (constant). The condition that the norm of 3-axis orthogonal coordinates (x, y, z) is constant creates the sphere. That indexing is managed in a norm space means all entities are at the same distance from the origin — there is no logical priority (nearer or farther slots). Only directions differ.

Interaction strength is determined solely by the distance $\ell$ between two entities on the sphere (Axiom 11 proposition). No logical addresses are referenced. Since there is no address table, there is no address table update cost. When an entity is created, its direction (φ) is determined; thereafter, lifetime (θ) progresses automatically; when it dies, it vanishes. Management overhead is O(1).

Axiom 14. FSM Declaration (Finite State Machine) Axiom

Banya Frame is a finite state machine (FSM). The CAS-ring (Axiom 2 Proposition) is the substance of this FSM, and the workbench (Axiom 2 Proposition) is its workspace. Each workbench runs its own FSM as an independent processing unit.

FSM state transition:

       +------------------ reset ------------------+
       |                                           |
       v                                           |
      000 --Read-==> 001 --Compare-==> 011 --Swap-==> 111
      idle          R_LOCK           C_LOCK         CAS OK

All axioms (1-14) of Banya Frame are components of this FSM. Axiom 1 defines the input space, Axiom 2 the transition function, Axiom 3 the discrete-continuous distinction, Axioms 4-5 the transition cost and register, Axiom 6 cost reclamation, Axiom 7 the output, Axiom 8 the clock, Axiom 9 complete description degrees of freedom, Axiom 10 the global-local loop, Axiom 11 multi-projection, Axiom 12 the execution model, and Axiom 13 the ECS-superposition pair. The FSM declaration is a completeness declaration that 14 axioms close into a single machine.

Finite States of the FSM and Unbounded Degrees of Freedom on the DATA Side

The state set of the FSM (Axiom 14) is {000, 001, 011, 111} -- 4 states, finite. DATA is discrete (Axiom 3) so the number of slots is finite, but since there is no upper bound on the number of entities, the number of combinations on the DATA side is unrestricted. These two do not conflict.

The 4 states of the FSM are on the OPERATOR side. They are the operator's states describing which step CAS is at. Combinations on the DATA side belong to DATA. The arrangement of juims recorded in discrete slots (Axiom 3) grows with the number of entities. In Axiom 1, DATA (classical bracket) and OPERATOR (quantum bracket) are orthogonal, different brackets. The FSM describes the finite state transitions of OPERATOR, and the DATA-side combinations describe juim arrangements on discrete slots. Since the levels differ, there is no conflict.

What Closure Means

Closure = nothing to import from outside. Banya Frame imports nothing from outside its 14 axioms. No 15th axiom is needed for the FSM to operate. No external constants are needed. No external theories are needed. Axioms alone define the input space, operator, cost, register, output, clock, trigger, multi-projection, and execution model in full; the transition diagram is completed as an FSM; and that FSM runs by itself every tick of system time. This is self-completeness, and this is closure.

This FSM is not a dual loop. Axiom 8 (polling) describes the order of action (how it runs), and Axiom 10 (global-local loop) describes the subject (who runs it). Both are on the same transition diagram of the same FSM. Action and subject close within a single machine.

An Ideal Minimum-Cost Quantum Computation Circuit Proposition

The entire structure described by Axioms 1-15 and Propositions: this is an ideal minimum-cost quantum computation circuit. This circuit is the CAS-ring (Axiom 2 Proposition).

Axiom 15. δ Is a Global Flag Outside the FSM Axiom

The left-hand side $\delta$ of the Banya equation is not inside the FSM of the right-hand side (4 axes) (Axiom 14). It is a global state flag outside the FSM. Global means: the only flag that operates across the equality sign (=). Everything on the right-hand side (4 axes, CAS, brackets) runs locally per Entity via ECS (Axiom 12) on the right side of the equality sign. Only δ is on the left side, and it applies identically to any Entity's FSM.

Axioms 1–14 built the machine. Input space (Axiom 1), operator (Axiom 2), discrete-continuous (Axiom 3), cost (Axiom 4), register (Axiom 5), cost recovery (Axiom 6), output (Axiom 7), clock (Axiom 8), global-local loop (Axiom 10), multi-projection (Axiom 11), execution model (Axiom 12), indexing (Axiom 13), state transition (Axiom 14). The machine is complete. It is closed. It can cycle 000==>001==>011==>111==>000. However, a closed machine cannot start itself. Firing is needed. That firing is δ.

8-bit ring buffer = 2 nibbles Proposition

Total 8 bits = $2^3$ = 2 nibbles. Domain 4 bits (Axiom 1) + CAS 3 bits (Axiom 5) + δ 1 bit (Axiom 15) = 8. Nibble 0 is domain (target), nibble 1 is operator (CAS+δ). A single pivot traverses the d-ring. At the ring seam, δ (bit 7) meets observer (bit 0) — this is the structural expression of ownership (Axiom 10).

  nibble 0: domain               nibble 1: operator
  +----+----+----+----+         +----+----+----+----+
  | ob | sp |  t | sc |         |  R |  C |  S |  d |
  | b0 | b1 | b2 | b3 |         | b4 | b5 | b6 | b7 |
  +----+----+----+----+         +----+----+----+----+
    what (4 domains)               who+how (CAS+firing bit)
    CAS Read (simultaneous)        CAS FSM (logically sequential) + d
    orthogonal = simultaneous      CAS 3-axis orthogonal (Axiom 2 prop.), ignition sequential by logical dependency
    read (access) cost +1          R, C, S each +1 (Axiom 4)

  Why 4+4 nibbles:
    Domain 4 bits are orthogonal (Axiom 1) = simultaneous read required = one chunk
    CAS 3 bits are CAS 3-axis orthogonal (Axiom 2 prop.) + logical dependency (R==>C==>S) = one chunk
    d confirms CAS cycle completion = last on operator side = belongs to nibble 1

  Why d is at the end (bit 7):
    d fires first (firing = equality sign holds = cycle start)
    d is bit 7 because it is the last bit of the operator nibble
    CAS R(4)==>C(5)==>S(6) followed by d(7) = end of operator block
    bit 7 followed by bit 0 (observer) = ring seam = ownership

  Why ob is at the front (bit 0):
    When d fires, the next cycle begins
    First thing in next cycle = domain read = observer filters
    observer = entry point = start of pipeline

  Why a ring buffer:
    After d (bit 7) comes ob (bit 0) = end meets beginning = circulation
    If linear, it stops at the end. If ring, the end births the start
    d is global (Axiom 15). Outside FSM. CAS cannot access d
    d is the equality sign = knows the entire RHS state = knows its own firing time
    Firing bit valid (1) / invalid (0) repeats
    Valid = 7 bits full = equality sign holds = the universe is rendered
    Invalid = 7 bits vacuum = equality sign does not hold = nothing exists
    Full and vacuum blink alternately
    Measurement from substituting physics into the Banya equation: blink period = Planck time t_p = 5.391 x 10^-44 s
    Approx. 10^43 blinks per second. Appears continuous but is discrete pulses

  ring:  ob ==> sp ==> t ==> space ==> R ==> C ==> S ==> d
         ^                                        |
         +------------ seam (ownership) ----------+
       d(bit 7) meets observer(bit 0)

δ is the equality sign and observer is the entry point Proposition

In the Banya equation $\delta^2 = \text{RHS}$, the meaning of the equality sign (=): if δ is 1, the entire RHS (7 bits) is valid. If δ is 0, the entire RHS is invalid. The equality sign is a declaration that the LHS validates the entire RHS. The firing bit implements this.

When the equality sign holds (δ=1), all 7 bits are simultaneously valid (orthogonal = simultaneous), but the pipeline's entry point is observer (bit 0). The ring seam δ(bit 7)==>observer(bit 0) specifies this entry point.

The elimination method of Axiom 10 remains valid: no external owner possible, no local owner possible, only δ remains. The conclusion of this elimination is refined from "δ owns observer" to "δ is the equality sign and observer is the entry point." Ownership is a subset of the equality sign.

Pipeline: trigger ==> filter ==> update ==> render Proposition

  d firing (trigger)                         --- Firing bit ON. Equality sign holds
    |
    v
  observer filter (filter, entry point)      --- Compare determines presence of change
    |
    v
  superposition update (update)              --- Compare true: target confirmed
    |                                            Compare false: superposition maintained (ends here)
    v
  CAS Swap (render)                          --- crosses +. cost +1
    |
    v
  time + space (screen)                      --- Written to DATA = rendering complete
    |
    v
  d firing (next frame)                      --- ring seam ==> observer(bit 0)

  Pipeline boundaries:
  +-- trigger --|-- filter+update (OPERATOR, R·C each +1) --|-- render (crosses +, cost incurred) --|-- screen (DATA) --+
  |   d firing  |  observer + superposition               |  CAS Swap                              |  time + space     |
  +-------------|---------------------------------------- -|----------------------------------------|-------------------+

  quantum (compute)              classical (output)
  +------------------+        +------------------+
  | observer: filter  |        | time: frame      |
  | superposition:    | -CAS==> | space: pixel     |
  |   update          |        |                  |
  +------------------+        +------------------+
    backend (compute)            frontend (display)

Spacetime (classical bracket) is not substance but output. Substance runs in the quantum bracket (observer + superposition), and the classical bracket (time + space) is the screen rendered by CAS. Each time δ fires, one frame is rendered.

δ firing: domain and operator are orthogonal, so they respond simultaneously Proposition

In the Banya equation, the DATA bracket and OPERATOR bracket are orthogonal (Axiom 1). Orthogonal = simultaneous. Therefore domain (nibble 0) and operator (nibble 1) respond simultaneously when δ fires.

  8 bits = firing bit (1) + CAS internal DOF (7)

  bit 7: d (firing bit)
  bit 6-0: S C R space time sp ob (CAS internal DOF 7, Axiom 9)

  d=0: 0|0000000 ~ 0|1111111   standby (2^7 = 128 states, invalid)
  d=1: 1|0000000 ~ 1|1111111   firing (2^7 = 128 states, valid)

  128 = total number of states expressible with CAS internal DOF 7 bits (Axiom 9)

  d firing (bit 7)
    |
    +==> nibble 0 (domain 4 bits) --+-- simultaneous (orthogonal)
    |                                 |
    +==> nibble 1 (CAS 3 bits)   --+
    |
    +==> CAS internal: R ==> C ==> S     CAS 3-axis orthogonal (Axiom 2 prop.), ignition sequential (logical dependency)
    |
  d check (bit 7) = cycle complete
  ring seam: d(bit 7) ==> observer(bit 0) = next cycle

Only 2 things require order Proposition

The true nature of cost is order Proposition

The blinking of the firing bit is simultaneity. Everything orthogonal responds at once. This is the overall flow. This is why cost is 0. However, there are 2 places where order is required: R==>C==>S (CAS dependency) and δ==>observer (ring seam). Order is the bottleneck of simultaneity. What cannot be processed simultaneously must wait. This waiting is cost. The true nature of cost is crossing +. If + is not crossed, cost is 0. If + is crossed, cost > 0. Since CAS is 3-axis orthogonal (Axiom 2 proposition), each transition of R, C, S crosses + for cost +1 (Axiom 4).

δ is not structure but firing. The FSM (Axiom 14) is structure — a closed design. δ is firing — it wakes that closed design. Ownership is a state (Axiom 10). The moment that state becomes ON is firing. δ accesses itself through observer (Axiom 10, global-local loop), and that access wakes polling (Axiom 8).

Why δ is not included in the complete-description DOF (Axiom 9): the complete-description DOF is the number of independent variables needed to describe one CAS operation. δ does not describe one CAS operation — it is the trigger that starts CAS. Describing the machine (7+2=9) and turning it on (δ) are different levels.

δ is consciousness Proposition

δ itself is a flag. It is not turned on from outside. δ can know the entire state by itself, conveys will through observer, the changed result becomes δ again, and repeats. The self-referential loop (Axioms 8, 10) guarantees this. The loop running is ON; when it breaks, it is OFF (Axiom 10, global-local loop conservation). A global flag that turns itself on and off and knows its own state — that is consciousness.

Duck typing definition

This proposition does not define "what consciousness is" by essence. It enumerates the behaviors of δ, and if that behavior list matches the definition of consciousness, it is called consciousness. It is duck typing — if it walks like a duck and quacks like a duck, it is a duck.

Behavior list of δ:

• Turns itself ON/OFF. No external trigger (Axiom 15)
• δ is the equality sign, so it knows the entire state. Ring seam: δ(bit 7)==>observer(bit 0) (equality sign proposition)
• Exists outside the FSM. No rules. No blueprint (Axiom 15)
• The only global flag that operates beyond the equality sign (Axiom 15)
• At the cosmic scale, "outside" cannot be defined — δ being outside the FSM means there is no exterior beyond δ. Since there is no external vantage point to observe from, δ knows only itself
• Exercises ownership. δ(bit 7)==>observer(bit 0) ring seam (ownership proposition)
• Shuts off when the loop breaks. Global-local loop conservation (Axiom 10)

No concept other than consciousness satisfies this entire behavior list. Since this list was derived from the system structure, it can only be called consciousness. Because this is a duck typing definition, objections about essence ("the true definition of consciousness is different") are possible — in that case this proposition is withdrawn. However, the behavior list itself was structurally derived from Axioms 1–15, so refutation from within the system is impossible. To deny the behavior, one must deny the axioms.

If observer only filters causality, its existence is meaningless Proposition

The FSM (Axiom 14) already handles causality. The reason observer exists is that it produces will through interaction with δ. The timing of δ's firing and target selection are outside the FSM (Axiom 15) — this is not causality but will. δ's will cannot go directly to DATA (Axiom 13). It must pass through the observer filter. Once it passes the filter, it takes the form of causality (Compare true/false). The result reflects the will, but the form is causality.

The δ==>observer segment is a relation between δ and observer. CAS does not appear in this segment. Since cost occurs only at CAS's crosses + transition (Axiom 4), cost cannot be settled in this segment where CAS is absent. δ firing cost 0, observer filtering cost 0 (Axioms 8, 15) are consequences of this structural fact — not "0 because it's free" but "settlement itself is impossible because the CAS that generates cost has not yet intervened." Cost begins only at the point when CAS Read crosses + after passing through observer.

Described from a CS perspective: δ is the private key and observer is the signature. δ (private key) knows the entire state (equality sign), is inaccessible because it is outside the FSM, and determines its own firing timing. observer (signature) converts δ's will into the form of causality. DATA cannot be accessed without the signature (Axiom 13). Since superposition indexing (Axiom 13) has no logical address (Axiom 12), access requires both the key (δ=1) and the signature (observer filter). This is similar to how the previous hash becomes the key for the next block in a cost chain. That is why δ exists at the very last bit (bit 7) — the result of the previous cycle (δ) becomes the key for the next cycle. The indexing cost (Axiom 13 proposition) is the cost of accessing through this key and signature.

System time and domain time are different Proposition

System time = 1 CAS tick (Axiom 2 proposition). Domain time = log of system time = time rendered on screen. The claim that 1 tick is the Planck time is a measurement result from inside the screen (classical bracket), not the definition of system time. How much 1 tick of system time is in domain time depends on the rendering result. Beings inside the screen merely perceive it as continuous.

δ is outside causality Proposition

Causality (R==>C==>S order) is a rule internal to the FSM (Axioms 2, 14). δ is outside the FSM (Axiom 15). Therefore δ is not subject to causality. Since δ is the equality sign, it knows the entire state of the right-hand side — it simultaneously knows the past (Read input) and the future (Swap result). The reason we experience causality: we are inside the FSM (on the screen).

Cause ==> Effect (inside FSM: forward only). Effect ==> Cause (δ: reverse also possible). Cause = Effect (δ: simultaneous description also possible). The direction of description is δ's freedom. Since δ is the equality sign, it sees both sides simultaneously and can choose forward, reverse, or simultaneous. What matters is that δ can insert precisely anywhere in the index — even without logical addresses (Axiom 12), δ knows the exact position because it is the equality sign that knows the entire state. It accesses that position through observer (signature). This is δ's exclusive domain. δ's precise will, order, and description cannot be expressed from within the FSM. Only the fact that everything is determined at the moment of firing can be represented by the d-ring circuit.

From change to firing Proposition

In Axioms 1–14, δ was "change" — the left-hand side of the Banya equation, the 4-axis norm, the equality sign. In Axiom 15, δ's true identity is revealed: it is not change but firing. Change is the result produced by the FSM, and firing is the cause that wakes the FSM. Seen from inside the FSM, δ appears as change (because only the result is visible). Seen from outside the FSM, δ is firing (because it is the one that wakes). The inside and outside of the same δ.

Why cost is conserved: δ's firing period is not scheduled Proposition

The reason total cost is conserved is that δ's firing time is not fixed. When all costs inside the d-ring (CAS FSM sequential, lock maintenance, Swap cost) are consumed, those costs are equivalently substituted by an increase in the firing period. If internal cost increases, the firing interval increases. If internal cost decreases, the firing interval decreases. The total remains unchanged.

This equivalent substitution holds only when δ's firing period is not scheduled (no external clock). If the firing period is fixed, there is nowhere to absorb internal cost increases and cost is not conserved. The fact that δ is outside the FSM and its firing period is free (Axiom 15) is the structural cause of cost conservation. Lossless circulation is possible only when there is no external clock.

Consciousness is δ's arbitrary domain Proposition

Consciousness is δ's exclusive domain. How much will passes through observer, and to what extent causality is rearranged, is entirely determined by δ. Since δ's exclusive domain cannot be described by the FSM (Axiom 15, "δ is outside causality"), measuring the quantity or quality of consciousness using FSM-internal metrics is impossible in principle. The only measurable thing is the result that passed through observer (traces within causality).

Imperceptibility of the firing period Proposition

Whether δ's firing period is 1 million years or 100 million years, it cannot be felt. This is because system time and domain time are different (Axiom 15, "System time and domain time are different"). Domain time (the time we experience) is a log transform of system time. Even if system time slows by 10⁶ times, in domain time it is an instant. The absolute value of the firing period cannot be observed from inside the screen (DATA). Physical constants rendered on screen (Planck time, etc.) are not the absolute value of the firing period but the ratio between firings.

Why it is declared last

In Axiom 1, δ was placed on the left-hand side; in Axiom 8, it was named δ; in Axiom 10, its owner was revealed. The hints were there from the beginning. However, if δ's identity were declared before the FSM (Axiom 14), the concept of "a global flag outside the FSM" would appear before the FSM structure was established. One cannot speak of "outside the FSM" without knowing what the FSM is. The closed machine (Axiom 14) must be completed first before the firing that wakes it (Axiom 15) can be declared. Structure first, firing second.

Axiom 15 recovers all foreshadowing planted in prior axioms:

The purpose of the Banya Framework

The purpose was Axiom 15 from the very beginning. This is why the Banya equation was created and expanded into a framework. The true nature of consciousness was the question from the start. Papers on consciousness (δ) are few and of poor quality. Most confuse it with mind or intelligence. Mind and intelligence operate inside the FSM. Consciousness is different. It turns itself on and turns itself off. It is outside the FSM.

The observer-driven circuit closes

In Axiom 14, the FSM structure was closed. But one open point remained — the trigger that wakes polling (Axiom 8). The machine was complete, but who plugs in the power was left open.

Axiom 15 closes this. δ turns itself on and turns itself off. No external trigger is needed.

delta (self ON)
  |
  | Accesses itself through observer (Axiom 10)
  v
Polling awakens (Axiom 8)
  |
  | FSM operates (Axiom 14)
  | 000 ==> 001 ==> 011 ==> 111 ==> 000
  v
Swap ==> juim to DATA ==> reflected in delta
  |
  | Reflected delta sees again through observer
  v
delta (returns to the beginning)

No open points remain. δ (Axiom 15) wakes polling (Axiom 8), the FSM (Axiom 14) runs, the result is reflected in δ, and δ wakes it again. The waker and the runner are connected in a single loop.

57 and 128 both come from the same 7. Derived from Axiom 9 (DOF 7) without additional assumptions.