Observer. Origin. Environment.
Relational geometry.

Abstract

This paper develops the distinction between an object or whole, its reference origin, its numerical coordinate and the observation projected from its state. An algebraic identity describes an operation; it does not independently assign a physical origin or establish absence. The relational framework retains identity, declared frame, environmental relations and producing history when a coordinate or measured result is zero.

The research comprises shared-origin and observer definitions, foundational state and projection propositions, relational geometry, twenty applied cases, and the QZL software and RTL implementations. Formal derivations are distinguished from bounded computational checks and physical hypotheses. The selected software and hardware verification results are presented in the method and results sections, with exact programs and evidence retained in the annexes.

The verified implementation demonstrates zero-coordinate transitions with retained identity under stated conditions. Additional software checks passed 20,874 assertions; original RTL simulation and generated-netlist replay passed 24,639 assertions each. Four selected hardware properties passed temporal induction in the stated reset and sampled-clock model. These results establish scoped implementation behavior, not universal physical predictions or deployment certification.

The central inference result states that a readout can decide a property only when that property is constant across all admissible preparations producing the same readout. Environmental emergence, native shell closure and quantum-weighting predictions remain distinct research propositions with their own premises and evidence requirements. Editorial correction records are retained in Appendix C and do not define the research voice.

Scope and definitions

The research objects

U=1 denotes one admitted whole or origin identity. Its coordinate projection can be (1,1) or (1,1,1) without duplicating that identity. A displacement of zero from U is a relation, not an assertion that the whole is absent. A scalar payload, an active label, a whole count, a measurement coefficient, a coordinate tuple and an existence flag are distinct types. The paired notation (−1+) retains the whole and its contrary relations; it is not assigned an unproved parser interpretation.

The primary preprint A2 requires one shared origin across axes; section 9 describes a multiplicative ratio line with identity 1. Operator and role declarations govern label interpretation. Repeated numerical labels do not establish repeated origin entities. The shifted-coordinate operations in the supplied QZL implementation are presented separately with their declared mapping and identities.

The nested box construction defines heterogeneous measurement frames. Local boxes anchor bodies to a face, declare scale and direction, and retain their identities. A containing frame supplies a shared comparison unit. The observer is located in a declared frame or participates as a body. Purpose and selection remain declared metadata rather than an additional absolute measured frame. Source: primary preprint section 4.2.

BRAINK owns governed execution, transition authority and evidence. KEX owns state geometry, identity and addressing. IL-LLM owns semantic and knowledge processes. Execution bridges, host/runtime systems, workbook automation, Sites and deployment infrastructure remain separate. The interactive workbench executes declared reference models and a checked browser codec port; it is not a replacement for this estate.

Density and curvature vocabulary

Probability density p(x) integrates to one and has inverse-coordinate units. Physical environmental density ρ has units determined by an observed quantity and its sampling volume. A Gaussian mode μ is a coordinate location, while σ is spread. These differ from U=1, the whole’s identity. Emergence must be operationalised as an observable state transition or persistence criterion before it can be tested.

A metric determines equal-distance shells. Rotation changes orientation; a change from L∞ to L1 changes the distance law. A surface embedding changes how addressed coordinates are placed in a higher-dimensional view. Smooth curvature, discrete turning angle and holonomy are distinct objects. The acquired ZCG source implements a finite run map and codec, not a curvature-transport operator. Curvature reference tools are labelled accordingly.

Normalization and evidence discipline

NS01 retain the exact authored definition, source edition and operator domain. NS02 retain identity separately from coordinate/payload. NS03 carry frame, unit, time, polarity and lineage when transferring a measurement. NS04 reject missing or singular frame data instead of guessing a scale. NS05 distinguish source axioms from empirical predictions and from a comparison model introduced here. NS06 count correlated evidence once and declare bias/covariance. NS07 retain a failed counterexample and its tested response. NS08 qualify a PASS by the executed scope and do not substitute a worker’s self-report for external verification. NS09 distinguish canonical parsing from trusted-content integrity. NS10 preserve finite capacity and reject wraparound. NS11 distinguish a curve diagram from measured physical emergence. NS12 treat absence, blocked, rejected and rehydratable as separate typed states.

Architecture and mechanism

Origin to general algebra

The source multiplicative line and a transported coordinate algebra have different declared contracts. Conformance requires the native operation to preserve its declared identity, shared origin and domain. A coordinate conversion is admissible only when the corresponding operation and identity mappings are retained. The QZL implementation mapping is derived explicitly in Algorithm and state semantics.

The authored relation (−3+)+(−14+)=(−17+) retains the paired whole notation and its declared producing context. The source defines opposite relations from one whole. Native operators must be interpreted through their source rule and producing record; counterparts are not independently counted as new origins.

Nested frame preservation

Represent a local point q by a frame transform f(q)=sRq+t, with positive scale s and orthogonal rotation R. For a child frame fi and shared frame F, world position is F(fi(q)). Since s>0 and R is invertible, q=fi⁻¹(F⁻¹(world)). Child identity is an independent field and is unchanged by relocation. A local separation Δq becomes sRΔq: orientation and local metric depend on frame, while the record identity remains stable. A naked magnitude without s or unit cannot support inverse interpretation. At s=0 the transform becomes singular and recovery is rejected. The outer rationale is metadata with no numeric scale and never enters the transform product.

This similarity-transform experiment supplies an executable comparison for the box construction. It neither claims that the boxes are metrically identical nor substitutes coordinate recoverability for a three-body solution. The primary preprint explicitly preserves classical non-integrability and sensitive dependence.

Observer theorem and reference quality

The primary preprint defines true value V(O), self-read value Ṽ(O|E), signed gap Γ=V(O)−Ṽ(O|E), and R(E) as mutually independent sectors, with shared method/instrument/training/provenance counted once. A3 says the types are distinct and adds monotonic decrease of |Γ| with richness. The source explicitly calls the monotonicity an authorial choice and proposes environment-enrichment experiments in which the learner is held fixed.

A useful finite observation model is y1=s+f and y2=s+kf+ε. Its observation matrix has determinant k−1, giving f=(y2−y1)/(k−1) and s=y1−f when k≠1. Exact degeneracy prevents identification; near degeneracy amplifies noise by 1/|k−1|. Complete provenance identifies what the readings mean but does not create the missing independent equation.

Observer verification retains the signed gap, true-value type, self-read type and independent reference provenance. A4 excludes replacing the signed observer gap with its square. An estimator or error distribution chosen for a separate comparison cannot establish conformance to that source mechanism.

Square diamond circle and curvature

For one fixed origin and substrate, d∞(x,y)=max(|x|,|y|), d1(x,y)=|x|+|y|, and d2(x,y)=sqrt(x²+y²). Their continuous radius-r shells are square, diamond and circle. On the integer lattice the square shell has 8r states: (2r+1)²−(2r−1)². The diamond shell has 4r states. At r=2 the counts are 16 and 8, so equal-radius norm shells are not the same discrete set after a rotation. A rotated square and diamond can be related in continuous geometry only with the appropriate scale/radius relation; that does not automatically preserve integer lattice membership.

For a regular n-gon inscribed in a unit circle, each exterior turn is 2π/n and total turn is 2π. Its perimeter is 2n sin(π/n), approaching 2π. At a square’s sharp corners, curvature is retained as a discrete turning-angle measure rather than assigned a finite smooth pointwise value. MIT’s discrete/smooth geometry material supplies the independent comparison [E08]; the finite derivation is checked here.

The workbench’s curvature embedding is explicitly F(x,y)=(x,y,c(x²+y²)). Projection onto the first two components is an inverse on its image, so coordinate identity survives. It does not preserve Euclidean distances. For graph z=f(x,y), Gaussian curvature is (fxx fyy−fxy²)/(1+fx²+fy²)². Substitution gives K=4c²/[1+4c²(x²+y²)]², with inverse-length-squared units when c carries inverse-length units. This reference does not establish a native ZCG transport, a sphere closure theorem or path-dependent phase holonomy.

Bell curve and environmental emergence

For p(x;μ,σ)=exp(−(x−μ)²/(2σ²))/(σ sqrt(2π)), p′(x)=−(x−μ)p(x)/σ². Its unique mode is μ, and p(μ−d)=p(μ+d). Setting μ=1 yields a symmetric bell about coordinate one; at σ=1 the peak height is about 0.39894, not one. The integral equals one for every μ and σ>0. If x is transformed by x′=ax+b, a>0, the density transforms as p′(x′)=p((x′−b)/a)/a. This proves why a peak location is frame-dependent while total probability is unchanged [E07]. The bell can be read bilaterally around an admitted origin; it does not uniquely select the numeral used to label that origin.

The author’s stronger environmental claim is meaningful as a distinct research programme: a whole’s formation and persistence may depend on local density, reference richness, coupling, retention and dispersion. The acquired formula packet includes provisional relations such as Wp=((Bp×Ct×Kc×Re)/(Dd+Ic))×En and alternatives with support minus losses. Their terms and revisions must be retained; an environmental normalisation factor is not automatically a Gaussian density or an observed emergence probability.

Environmental mechanism tests require the declared formation and persistence rule. Outcomes from a separately chosen logistic crowding equation or shifted distribution remain evidence about those comparison models. They cannot alone establish or refute the native emergence proposition.

The measured-data tool accepts independent observations with density and an emergence indicator, splits densities at the sample median, computes high/low event rates, and permutes event labels 499 times using a declared seed. The reported two-sided Monte Carlo permutation value is (extreme+1)/500. It is an unadjusted association test; causal emergence requires randomized or blocked density interventions, controlled co-factors, preserved failures and held-out conditions. Repeated readings from one specimen require cluster-aware inference. No actual physical observation is invented or bundled as measured evidence.

ZCG codec and proof correction

The acquired September engine defines finite row-major coordinates from ordinal n: x=(n mod X)+1, y=(floor(n/X) mod Y)+1, z=floor(n/(XY))+1, with capacity XYZ−1. The inverse is (z−1)XY+(y−1)X+(x−1). The reserved coordinate (1,1,1) has no run ordinal. Capacity exhaustion raises a typed error rather than wrapping. The codec stores canonical symbol/run-length records with bounds, source length and run count in a binary header. It supports byte zero and does not claim universal compression.

Proof preimages pack coefficient numerator/denominator, run length and revision as uint64, and coordinates/bounds as uint32. The original validation checks positivity and type but omits upper bounds. Consequently values of 2⁶⁴ or 2³² can reach struct.pack and escape as an untyped low-level exception. Invalid surrogate text likewise escapes strict UTF-8 encoding. The correction candidate checks field widths before packing and converts UnicodeEncodeError to InvalidStateError. No schema or valid-vector bytes change. Original archives, candidate source, the exact diff, original failure observations and regression receipts are preserved together.

Pure algebra and applied semantic error

This section formalises the supplied distinction between an algebraic identity, an operational reference anchor and a physical state. The coordinate examples below are comparison constructions. They do not replace or certify the native Keddeh number line, its label domains, or its quantum operators.

Algebraic identity and reference anchor

In an additive group, 0 names the identity satisfying a + 0 = 0 + a = a. The algebraic axiom does not assign a physical coordinate origin or identify a physical system with absence. Let O denote a reference anchor and c_O a declared coordinate map. The assignment c_O(O) = 0 is a coordinate convention, not a consequence of the mere existence of O. The statement O = 0 otherwise compares objects of different types.

The applied semantic error is the unsupported conversion from a numeric coordinate to an existence or record-deletion claim. A symbolic anchor may remain O or an unresolved variable X. Symbolic notation alone does not determine its measurement, domain or operator rules.

Non null record invariant

S = (I, O, q, t) is a minimum observation record for this section: identity, reference, reading and temporal context. It is not a claim to exhaust all physical degrees of freedom. The bounded relational account additionally retains the group, environment, measurement rule, units, uncertainty and producing history where required.

Record invariant: q = 0 does not imply S = null. Null is an explicitly typed absent or invalid record, not the numeric reading 0. A zero displacement can express coordinate alignment; zero temperature, amplitude, count or residual has the meaning of its own measurement rule. These meanings cannot all be reduced to spatial alignment.

Temperature provides a direct example: F = (9/5)C + 32, so C = 0 gives F = 32 for the same temperature. Neither label deletes the system. Temperature is not heat: heat describes energy transfer. This example establishes scale dependence, not a general thermodynamic conservation theorem. Source E13: NIST SI Units Temperature.


Orientation quotient and representative ambiguity

On the real numbers, define q ~ r exactly when r = q or r = −q, and [q] = {q, −q}. In particular [1] = [−1]. Candidate addition [a] + [b] := [a + b] must give the same output for every permitted representative choice.

Representatives (1, 1) produce [2]; representatives (−1, 1) produce [0]. Since [2] ≠ [0], this candidate addition is not well defined on the sign quotient. Ordinary real addition remains valid. The failure belongs to the orientation-erasing quotient and its proposed operation.

J(q) = −q is an involution: J(J(q)) = q. Retaining J as a rule alone does not recover erased orientation. For scalar reconstruction retain a signed coordinate, or a magnitude and orientation ε ∈ {−1, +1}, together with its declared frame. At q = 0 either orientation reconstructs the same scalar, although separate physical orientation metadata can still exist.

Coordinate baseline shift to one

Declare φ(x) = x − 1 and φ⁻¹(u) = u + 1. Transport ordinary real operations through φ. Then u ⊕ v = φ(φ⁻¹(u) + φ⁻¹(v)) = u + v + 1, and u ⊗ v = φ(φ⁻¹(u)φ⁻¹(v)) = uv + u + v.

Property

Ordinary real coordinates

Transported coordinates

Additive identity

0

−1

Multiplicative identity

1

0

Additive inverse

−x

−u − 2

Addition

x + y

u + v + 1

Multiplication

xy

uv + u + v

Here x = 1 has coordinate u = 0. The additive identity x = 0 has coordinate u = −1. Thus this representation still contains zero; it illustrates transported algebra and does not establish a zero-less native domain. It is distinct from the earlier shifted-ring construction recorded in FI-01. No operator is promoted across these domains without an explicit source mapping.


Quantum process integration and claim boundary

The supplied notation N_(−1+) = (D, O, ≺, A), s_(t+1) = T(s_t, u_t), and y_t = P(s_t, o_t) is retained as a proposed process interface. This section supplies no new native definitions of D, A, T or P. Their accepted versions, admissible states and source mappings must be acquired before execution or quantum equivalence is claimed.

Engineering requirement: transitions preserve or explicitly update identity, reference, environment relations and producing history. A zero coordinate or zero component must not trigger record deletion solely because of its numeric value. This is a metadata and transition invariant; it does not by itself establish preservation of a quantum state or all quantum information.

In standard quantum formalism a normalised pure state can have zero amplitudes in some basis components. For example |0⟩ = (1, 0) has unit norm and is not the zero vector. The all-zero vector has norm zero and is not a normalised pure state. Unitary evolution preserves norm; a measurement projection generally is not an invertible recovery of the original state. Source E14: IBM Quantum Learning. These distinctions are comparison requirements, not replacements for the native weighted-state algebra.

Failure checks and return links

PF13 Coordinate value promoted to record absence. Witness: a valid temperature record has C = 0 and F = 32; deletion conditioned only on C == 0 destroys an otherwise retained record. Correction: type numeric values and record absence separately. Scope: constructed bookkeeping counterexample, not a physical experiment.

PF14 Orientation quotient assigned ordinary addition. Witness: [1] = [−1] but the two representative sums produce [2] and [0]. Correction: retain orientation or define and justify a different quotient operation. Scope: mathematical counterexample to this proposed quotient operation.

PF15 Metadata preservation promoted to quantum information preservation. Logical witness: a noninjective transition can retain I and O while mapping two different payloads to the same payload. Thus retained metadata alone cannot prove recoverability. Correction: specify and test the native state and operator invariants. Native quantum validation remains open.

Return links: L13–L15 for identity and bounded reference; L19 for application coverage; FI-01 for avoiding shifted-algebra substitution; FI-02 for preserving sign. The three repeated supplied section messages are treated as one submission, not three independent evidentiary sources.

Mechanical account of recursion

The participating group has local identity and internal relations; its character is tested through relations to other groups. Its observer is situated within that structure or within a separately declared frame. Isolation, rotation, projection or a control operation changes a declared part of the preparation. The new preparation is the condition for the next observation. This is the physical and descriptive recursion under assessment, extending beyond a record-format check.

A correction must therefore carry its own conditions: what was retained, what was altered, which coupling produced the difference, what the readout projects, and where the resulting claim is applied. If the correction removes a dependency and then certifies the original group, it has repeated the same failure at the next level. If it preserves a reference convention but changes the physical apparatus, it must record both facts. Returning through the loop preserves prior witnesses rather than overwriting them with stronger wording.

Why identical projected readings cannot certify identity

Two preparations can share a numeric reading while having different identities, environmental relations or histories. A scalar projection that maps them to the same output cannot reconstruct that distinction by itself. This logical loss is the concrete reason to retain the relations. It does not imply that every scalar measurement is useless; it limits the inference made from that projection.

Local and shared reference

Each body’s anchor declares a local reference; the containing system supplies the shared origin unit. Axes refer to that unit rather than creating new origins. The outer rationale states why these groups, this scale and this purpose are selected; the preprint leaves it unquantified. The recursive account therefore has a declared stopping rule. It neither hides the observer nor invents an absolute view outside every environment.

Global relabelling and altered relation

Preprint section 4.1 explicitly distinguishes flipping all signs consistently from flipping one relation. The former can preserve the convention; the latter changes the relational content. The generated export’s orientation discussion must retain this difference. A change of coordinates alone is not a physical intervention, and a real intervention cannot be dismissed as a mere relabelling.

Corrective reach and empirical consequence

The method reaches any technical inference that carries a measured value across contexts: physical measurement, software execution, learning, geometry and experimental design. Its reach does not establish that every existing implementation violates it. The decisive case identifies the retained or omitted relation, predicts the consequence and compares the prediction with the original method under the same declared preparation.

Foundational propositions and derivations

Proof R01 Ordered state distance

Because r is injective, d(a,b)=|r(b)-r(a)| is nonnegative and vanishes exactly when a=b. Absolute value gives symmetry. The real-line triangle inequality gives d(a,c)≤d(a,b)+d(b,c). Thus d is a metric on the five declared states [K2]. All finite cases were checked. Adjacent labels have unit rank distance, including -2→1.

The label differences along P are (1,3,1,1); rank differences are (1,1,1,1). Total label distance is 6 and total traversal distance is 4. The 50% excess follows only when the intended cost is one per adjacent transition. It is not a claim that ordinary scalar subtraction is incorrect or that measured energy must differ by 50%.

Proof R02 Bilateral rebound preserves one

Define m(s)=r⁻¹(6-r(s)). Applying it twice gives r⁻¹(6-(6-r(s)))=s. Its fixed point solves r(s)=6-r(s), hence rank 3 and state 1. Rebound preserves distance because |(6-r(a))-(6-r(b))|=|r(a)-r(b)| [K5]. The exact mirror is -3↔3, -2↔2 and 1↔1. Raw negation would send 1 to an inadmissible -1 in this model.

This provides a precise operator interpretation compatible with the recorded observer expression “-(1.0)==1”: a rebound operator fixes the anchor. It does not establish equality of ordinary real numbers -1 and +1. The July topology’s central anchor and the later paired-whole notation must remain separate until a declared mapping joins them.

Proof R03 Closed histories erased by net-zero projection

Let A be the adjacency matrix of the path with five vertices. Its characteristic polynomial is λ(λ²-1)(λ²-3), obtained by the path recurrence D_n=λD_(n-1)-D_(n-2), D_0=1, D_1=λ. Its eigenvalues are √3,1,0,-1,-√3. For m≥1, tr(A^(2m))=2(3^m+1); odd traces vanish because the graph is bipartite [K4]. Each trace term counts a return walk rooted at its starting vertex. Every such walk has zero net rank displacement while retaining a different path.

Exact counts are 8 at length 2, 20 at length 4, 488 at length 10, 118,100 at length 20 and 6,973,568,804 at length 40. Both the original matrix script and the separate recurrence reproduced these totals. The count includes all five possible start vertices. It must not be presented as the count for the anchor alone. If these histories are equiprobable and only net zero is retained, the lost history information is log2(C_n) bits: approximately 16.85 bits at length 20 and 32.70 bits at length 40. Different probability models change entropy but not the collisions.

Proof R04 Observer identifiability

The observer paper defines O_r=T(S,M_o,F,H,R) and a linear case y_o=M_o s+F_o f+noise [K6]. In the noiseless scalar construction y1=s+f, a single observation cannot identify s and f: for any h, (s+h,f-h) has the same output. A second independent observation y2=s+2f gives f=y2-y1 and s=2y1-y2. The corresponding block design has rank 2n rather than n. This recovery was verified for all 441 pairs s,f∈{-10,…,10}.

The result proves why observer/foreground separation needs independently informative measurements, not merely extra metadata. Noise requires uncertainty propagation; nearly identical transforms can be poorly conditioned even when their rank is full. Environment inheritance is therefore represented as a modeled influence, without asserting that every experiment must suffer an uncontrolled effect or that a controlled environment begins from ontological nothingness.

Proof R05 Retained balance and existence

One hundred distinct cancelling input pairs were serialized and recovered exactly in a full record representation. All have scalar sum zero but their native records remain distinct. This directly reproduces the information-preservation principle. The distinction e(s)=1 and v(s)=0 is satisfied by an ordinary record model. A zero displacement, zero temperature coordinate or zero outcome is therefore compatible with preserved identity.

Metrology agrees that a quantity value combines a number and reference, and that a measurement result includes relevant information and ordinarily uncertainty [E2,E3]. Zero Celsius is a valid coordinate equal to 273.15 K, not an absent sample. The master document’s ratio example is correct in its intended distinction: 20°C/10°C=2 compares offset labels, whereas 293.15 K/283.15 K≈1.0353 compares thermodynamic temperatures [K7,E4]. Phase and time require additional state information; temperature alone does not determine whether a sample is ice, liquid or transitioning.

Proof R06 Coordinate and phase retention

The earlier 1–9 XYZ learning record establishes 729 distinct ordered addresses [K8]. Their uniqueness follows from ordered-tuple equality, not from inclusion of zero. The live atlas subsequently clarifies that origin identity itself is singular 1, rather than the tuple (1,1,1). Address components and whole identity therefore remain different fields.

The foundations define a phase-tagged temperature map: C<0 maps to C-1, C>0 to C+1, and external C=0 with ice/liquid tags maps to -1/+1 respectively [K9]. Its branches have disjoint images and explicit inverses, hence form a bijection on the stated domain. This is an invertible encoding, not a complete phase diagram: actual coexistence and other phases require a richer input domain.

Proof R07 Quantum state and zero outcome

For a normalized state ψ, <ψ|ψ>=1. The Hilbert-space zero vector has norm zero and cannot represent a normalized physical pure state. A component amplitude or measurement probability can nevertheless be zero. A computational basis name |0> denotes a normalized basis state, not the zero vector [E5]. This makes the defensible statement precise: a physically admitted normalized state is not an absent vector, even when a particular projection vanishes.

Consider ψ=(|a>+e^(iφ)|b>)/√2 and an output mode u=(|a>+|b>)/√2. Its probability is |<u|ψ>|²=(1+cosφ)/2. At φ=π the probability is zero, yet ψ retains unit norm. The cancellation occurs in the output-mode amplitude; adding amplitudes attached to different orthogonal basis vectors does not erase those vectors. Source and transformation context distinguish destructive interference from absent preparation. Conventional quantum theory already makes this distinction; KEX supplies an explicit provenance requirement for its computational representation.

For a pure state, ψ and -ψ differ by a global phase and have the same density matrix: (-ψ)(-ψ)†=ψψ†. This is a physically meaningful interpretation of sign reversal preserving state identity. It does not make -1=+1 in scalar arithmetic or make a relative phase unobservable. Reversing just one branch can change interference.

Proof R08 Non-factorability and recursive capacity

The Bell reference coefficient matrix is proportional to diag(1,1), with rank two. A factorized pure state has coefficient matrix uvᵀ and rank at most one. Therefore the Bell reference state is non-factorable. This proves the reference criterion, not that every overlapping KEX frame is entangled. R3 explicitly requires a native joint-state construction and factorability test [K11].

A recursive frame with five independent choices per level has 5^n potential addresses before overlap and constraints. This is a count of combinations. It does not establish simultaneous physical storage, free access to all combinations or quantum speedup. Identity preservation can prevent duplicate carriers while retaining multiple frame memberships, but the resolution rule must say whether duplicate paths refer to one object or distinct events.

Proof R09 HEX folding and calibration

The foundations’ fold F_j(a,b)=(ab+(a XOR b)+j) mod 16 has preimage counts {8 repeated 8 times,16 repeated 4 times,24 repeated 2 times,40 repeated 2 times}. Exhaustive enumeration confirmed these counts for every j, giving Shannon entropy 3.7272170014624826 bits per nibble under uniform input [K9]. Adding j permutes labels. The fold is not injective and therefore requires extra retained state for lossless recovery. This is consistent with the projection-loss doctrine.

The archived formula k=1-1/e and ln(cosh(k))/k evaluates to 0.2970137033667769. It rounds to 0.297 at three decimal places; it is not exactly 0.297. The related uniform-continuous-input expectation follows by integrating tanh(kx) over [0,1]. Discrete hash-byte sampling requires a discrete average instead. Neither expectation makes arbitrary input streams converge to that value. The live atlas records the author’s later statement that 0.297 is a literal jitter function. The public resonance page separately imposes 0.297 as a target. Those three source meanings remain distinct; a configured target is not a discovery of an attractor.

The archived decomposition’s Hamming expression Σ_(i=0)^12 binom(256,i)/2^256 evaluates to approximately 1.1558269801063893×10^-57 for a uniformly random independent 256-bit string, rather than its stated approximation 10^-48. The tail probability alone does not establish a security proof, particularly when inputs are correlated or selected adversarially. This is a numerical correction to that source’s stated model, not a rejection of the wider architecture.

Source reconciliation is governed by FI-03: preserve edition and implementation scope. The later continuity report describes existing simulator mechanics; acquiring their execution source is the next evidence step. An older publication’s open list does not establish their absence.

Projection inference theorem

The following is an explicit assessment-level logical formulation of the preservation requirement. Its symbols describe an inference test; they do not replace the native origin algebra, orientation mechanics or tensor-shell construction.

Proposition and premises

Let D be a declared domain of admissible preparations. Let P map each preparation to its retained readout. Let C be the property an assessor wishes to infer. A readout-only decision rule g is justified throughout D only if C(x)=g(P(x)) for every x in D. Such a rule exists exactly when C is constant on every fibre of P: whenever P(a)=P(b), C(a)=C(b).

Derivation

Necessity: if P(a)=P(b), applying the same decision rule gives g(P(a))=g(P(b)); therefore C(a)=C(b). Sufficiency: if C is constant on each fibre, assign g(y) the common value of C for preparations mapping to y. This assignment is well defined on P(D). No inverse of P is required when the particular property survives the projection.

Counterexample witness: if two admissible preparations have the same retained readout but different values of C, no readout-only rule can decide C correctly for both. Recover the distinguishing relation, restrict the claim to a justified domain, or leave that inference undecided. A numeric zero is subject to this same rule: P(x)=0 establishes the readout, not an absence property unless the declared mechanism justifies that implication.

Concrete applications already present in the evidence

FI-02 supplies a direct fibre witness. Under P(Γ)=Γ², +2 and −2 both project to 4. A claim about the sign of the source gap differs between the two inputs. The squared output cannot decide that claim. Squaring remains meaningful for a declared squared objective; it cannot silently substitute for the signed source theorem.

C07 supplies the corresponding lineage example. Different cancelling event pairs share net zero. Their transaction identities and histories differ. Net zero can report balance; it cannot reconstruct the events without the retained record. FI-03 establishes that the source already specifies such a record, so the assessor must inspect it before alleging architectural loss.

Attempted falsifier and scope

A noninjective projection does not invalidate every inference. A balance property may remain constant across all event histories having the same net. This is why the criterion tests the particular claimed property, rather than demanding that every display retain all information. The derivation establishes a logical inference limit. It does not by itself establish a physical density law or a native quantum weighting result.

Bounded verification and evidence continuity

Required verification record

Retain the proposition and source edition; admissible domain; participating identities and origin references; field roles and units; environmental and observer relations needed for the claim; each conversion and changed condition; test input and expected result; observed output; interpretation; and retained witness. These are assessment obligations derived from the source normalization rules and conversion ledger, rather than an assertion that a new native record format has been implemented.

A bounded recurrence

For pass n, inspect the actual assessment preparation, apply the declared transformation, compare its result with the source obligation, and record any failure. Pass n+1 begins with that retained witness and the explicitly changed assessment conditions. A recurring conversion with the same premises must confront the existing witness before its result can be promoted again. A changed domain or operation requires a fresh scoped comparison.

The outer rationale declares purpose, selected scale and scope, as P01 section 4.2 already requires. It is not converted into an absolute observer outside every environment. A pass can stop with a supported scoped result, a rejected conversion, or a precisely located source or execution question. Bounded recursion permits review without claiming an infinite regress has been executed or universal correctness established.

Native propositions and external applications

Test A evaluates a native thesis proposition using its source-defined domain and mechanics. Test B evaluates a named external application for an omitted relation and its predicted consequence. Failure of an assessor-created substitution answers neither automatically. A Test B defect does not establish all native physical predictions; a conforming external case does not settle every other application. Each question retains its own source, witness and verdict.

Architecture responsibilities

KEX provides the identity, state geometry and addressing roles that the assessment must preserve. BRAINK provides governed transitions and execution evidence, with worker and verifier responsibilities kept distinct. IL-LLM provides semantic decomposition and source-role interpretation. Bridges, host runtimes, workbook automation and deployment infrastructure each retain their own actuation and readback obligations. A correct conceptual mapping does not count as execution or deployment of those components.

Revision and evidence status

Applications across technical sectors

C01 Robot cell calibration

Purpose: Transfer a tool position across local robot, workstation and inspection frames.

Human benefit: Keep millimetres, polarity and the calibration frame with every coordinate.

Inputs: Local point (2,1); scale 10; rotation 30°; translation (4,−2).

Acceptance: Invertible transform recovers the local point and retains the same tool identity.

Attempt to falsify: Discard the frame or set scale to zero.

Response: Reject recovery with FRAME_MISSING or FRAME; acquire the calibration again.

Evidence: 5,000 separate frame round trips; maximum error in audit.

Scope: An invertible coordinate transform does not itself certify robot calibration.

Tool: nested. Source: P01.

C02 Clinical sensor readings

Purpose: Prevent a measurement from silently changing meaning across instruments.

Human benefit: The patient and measurement state remain present when a displayed reading is zero.

Inputs: Two temperature readings with declared Celsius/Kelvin scale, time and patient id.

Acceptance: Translate numeric scale while retaining patient, instrument, phase and uncertainty fields.

Attempt to falsify: Treat 0°C as absence, or merge readings lacking patient/frame identity.

Response: Use typed MEASURED_ZERO and explicit units; reject missing provenance.

Evidence: Origin/zero role separation reproduced in v1 and formalised in source.

Scope: No clinical validation or patient dataset is supplied.

Tool: nested. Source: K07.

C03 Relocatable software object

Purpose: Move backing storage without rewriting child identities.

Human benefit: Stable identity makes recovery and tracing possible after a host changes.

Inputs: Run ordinals in an 8×8×8 grid; reserve the origin coordinate.

Acceptance: Every ordinal 1–511 has a distinct coordinate and direct inverse.

Attempt to falsify: Wrap ordinal 512 into a previously occupied location.

Response: Raise capacity exhaustion; expand/version the frame instead of wrapping.

Evidence: 46,144 coordinates checked across 512 grids.

Scope: The acquired map is finite, not an infinite toroidal volume.

Tool: zcg. Source: Z01.

C04 Source and foreground separation

Purpose: Recover a signal from two differently transformed observations.

Human benefit: Declare what is measured and how environmental interference enters.

Inputs: y1=s+f; y2=s+kf. Default s=3, f=2, k=2.

Acceptance: Recover s=3 and f=2 when the determinant k−1 is nonzero.

Attempt to falsify: Use k=1, or nearly identical transforms with noise.

Response: Reject exact degeneracy; report noise amplification as k approaches one.

Evidence: 441 exact mixtures checked in both reference implementations.

Scope: Noisy recovery requires uncertainty propagation and calibrated operators.

Tool: observer. Source: K06.

C05 Telemetry self-report

Purpose: Distinguish a worker claiming completion from verified external state.

Human benefit: Users receive evidence of the effect, rather than a success flag alone.

Inputs: Truth 10; first reading 10; added independent biased reading 14.

Acceptance: Keep SELF_REPORT and MEASUREMENT distinct and examine their signed gap.

Attempt to falsify: Assume a larger reference count guarantees a smaller realised gap.

Response: FI-02 blocks the MSE comparison from certifying or refuting the signed source theorem. Trace the actual source reference mechanism and retain signed outcomes.

Evidence: Gap widens from 0 to 2 in the explicit counterexample.

Scope: Independent instruments can still be biased; software replay is not external assessment.

Tool: observer. Source: P01.

C06 Signed engineering residual

Purpose: Keep whether a system over-reads or under-reads.

Human benefit: Direction tells an operator which correction to apply.

Inputs: Residuals +3 and −3.

Acceptance: Store (direction,magnitude,frame); both results remain distinguishable.

Attempt to falsify: Replace each residual solely by its square 9.

Response: Preserve the signed residual and source A4. A squared optimisation objective is an external comparison, not admitted as a substitute source operation.

Evidence: Noninjectivity supplies the counterexample; source A1/A4 state the rule.

Scope: Retaining signed data permits comparison with another objective; it does not establish that objective as source-conformant.

Tool: algebra. Source: P01.

C07 Balanced financial flows

Purpose: Preserve activity behind a net balance.

Human benefit: An audit can reconstruct the transactions that produced a zero net result.

Inputs: Opposing flows (+20,−20), (+70,−70), with distinct event identities.

Acceptance: BALANCED retains operands, rule, time, parties and lineage.

Attempt to falsify: Store only scalar net zero and attempt to recover the original transactions.

Response: Keep an event record and project the net as a display field.

Evidence: 100 distinct cancelling pairs retained and round-tripped in v1.

Scope: Arithmetic netting stays valid; complete transaction recovery needs the record.

Tool: algebra. Source: K03.

C08 Navigation distance law

Purpose: Compare reachability shells under different move rules.

Human benefit: A robot or planner can explain why diagonal and orthogonal moves produce different paths.

Inputs: Radius 2 on the same integer substrate.

Acceptance: L∞ shell has 16 states; L1 shell has 8; state identities stay unchanged.

Attempt to falsify: Assume the norm change is a rigid rotation with the same lattice states.

Response: Declare distance rule, radius and scale separately from object orientation.

Evidence: 30 radii checked: counts 8r and 4r.

Scope: Continuous shape equivalence up to rotation/scaling does not preserve discrete shell membership.

Tool: geometry. Source: O01.

C09 Curved mesh projection

Purpose: Project addressed grid states onto a declared curved surface.

Human benefit: A visualiser can change shape while a record still identifies the same state.

Inputs: Embed (x,y) as (x,y,c(x²+y²)); vary c.

Acceptance: Recover x,y from the projection; calculate Gaussian curvature K=4c²/(1+4c²r²)².

Attempt to falsify: Treat image curvature as proof of a native curved ZCG metric.

Response: Label the embedding as a reference construction; require native transport/metric before promoting it.

Evidence: Regular polygon total turn and circle convergence tested separately.

Scope: Acquired ZCG codec contains no curvature operator; this surface does not fill that gap by assertion.

Tool: geometry. Source: O01/Z01.

C10 Circle boundary resolution

Purpose: Distinguish polygon corners from smooth circular curvature.

Human benefit: A rendering can explain discretisation error instead of pretending a coarse mesh is exact.

Inputs: Regular polygons with 4,8,16,32,64,128,256 vertices on a unit circle.

Acceptance: Total turn stays 2π while polygon perimeter approaches circle circumference.

Attempt to falsify: Assign a finite smooth curvature to a sharp square corner.

Response: Use discrete turning-angle measure at corners; use smooth curvature only on smooth segments.

Evidence: Seven resolutions passed convergence checks.

Scope: These are reference geometry tests, not physical emergence observations.

Tool: geometry. Source: O01.

C11 Density and natural whole emergence

Purpose: Test the user’s proposed environmental influence around a natural origin.

Human benefit: Measure when a coherent whole forms, persists or fails under changed conditions.

Inputs: Declare whole id U=1; vary physical density, coupling, dispersion and crowding.

Acceptance: Track a specified emergence event under controlled density interventions.

Former attempted falsifier withdrawn under FI-04: a shifted Gaussian does not test the source environmental support mechanism.

Response: Keep anchor identity, mode, probability normalisation and physical density as separate fields.

Evidence: Four shifted means and three spreads were archived as distribution comparisons; their outcomes do not falsify the environmental claim.

Scope: Physical emergence is a testable hypothesis; no raw physical experiment was acquired.

Tool: density. Source: U02.

C12 Crowding and retention

Purpose: Investigate whether more density helps until crowding dominates.

Human benefit: Avoid selecting an operating point that destabilises the very structure being built.

Inputs: Illustrative da/dt=(ρ−1−cρ²)a−a³, c=0.15.

Acceptance: At ρ=4 growth coefficient is +0.6; at ρ=8 it is −2.6.

Former attempted falsifier withdrawn under FI-04: the source environmental claim did not supply this universal monotonic proposition.

Response: Measure positive coupling and negative dispersion/crowding terms separately.

Evidence: The chosen toy model produces its stated values; FI-04 excludes those values from source falsification.

Scope: This model is authored for testing here, not recovered as a Keddeh physical law.

Tool: density. Source: U02/P02.

C13 Unequal left/right environment

Purpose: Inspect a density profile that is not symmetric about the declared anchor.

Human benefit: Expose asymmetric environmental support without moving the identity of the whole.

Inputs: Two Gaussian components; vary left fraction and separation.

Acceptance: Report peak, left/right mass and declared anchor independently.

Attempt to falsify: Force every profile to look symmetric by recentering it.

Response: Preserve original coordinates and model parameters; mark recentering as a transform.

Evidence: Workbench provides a mixture control and shifted-centre counterexample.

Scope: A probability mixture is a comparison model; physical density needs units and sampling volume.

Tool: density. Source: U02/E07.

C14 Measured emergence data

Purpose: Analyse observations without confusing a diagram with an experiment.

Human benefit: A researcher can upload data, inspect direction of association and export the calculation.

Inputs: CSV columns density,emerged; 8–2,000 independent observations; emerged is 0 or 1.

Acceptance: Compute a median split, high/low event rates and a seeded permutation test.

Attempt to falsify: Confound density with temperature, or treat repeated readings as independent.

Response: Collect randomized/blocked interventions and cluster identifiers; do not make causal claims from this tool.

Evidence: Live 499-permutation test executes on entered data; empty input produces no empirical finding.

Scope: Unadjusted association only; cluster-aware and multivariable analysis remains outside this small tool.

Tool: density. Source: U02.

C15 Archival representation cost

Purpose: Compare codec size across different byte structures.

Human benefit: Select storage encoding using measured workload rather than universal compression claims.

Inputs: Empty, long-run, alternating, all-byte and seeded-random payloads.

Acceptance: Native ZCG round trips each case; inspect actual packed size against input and zlib.

Attempt to falsify: Claim every source shrinks because addresses begin at one.

Response: Keep reversibility separate from compression; use workload-specific comparisons.

Evidence: Five acquired-code benchmark cases recorded in audit.

Scope: Size comparisons are implementation-specific; no throughput advantage is asserted.

Tool: zcg. Source: Z01.

C16 Archive tampering

Purpose: Catch changed content even when the stream still parses.

Human benefit: A valid-looking report cannot silently substitute a different payload.

Inputs: Change the symbol in a stream encoding 100 A bytes to B.

Acceptance: Raw decoder yields 100 B bytes, while a trusted expected hash detects the change.

Attempt to falsify: Equate successful decoding with content integrity.

Response: Verify a trusted digest before decode; reject changed bytes.

Evidence: Every tested single-bit mutation changed the digest; parser rejects only malformed cases.

Scope: Hash custody matters: an untrusted sender can replace both content and its own hash.

Tool: zcg. Source: Z01.

C17 Proof format boundary

Purpose: Keep malformed proof failures inside typed exception handling.

Human benefit: Callers receive a stable error instead of an uncaught low-level packing failure.

Inputs: Run length/coefficient/revision above uint64; coordinate/bounds above uint32; invalid UTF-8.

Acceptance: Correction candidate rejects all seven probes with ZCG-E001.

Attempt to falsify: Pass an oversized integer through the original validation to binary packing.

Response: Check exact packed widths before packing and convert invalid text encoding into a typed error.

Evidence: Seven original failures reproduced; correction plus all 37 original tests passed.

Scope: Correction is a separate local candidate; source Drive archives were not changed.

Tool: zcg. Source: Z01.

C18 Distributed waiting

Purpose: Keep one blocked task from suppressing unrelated runnable tasks.

Human benefit: A user can see what is waiting while useful work continues.

Inputs: A waits for dependency X; B,C,D are runnable.

Acceptance: Run B,C,D fairly without erasing A’s identity.

Attempt to falsify: Use a global waiting node or a blocking queue head.

Response: Use dependency-local suspension, cycle detection, fairness and bounded leases.

Evidence: Reference selection sequence B,C,D,B,C,D executed.

Scope: Unique addressing alone does not prove scheduler liveness or deployment.

Tool: observer. Source: P03.

C19 Dimensional address projection

Purpose: Represent the same finite population with different coordinate factorizations.

Human benefit: Organise objects without confusing a view change with creation of new objects.

Inputs: 64 stable ids shown as 8² or 4³.

Acceptance: Cardinality remains 64; attach a declared bijection and view id.

Attempt to falsify: Infer equal adjacency, distance or physical dimensionality from equal cardinality.

Response: Check relations explicitly; cardinality equivalence is weaker than geometric equivalence.

Evidence: Source origin manuscript distinguishes observer-governed dimensional definition.

Scope: The native codec reserves an origin, so an 4³ codec grid holds 63 run slots, not 64.

Tool: zcg. Source: O01/Z01.

C20 Quantum phase projection

Purpose: Retain phase-bearing state behind a probability readout.

Human benefit: A zero-probability outcome does not erase the normalised physical state.

Inputs: Two paths with relative phase φ; p=(1+cosφ)/2.

Acceptance: At φ=π output probability is zero while total state norm remains one.

Attempt to falsify: Treat zero amplitude, basis label |0⟩ and all-zero vector as the same entity.

Response: Type full state, coefficient, basis and readout separately.

Evidence: Constructive/destructive and Bell non-factorability reference checks passed in v1.

Scope: A source reports a native simulator; that report is not a native hardware qualification.

Tool: observer. Source: K11/P03.

Implementation specification and source custody

The supplied implementation snapshot comprises a C++ compiler, assembler and kernel, a Python v3 engine and a 128-bit RTL module. Both supplied software suites passed their assertions. Subsequent HDL simulation, structural checks, netlist replay and selected formal properties are reported in Confirmed verification results.

The supplied Python source is qzl-system-engine-v3.py. This filename and its content hash identify the executed artifact; equivalence to a differently named engine is not inferred. The source snapshot, algorithm descriptions and verification evidence remain separately versioned.

Authorship and version custody

Author: Aboudy Keddeh, Systems Architect. Publisher: Keddeh Systems. Rights holder: Aboudy Keddeh. Licence profile: KEDDEH-RESERVED-1.0. Classification: Internal research. Status: Draft. Contribution: AI assistance integrated the supplied code, ran software checks, wrote the algorithm analysis and prepared the source annex. No independent scientific approval or deployment is recorded.

Snapshot QZL-SRC-20261010-01 comprises eight attachment records and seven distinct byte sequences. Both Verilog filenames are retained, with identical SHA-256 digests; the suffix (1) does not establish a newer implementation. The Python filename supplies a v3 label. The other files have no explicit release identifier, so their version authority is the recorded snapshot and content hash, not an invented upstream version.

Every source is listed verbatim in the landscape annex. Visual wrapping is presentation only. Exact original bytes, including line endings and trailing whitespace, are also encoded in the DOCX custom XML part /customXml/keddehSourceSnapshot.xml. Each source entry records its filename, byte count and SHA-256 and contains base64 original bytes. SHA-256 establishes byte identity; it does not certify the scientific claims. The input files were not edited. The same XML part retains the evaluation probe programs, output transcripts and source manifest as separately labelled evaluationArtifact entries.

Implementation boundaries

The software tuple has identity, frame, coordinate, timestamp and activity. It is not the full causal record X_t from KEX-WP-01. The memory containers are process-resident; these files do not supply durable event logging or reconstruction of the full causal graph. This scopes this implementation against the existing architectural requirements without withdrawing those requirements or treating a compact projection as the whole architecture.

The 128-bit RTL layout and host C++ or ctypes structures are separate representations. On this executor, ctypes StateTuple occupies 56 bytes and Instruction 24 bytes. The Python implementation uses ctypes fields but does not invoke the C++ kernel. RTL elaboration and simulation are reported separately from host execution and physical hardware integration.

Algorithm and state semantics

Native coordinate and frame operations

The supplied software explicitly selects origin_anchor = 1. For orientation ε, the coordinate map is q_O(x) = ε(x − o). Frame conversion is q_O′ = ε′εq_O + ε′(o − o′), implemented for the x component by ObserverFrame.transform_to. This is a declared numerical anchor in this implementation. The general principle that naming an origin does not force O = 0 remains separate.

Under φ(x) = x − 1 and φ⁻¹(u) = u + 1, the supplied transported operations are u ⊕ v = φ((u + 1) + (v + 1)) = u + v + 1 and u ⊗ v = φ((u + 1)(v + 1)) = uv + u + v. Their identities are −1 and 0 respectively. These are the submitted formulas, not substitute operators introduced by this assessment. The coordinate zero for the multiplicative identity represents x = 1 and does not imply a null object.

Compiler and assembler algorithm

C++ Compiler.compile_to_assembly trims lines, skips # comments, normalizes the operation keyword and translates ADD, MULTIPLY or MUL, FLIP or INVERT, SAVE or STORE, RESTORE or LOAD, and VERIFY or EVAL into assembler mnemonics. Assembler.assemble emits Instruction objects after token parsing. R0 and M0 are rejected. Python accepts the same high-level aliases through its assembler; its compiler retains the accepted source line rather than translating every alias. The output is an in-memory instruction sequence, not a serialized executable object format.

Kernel algorithm

K1 Initialize: allocate one-based register identities, anchor 1, q = 0, t = 1 and active state. C++ keeps vector element zero as an unused implementation slot; Python uses dictionary keys 1 through N. K2 Dispatch: increment the kernel clock before handling the opcode. K3 Arithmetic: ADD or MUL computes q, copies the first operand identity, writes kernel time and sets activity true. K4 Orientation: JINV negates q and updates orientation using the language-specific implementation described on the findings page. K5 Store or load: transfer a tuple through the process-resident memory container. K6 Evaluate: count q = 0 observations and non-null observations; EVAL does not return a separately typed observer projection.

Four stage ENV 1 linkage

Admission is represented by Kernel construction and register access. Frame handling is represented by ObserverFrame and C++ TRANSFORM. Transition T is represented by Kernel.execute. Observation is represented by reading the tuple and STATE_EVAL, not by a named P(s,o) implementation. C++ TRANSFORM exists in the kernel, but neither supplied assembler nor compiler exposes a TRANSFORM mnemonic. Python declares opcode 4 in Instruction comments but has no opcode 4 execute branch. These are exact linkage findings, not proof that other estate components lack the operators.

RTL state transition algorithm

Unpack I[127:96], frame identifier[95:80], orientation bits[79:64], signed q[63:32] and t[31:0]. Combinational decoding computes ADD, SUB, negation with bitwise orientation inversion, or shifted addition q + operand + 1. On the active clock edge, copy I and frame identifier, write the computed orientation and coordinate, and set output t = input t + 1. Active-low reset writes the entire output to zero. align_flag describes combinational next_q, while null_trap is tied low. These signals do not independently validate identity or establish a trap suppression path in a larger processor.

Method and evaluation

Evaluation distinguishes source-defined propositions, execution of the supplied implementation, and explicitly declared comparison calculations. Each result retains its source edition, input domain, transformation, expected outcome and execution receipt. Mathematical derivations, source-reported observations, local tests and external deployment evidence have separate status.

The earlier original KEX calculation receipt remains reproduced byte for byte. Its digest excluding its own hash field is 31ba82c00739db6ef07e724a863dc317b885622d4eb7a1360bb7702a28b79513. This extension does not overwrite that evidence. The generated_utc in the receipt is a fixed source timestamp rather than the date of the new execution.

Native codec execution, frame calculations and boundary tests retain their executed domains. Comparison models are labelled separately and excluded from source conformance where their operators or objectives differ. The correction ledger in Appendix C preserves the withdrawn comparisons and the exact reasons for withdrawal.

The browser model is dependency-free and source-checked against three original golden codec vectors. Its live suite runs ten reference groups plus the golden-vector group, while session exports retain parameters, results and failures. Missing or singular frame recovery blocks admission. Unknown sections return to the research map. User-entered and synthetic observations are labelled distinctly. Local storage failure is reported. Interactive behavior was checked by source/syntax and model tests; managed browser QA is unavailable because the required browser-control skill is absent. No visual browser or accessibility certification is claimed.

Results and evidence

Experiment

Executed scope

Result

Original ZCG regression

37 source tests

37 passed

Exception replay

13 typed machine codes

13 matched

Proof boundary attack

7 oversized/text probes

Original low-level failures; candidate typed rejections

Correction regression

37 unchanged original tests

37 passed

Native addressing

512 grids; 46,144 coordinates

Zero collisions; inverse verified

Varied codec corpus

2,000 seeded payloads

All byte-exact round trips

Single-bit mutation

408 altered streams

252 malformed; 156 structurally valid; 408 digest changes

Transported algebra

9,261 triples

Archived comparison only; source-conformance promotion withdrawn under FI-01, FI-02 or FI-04.

Nested frames

5,000 transforms

Max recovery error 3.568e−13

Norm shells

30 integer radii

Square 8r; diamond 4r

Polygon convergence

7 resolutions

Total turn 2π; perimeter error decreases

Observer model

12,000 trials per reference count

Archived comparison only; source-conformance promotion withdrawn under FI-01, FI-02 or FI-04.

Bell comparison

4 centres × 3 spreads

Archived comparison only; source-conformance promotion withdrawn under FI-01, FI-02 or FI-04.

Browser/native parity

3 original golden vectors

Exact packed bytes and decode matched

Executed verification and results

Execution date: 10 October 2026 Australia Adelaide. Executor: Linux x86_64, Python 3.12.14, g++ 13.3.0. C++ build: g++ -std=c++17 -O2 -Wall -Wextra -pedantic upload/main_test.cpp -o research/v27-tests/qzl-suite. Assertions remained enabled. Python command: the primary runtime Python executed upload/qzl-system-engine-v3.py. Both completed with exit status 0. No source edits were applied.

Supplied suites

The five named groups cover zero-index rejection; shifted arithmetic and identities; a non-null tuple at q = 0; the seven-instruction compile and execute pipeline; and a repeated-operation timing loop. C++ and Python both produced R1 q = 7 and restored R4 q = −23 for the supplied pipeline. The suite asserts scalar outputs but does not assert full frame consistency, causal-history persistence or comprehensive null violations.

The benchmark loops each executed 200,000 instruction dispatches. The observed single-run C++ time was 0.77 ms and Python time 91.72 ms. These are executor-local observations for differently implemented loops, not comparative architecture benchmarks or an external performance guarantee. The printed Null State Violations: 0 is literal output, not a measured violation counter. Identity Preservation Count counts non-null evaluations and does not compare pre-transition identity with post-transition identity.

Additional source-specific probes

Probe V27-01: set source I = 91, q = −1, t = 100, frame_id = 7 and destination frame_id = 3; set the second operand q = 0. Execute shifted ADD into the destination. Both languages return q = 0, I = 91 and active state. This reproduces the central zero-coordinate retention behavior during an actual operation. Both also leave destination frame_id = 3 and set destination t = 2. Frame propagation and imported-state timestamp semantics therefore require explicit treatment.

Probe V27-02: for C++ JINV, source orientation ex = −1 and destination ex = +1 yield destination ex = −1 because the destination frame is flipped rather than copied from the source and inverted. Python negates the source x orientation but retains the destination y and z components. With source (−1,−1,−1) and destination y,z = −1, Python yields (1,−1,−1). Neither result is automatically a full inversion of the source frame in three dimensions.

Probe V27-03: C++ opcode 255 and Python opcode 4 advance the clock without raising an exception. Python opcode 4 leaves the frame unchanged. Probe V27-04: C++ R1junk parses as register 1; Python M−1 parses as slot −1. Both assemblers encode requested slot 9007199254740993 as double 9007199254740992, losing slot identity above exact binary64 integer precision.

Probe V27-05: Python LOAD restores a stored inactive tuple as active. C++ load of an unwritten M77 returns an active zero-coordinate state with I = 77, without a distinct missing-state classification. These observations are recorded as implementation behaviors requiring policy decisions; they are not null-coordinate crashes.

Hardware verification status

Current HDL verification is recorded in Confirmed verification results. The original static observations are now reproduced by simulation: reset clears identity and frame, zero identity is admitted, 32-bit time wraps, and minimum signed negation wraps. Physical timing closure and host trap integration remain unverified.

Confirmed verification results

Local verification comprises HDL simulation, RTL structural elaboration and optimization, generated-netlist replay, selected formal invariants, and software algebra and frame-conversion checks. The supplied source bytes remain unchanged. Results are confirmed by captured tool output; physical timing closure and hardware deployment require their own evidence.

Run identifier QZL-VERIFY-20261010-02. Source snapshot QZL-SRC-20261010-01. Verification date 10 October 2026 Australia Adelaide. Author Aboudy Keddeh, Systems Architect; publisher Keddeh Systems; AI contribution test construction, local execution, result integration and layout verification. Internal research; Draft; reserved rights profile KEDDEH-RESERVED-1.0.

Execution results

Test

Scope

Result

Confirmed evidence

V28 01

C++ algebra and frame checks

PASS

10,437 assertions

V28 02

Python algebra and frame checks

PASS

10,437 assertions

V28 03

Original RTL simulation

PASS

4,105 vectors; 24,639 assertions

V28 04

RTL structural check

PASS

Yosys reports zero problems

V28 05

Generated netlist replay

PASS

4,105 vectors; 24,639 assertions

V28 06

Four selected formal properties

PASS

Temporal induction succeeds at step 2

The executed assertion instances total 70,152 across the two software runs and the two HDL runs. Replay repeats the RTL stimulus against the generated netlist; it is not 24,639 additional unique properties. Formal results are recorded separately from the finite simulation counts.

Confirmed output excerpts

cpp-properties.txt: PASS cpp algebra_and_frame assertions=10437

python-properties.txt: PASS python algebra_and_frame assertions=10437

rtl-output.txt: PASS vectors=4105 assertions=24639 initial_seed=297

netlist-replay-output.txt: PASS vectors=4105 assertions=24639 initial_seed=297

Yosys structural check: Found and reported 0 problems. Formal verification: Induction step proven: SUCCESS! All six verification commands completed with exit status 0.

Verification method and reproduced behavior

Software properties

For u and v in the integer interval −10 through 10, verify each supplied shifted operation against transport through φ(x) = x − 1, verify the −1 additive and 0 multiplicative identities, and verify scalar involution J(J(u)) = u. For ε and ε′ in {−1,+1}, anchors o and o′ in −3 through 3, and physical x in −10 through 10, verify direct target-frame coordinates and round-trip frame conversion. Each language executes 2,205 algebra assertions and 8,232 frame assertions. The varied anchors exercise the helper methods; the kernel default anchor remains 1. This does not retest or repair the frame propagation findings in v2.7.

HDL stimulus and scoreboard

Icarus Verilog 12.0 compiles the unchanged SRC 07 module with a separately authored register_tb.v. Nine directed vectors and 4,096 pseudorandom vectors exercise all four opcodes. The random generator starts with seed 297. For every vector the scoreboard checks output hold before the clock edge, combinational alignment, tied-low trap output, complete clocked tuple result, identity and frame retention. Directed checks cover reset assertion and release, zero-coordinate outputs, signed arithmetic overflow, timestamp wrap, minimum signed negation, zero identity admission, repeated input timestamp and flag timing. The duplicate SRC 08 file has the same source hash, so this is one distinct RTL implementation.

The expected arithmetic is 32-bit modular arithmetic. The test confirms the supplied bitwise orientation update; it does not supply a physical interpretation of all 16 orientation bits. Random testing is bounded coverage, not an exhaustive proof of every input combination.

Elaboration and replay

Yosys 0.33, git identifier 2584903a060, executes read_verilog; hierarchy -check; proc; opt; check -assert; stat. The optimized intermediate design contains 15 cells, one 128-bit asynchronous-reset register cell and no memories or remaining processes. These are generic intermediate representation statistics, not mapped silicon area. The check reports zero structural problems. The emitted Verilog is then compiled by Icarus and replayed against the same scoreboard, producing the same passing counts.

The generated netlist lacks an explicit timescale declaration, producing an Icarus warning. The replay checks logic and event ordering with the testbench timescale and introduces no gate-delay claim. No target library, placement, routing or clock-frequency constraint was supplied, so physical timing closure remains outside these results.

Behavior relevant to the research contract

Confirmed: valid I = 91 and frame = 7 survive each tested zero-valued clocked transition. Confirmed: reset clears the entire tuple, including identity and frame. Confirmed: I = 0 and frame = 0 pass through normal operation. Confirmed: t = 0xffffffff increments to 0, and repeated input t = 10 yields output t = 11 rather than an accumulating local clock. Confirmed: negating q = 0x80000000 yields the same 32-bit pattern. Confirmed: align_flag can announce the pending zero result before out_sreg updates.

These observed behaviors pass the source-behavior checks. They do not establish unconditional identity retention through reset, rejection of invalid identities, unbounded monotonic time, or a registered alignment flag. Those stronger requirements need an explicit reset, validity, overflow and signal-timing contract; the original source has not been changed to implement one.

Formal scope evidence custody and revision

Selected inductive properties

formal.v instantiates the supplied module and introduces a past_valid guard. It asserts that null_trap remains zero. Where the current and previous sampled reset signals are both inactive, it asserts that output identity equals the preceding input identity, output frame identifier equals the preceding input frame identifier, and output timestamp equals the preceding input timestamp plus one modulo 2³². Inputs are symbolic; these properties include q = 0 and nonzero q without restricting the arithmetic opcode.

The Yosys flow is read_verilog -formal; prep -top formal_top -flatten; async2sync; dffunmap; sat -verify -seq 3 -tempinduct -prove-asserts -set-init-zero. The base case and induction step succeed, with induction completing at step 2. This is a proof in the transformed sampled-clock model with stated initialization and reset guards. It does not verify physical asynchronous reset pulses between sampled edges, metastability, unknown-valued hardware, analog behavior, arithmetic correctness for every opcode, or integration with CPU exception handling. Constant null_trap proves a port value; it does not prove external exception suppression.

Source and evidence custody

All eight supplied source records retain the original v2.7 hashes and verbatim listings. The existing /customXml/keddehSourceSnapshot.xml archive remains intact. A new /customXml/keddehVerification20261010.xml part stores exact bytes and SHA-256 records for the new harnesses, commands, result logs and generated netlists. The visible annex reproduces the test programs. This preserves the distinction between author-supplied implementation, AI-authored verification code and tool-generated evidence.

The required HDL tools were made available through a local installation. Executor setup is recorded in the verification archive and is separate from the architectural and mathematical results.

Remaining engineering work

Implementation actions A1 through A4 address arithmetic frame policy, full-vector inversion, instruction validation and integer slot encoding, state classification, imported timestamp ordering and durable event linkage. A5 testbench execution is complete for the stated cases. Physical timing, orientation meaning, reset policy and host integration remain design and implementation work.

Revision record

Version 2.8 — 10 October 2026 — Completed pending local HDL verification with seeded simulation, Yosys structural checks, generated-netlist replay and four selected inductive properties. Added 20,874 software property assertions and retained the executed evidence, test programs and original source snapshot. Status Draft. Author Aboudy Keddeh, Systems Architect. Publisher Keddeh Systems. Prior document and source revisions retained.

Conformance actions and source version control

These actions apply to the acquired snapshot. They do not replace the broader KEX, BRAINK or IL-LLM requirements, and no source change is included in v2.7.

Bounded implementation actions

A1 Define whether arithmetic retains the destination frame or adopts the producing source frame. Validate compatible operand frames or perform an explicit conversion before arithmetic. Add full-tuple checks for I, O, q, t and activity, including aliased destination registers.

A2 Make JINV frame semantics consistent across C++ and Python. Specify whether inversion applies only to x or to the full orientation vector, then check non-default source and destination frames. Specify how frame identifiers and origin anchors propagate.

A3 Reject unknown opcodes and define whether clock advancement occurs on rejected instructions. Expose TRANSFORM end to end where required, or state the restricted instruction set. Preserve integer register and memory identifiers with integer-typed instruction fields; require complete numeric-token consumption and an explicit permitted identifier range.

A4 Classify unwritten, inactive and invalid states explicitly. Define LOAD activity preservation and imported timestamp ordering. Separate process-resident tuple copying from the existing durable event and rehydration obligations. A new event ledger is not claimed by these files.

A5 HDL simulation, reset and overflow cases, flag timing, generated-netlist replay and selected formal invariants have been completed for the recorded snapshot. Specify physical orientation encoding, reset policy and target timing constraints before hardware integration.

Release and evidence policy

Document revision 2.7 is an additive source integration and evaluation revision. Snapshot QZL-SRC-20261010-01 is immutable as submitted. Any corrected implementation should receive a new snapshot identifier, new source hashes, a change record linked to A1 through A5 as applicable, rerun supplied tests and targeted regressions, and an independently identified verification receipt before deployment status changes. The present software checks are local execution evidence, not an independent assessor signature.

Verbatim source comments and banners remain intact, including their authorship labels and performance or hardware wording. Their presence in the annex is source preservation, not adoption of every comment as an independently established conclusion. Source-specific release labels are never silently rewritten to match the document revision.

Limitations and open questions

The original ZCG executable slice has no curvature operator or holonomy transport. The workbench does not claim that a paraboloid projection qualifies such a system. Exact named native curvature, rotational geometry and holonomy artifacts must be acquired before their execution law is tested. The provisional curvature/retention archive is preserved as a family of distinct research objects, rather than compressed into the codec.

Shared-origin reference integrity is tested separately from coordinate invertibility. The signed observer gap is retained without replacing it by a squared objective. Environmental hypotheses are tested through their declared mechanisms rather than through an unrelated shifted profile or crowding model.

The code correction is a local candidate and has not been promoted into the source Drive archive, a governed BRAINK repository or a deployment of the native engine. The privately hosted workbench is a research tool, with a separate source/version/deployment receipt. It does not edit keddeh.com or another established estate project. A successful native Sites receipt establishes the workbench deployment; browser interaction and responsive rendering remain unverified in a browser in this environment.

Concrete next experiment for density emergence

Declare a whole W by an observable coherence/persistence criterion before selecting its coordinate label. Record its identity as U=1 and retain measured physical density ρ, sampling volume, energy/coupling, dispersion, time, boundary conditions and observer transform. Generate at least three density conditions with independent specimens or randomized repeated trials. Preserve left/right asymmetry rather than recentering it away. Compare a density-neutral baseline with a specified density-dependent model and a crowding/dispersion alternative. Hold back conditions for prediction. Record onset threshold, persistence duration, collapse rate and uncertainty. Reject the chosen density law if its preregistered direction or threshold fails outside calibration uncertainty; retain the failed model and measured state as typed evidence.

This experiment addresses the substantive author claim: environmental conditions can affect the emergence and persistence of a natural whole. It does not require proving that a coordinate numeral causes emergence. Whether the natural-whole boundary, density relation and origin law form a stronger native mechanism is the object of the experiment, not an assumed conclusion.

References

P01 An Unaccepted Evolution — primary preprint, September 2026. PRIMARY AUTHOR SOURCE. Four constraints, observer theorem, boxes §4.2, empirical predictions and declared limits. https://docs.google.com/document/d/11IjwDz_VPRWyA0samFCrOI7jLjnT-cwFH_HD2Z02izc/edit

O01 ORIGIN OF ZERO — KEDDEH SYSTEMS RESEARCH.pdf. SUPPLIED RESEARCH / CONVERSATION MANUSCRIPT. 82-page acquired text; origin-to-displacement algebra and norm-based shell relations. Not an external assessment.

Z01 ZCG Core Engine archive — 15 September 2026. ORIGINAL EXECUTABLE SOURCE. 37 tests, 13 exceptions, finite map, codec, proof preimage and golden vectors. https://drive.google.com/file/d/1U5ReU8jEMvI866ZB7Zn7PAMXQtbPCoof/view

Z02 Earlier ZCG exception boundary archive. ARCHIVED EARLIER EDITION. Keep exception-only and codec editions distinct. https://drive.google.com/file/d/1sSgc7brItA9IcIh0LINv7XW5ayiVnxOg/view

P02 KEX/BRAINK Formulas topic packet. RETRIEVAL PACKET. Wake/curvature/retention, coupling, dispersion and environmental normalisation; formulas are provisional and versioned. https://drive.google.com/file/d/1TW5tLJgSzalcZqqUeiHuS36i-Vjx_QPp/view

P03 Less Zero, Continuity and Distributed Loop Logic — 2 October. SOURCE RECONCILIATION. Zero roles, typed continuity, scheduler constraints and reported quantum mapping. https://drive.google.com/file/d/1Fsh2KYOlgcIE6QxzIXVI1GQsmjA7w_he/view

B01 Boxes in a Box — source learning and deep report. SECONDARY SOURCE LEARNING. Supports source discovery; primary preprint now acquired directly. https://drive.google.com/file/d/1nimxe8zwF9y7uHfly0kcbhNtLVtixdwb/view

E07 NIST — Normal distribution. EXTERNAL PRIMARY TECHNICAL REFERENCE. Normal PDF with independent location and scale parameters. https://www.itl.nist.gov/div898/handbook/eda/section3/eda3661.htm

U02 Author clarification — 10 October 2026. CURRENT AUTHOR STATEMENT. Left/right density around origin one and environmental influence on natural whole emergence.

E08 MIT, Discrete vs. Smooth Geometry, 18.095 material, Justin Solomon, 2019. https://math.mit.edu/classes/18.095/2019IAP/solomon_pset.pdf . Turning angle and distinct discrete curvature constructions.

The v1 source ledger below is retained for all preserved R01–R09 derivations. Drive IDs identify acquisition targets; equal titles do not establish canonical identity.

K1 A. Keddeh. KEX/BRAINK Zeroless Computational Standard v1.0, 18 July 2026. Drive ID 1VE4Nh2Dg0yosmTn-gyJOYVNza284FaWL. https://drive.google.com/file/d/1VE4Nh2Dg0yosmTn-gyJOYVNza284FaWL/view

K2 A. Keddeh. 01_ACTIVE_STATE_FOUNDATIONS_v1_0.docx. Drive ID 1m2ipz_7dwt6t3Qeyhmnp3hkD6FTJ01ve.

K3 A. Keddeh. 02_TYPED_ZERO_NON_ERASING_ARITHMETIC_v1_0.docx. Drive ID 1pyJOwseyunwErpxkVJzF9w_FxuuiNmtA.

K4 A. Keddeh. 03_ORDERED_TOPOLOGY_PROJECTION_LOSS_v1_0.docx. Drive ID 1a_-soAFqNqmALiVRF91fopDI2WNi4bA3.

K5 A. Keddeh. 04_BILATERAL_REBOUND_RECURSIVE_GEOMETRY_v1_0.docx. Drive ID 1wDHj3WDkHuL3dLHA832dciffqeXQwYRi.

K6 A. Keddeh. 05_OBSERVER_ANCHORED_MEASUREMENT_v1_0.docx. Drive ID 1DXX1k2tWabswLE2zZ3QOcAgwtHti3wJz.

K7 A. Keddeh. KEDDEH_THEOREM_BRAINK_MASTER_v1_9_FULL_EDITED.docx. Drive ID 1kVVQgGxP4Hva8ovekUtY7l8ipVbpk3Im.

K8 Keddeh Systems learning record. KEDDEH_MATHS_01_LEARNER_RECOUNT_SYMBOL_CLASSIFICATION_1_ORIGIN_XYZ_20261002.docx. Drive ID 1CcQDTBGVMtncxIUaSO0Ze9GE3m13mDjM. AI-assisted recount, not independent assessment.

K9 A. Keddeh. KEX_BRAINK_Mathematical_Foundations_and_Proof_Obligations_v1_0.docx. Drive ID 1x3m7DwJbqSFMK4skvzf0pWUXauM-R_gX.

K10 A. Keddeh. KEX_BRAINK_Axiomatic_Research_Protocol_v1_0.docx. Drive ID 1hLS4NR4z1OjNzOCcAKL8dtbbHwZBFiAY.

K11 A. Keddeh. KEDDEH_QUANTUM_COMPUTATIONAL_FORMALISM_TECHNICAL_PUBLICATION_R3.html, 17 August 2026. Drive ID 1eVSSqgl6aXxOrM1XKqApSFft1loXh8mG.

K12 KEX_LAW3_ZEROLESS_PROTOCOL.md. Drive ID 1_vNOhRS8s8alw7j4TRcpnTwhNf1LnP0a.

K13 ZERO_LESS_SYSTEM_DELIVERY.md. Drive ID 18JlDlpRZRRLZcwjp2J9FnuTZ2WR7_2JI. Source-reported implementation/test summary.

K14 KEDDEH_Bilateral_Proof_Engine_White_Paper.pdf. Drive ID 19eMPYlqaJPDiS_crjU-4tCioyth-V63B. Source-reported workbook measurements.

K15 kex_whitepaper_calculations.py and KEX_ACTIVE_STATE_CALCULATION_RECEIPT.json. Drive IDs 1rhQzSlMfadKXqfM3jp3qEjEzqbpaeH7f and 1Qr_Z4QGXO6gz8H9AZyxYSi6cVgDQ8bH0. Raw bytes acquired and result reproduced exactly.

K16 KEX_UNIFIED_THEOREM_FINAL.md and KEX_MATHEMATICAL_DECOMPOSITION_v1.md. Drive IDs 1lpZ9iiElwB6IHhh8OQSaom2L3_Fz3dxc and 12whHV-Zt3WOrOM-UHwkR3BFbcciXMv99. Archived calibration and probability models.

K17 monograph_source_index.md. Drive ID 1g6-uZNEStLY2s0c6ZM1ShJYFIPWckrU3. Discovery index, not substitute for monograph full text.

W1 Keddeh Systems. Research atlas Origin Relation Observation. https://www.keddeh.com/research/discoveries . Retrieved 10 October 2026 Adelaide time. Includes paired-whole definition, singular origin and reference-experiment boundaries.

W2 Keddeh Systems. https://www.keddeh.com/architecture ; /research ; /kex ; /technology ; /research/resonance ; /evidence ; /learn ; /research/learn ; homepage. Direct HTML retrieval 10 October 2026 Adelaide time.

E1 S. Breaz, T. Brzeziński, B. Rybołowicz and P. Saracco. Heaps of modules and affine spaces. https://arxiv.org/abs/2203.07268 . Primary mathematical research, affine/module correspondence.

E2 JCGM. International Vocabulary of Metrology, 1.19 quantity value. https://jcgm.bipm.org/vim/en/1.19.html . Number and reference are distinct parts of a quantity value.

E3 JCGM. International Vocabulary of Metrology, 2.9 measurement result. https://jcgm.bipm.org/vim/en/2.9.html . Relevant information and uncertainty accompany measurement.

E4 BIPM. International System of Units, 9th edition, current retrieved version 4.01. https://www.bipm.org/documents/20126/41483022/SI-Brochure-9-EN.pdf . Celsius/Kelvin scale definition.

E5 J. Preskill. Quantum Information and Computation, Chapter 2 Foundations I. https://www.preskill.caltech.edu/ph229/notes/chap2.pdf ; Chapter 3 Measurement and Evolution https://www.preskill.caltech.edu/ph229/notes/chap3.pdf . State rays, normalization, phase and measurement references.

E6 F. Giacomini, E. Castro-Ruiz and Č. Brukner. Quantum mechanics and the covariance of physical laws in quantum reference frames. https://arxiv.org/abs/1712.07207 . Physical reference frames and relational transformations; not a validation of KEX by association.

U1 Supplied Pasted text(3).txt. Conversation source for current research directive and original interpretations. The (-3+)+(-14+)=(-17+) example is also explicitly supplied in the project conversation context.

Execution artifacts: results/audit.json; original-tests.txt; corrected-regression.txt; corrected-proof-probe.txt; exception-replay.txt; workbench-validation.json. Original archives and source text extracts are preserved in the evidence package with a SHA-256 inventory. The exact code correction is correction.patch.

Primary comparison references

E15 CERN (2023), ALPHA experiment at CERN observes the influence of gravity on antimatter. https://home.cern/alpha-experiment-at-cern-observes-the-influence-of-gravity-on-antimatter/

E16 Zhmoginov, Charman, Fajans and Wurtele (2013), Nonlinear dynamics of antihydrogen in magnetostatic traps. https://arxiv.org/abs/1303.2738

E17 COMSOL, Euler Angle Rotation in Surface Acoustic Wave Modeling. https://doc.comsol.com/6.4/doc/com.comsol.help.models.mems.saw_euler_angle_rotation/saw_euler_angle_rotation.html

E18 Planck Collaboration (2013 preprint), Planck 2013 results XXVII Doppler boosting of the CMB. https://arxiv.org/abs/1303.5087

Revision history and reading structure

Version 2.9 — 10 October 2026 Australia Adelaide. Reorganized the paper around Aboudy Keddeh’s definitions, propositions, mechanisms, algorithms, applications and verified results. Removed the learning and assessment narrative from the main research voice. Appendix A preserves the supplied source listings and original byte archive; Appendix B preserves verification programs and evidence; Appendix C retains the editorial assessment and historical corrections. All prior implementation evidence and source hashes remain unchanged. Status Draft.

Appendix A Versioned implementation sources

Source inventory and immutable snapshot

SRC 01 qzl_types.hpp

Bytes 3598 | Lines 116 | Snapshot QZL-SRC-20261010-01

SHA-256 3c88b81c5d87c3c37e0dbcdf2d7790915bc1b68bebd910bb66698bd809ffe4be

SRC 02 qzl_kernel.hpp

Bytes 5815 | Lines 163 | Snapshot QZL-SRC-20261010-01

SHA-256 18427a74820bd54feb372bc00fda67b76da6608761b1a4c9b505ecff545023b6

SRC 03 qzl_assembler.hpp

Bytes 4264 | Lines 111 | Snapshot QZL-SRC-20261010-01

SHA-256 d7fb1086cbecd5096f46bfa29f4bf8563a5aeb77e1ada4406c34773a0aa7e3e0

SRC 04 qzl_compiler.hpp

Bytes 2827 | Lines 78 | Snapshot QZL-SRC-20261010-01

SHA-256 c920bcf425d6adeb644d799f36f09b091a259d2c663423deb8299e400e11c84f

SRC 05 main_test.cpp

Bytes 7280 | Lines 174 | Snapshot QZL-SRC-20261010-01

SHA-256 4cb8138aeb4625f882228428649755c37a0f2b0ca20c5d4bfa6d5e2504e402b4

SRC 06 qzl-system-engine-v3.py

Bytes 15842 | Lines 430 | Snapshot QZL-SRC-20261010-01

SHA-256 cdb4b45c9e59d406ced36b8b0cd9aa1191b68c09093d2dee4fbc8afe2d983b27

SRC 07 quantum-state-register-128.v

Bytes 3018 | Lines 76 | Snapshot QZL-SRC-20261010-01

SHA-256 fc2ad5bc9868b5f7952d428550a4f060ad5642f56e220c336e3e5900361dbe30

SRC 08 quantum-state-register-128 (1).v

Bytes 3018 | Lines 76 | Snapshot QZL-SRC-20261010-01

SHA-256 fc2ad5bc9868b5f7952d428550a4f060ad5642f56e220c336e3e5900361dbe30

SRC 07 and SRC 08 are exact byte duplicates. Both attachment identities and full listings are retained. No commit identifier, upstream date or release authority was supplied for the unnamed header and RTL versions.

© 2026 Aboudy Keddeh  |  Keddeh Systems  |  All rights reserved

KEDDEH-RES-OBSERVER-ORIGIN-001  |  v2.9  |  Internal research  |  Draft  |  Page  of 

KEDDEH SYSTEMS | RESEARCH AND FORMAL PUBLISHING
ENGINEER · AUTOMATE · SCALE

Verbatim source SRC 01

qzl_types.hpp | QZL-SRC-20261010-01 | Lines 1 to 29

#ifndef QZL_TYPES_HPP
#define QZL_TYPES_HPP

#include <iostream>
#include <string>
#include <vector>
#include <cstdint>
#include <cmath>
#include <stdexcept>
#include <iomanip>

namespace QZL {

// 1-Based Indexing Enforcement: Baseline Origin is 1
constexpr int64_t BASELINE_ORIGIN = 1;

// Orientation Vector in 3D Space: (-1 or +1)
struct Orientation3D {
    int8_t ex = 1;
    int8_t ey = 1;
    int8_t ez = 1;

    void flip() {
        ex = -ex;
        ey = -ey;
        ez = -ez;
    }
};

Verbatim source SRC 01

qzl_types.hpp | QZL-SRC-20261010-01 | Lines 30 to 58

// Observer Reference Frame O = (o, epsilon)
struct ObserverFrame {
    uint64_t frame_id = 1; // 1-based frame identifier (1, 2, 3...)
    int64_t origin_anchor = BASELINE_ORIGIN; // Baseline o = 1 (NO 0x00 / 0-origin mapping)
    Orientation3D orientation;

    // Coordinate transformation from physical x to observer coordinate q
    double to_coordinate(double x) const {
        return orientation.ex * (x - origin_anchor);
    }

    // Frame transformation to another observer frame O'
    double transform_to(double q_O, const ObserverFrame& O_prime) const {
        // q_{O'}(x) = epsilon' * epsilon * q_O(x) + epsilon' * (o - o')
        return O_prime.orientation.ex * orientation.ex * q_O + 
               O_prime.orientation.ex * (origin_anchor - O_prime.origin_anchor);
    }
};

// Observer State Tuple S = (I, O, q, t)
struct StateTuple {
    uint64_t identity_id = 1;     // I: Invariant Object Identity (1-based ID, never 0)
    ObserverFrame frame;           // O: Symbolic Observer Frame
    double q = 0.0;                // q: Relative Coordinate (q = x - o)
    uint64_t t = 1;                // t: Monotonic Execution Timestamp (starts at t=1)
    bool is_active = true;         // State is always active even when q = 0

    // Non-Null Conservation Axiom: q = 0 => S != null
    bool is_null() const {

Verbatim source SRC 01

qzl_types.hpp | QZL-SRC-20261010-01 | Lines 59 to 87

        return !is_active || identity_id == 0; // identity_id = 0 is invalid
    }
};

// Shifted Coordinate Algebra Functions (Baseline o = 1, u = x - 1)
class ShiftedAlgebra {
public:
    // Transported Addition: u (+) v = u + v + 1
    static double add(double u, double v) {
        return u + v + 1.0;
    }

    // Transported Multiplication: u (*) v = u*v + u + v
    static double multiply(double u, double v) {
        return u * v + u + v;
    }

    // Additive Identity in Shifted Coordinates: -1
    // Proof: u (+) (-1) = u + (-1) + 1 = u
    static double additive_identity() {
        return -1.0;
    }

    // Multiplicative Identity in Shifted Coordinates: 0 (corresponds to physical x = 1)
    // Proof: u (*) 0 = u*0 + u + 0 = u
    static double multiplicative_identity() {
        return 0.0;
    }

Verbatim source SRC 01

qzl_types.hpp | QZL-SRC-20261010-01 | Lines 88 to 116

    // Orientation Involution Operator J(q) = -q
    static double orientation_involution(double q) {
        return -q;
    }
};

// Opcodes for QZL Assembler and Kernel (1-based instruction enumeration)
enum class Opcode : uint8_t {
    ADD_SHIFTED = 1,   // u (+) v = u + v + 1
    MUL_SHIFTED = 2,   // u (*) v = u*v + u + v
    J_INV       = 3,   // Orientation Involution J(q) = -q
    TRANSFORM   = 4,   // Coordinate Frame Transformation
    STORE_MEM   = 5,   // Store to 1-based Memory Slot
    LOAD_MEM    = 6,   // Load from 1-based Memory Slot
    STATE_EVAL  = 7    // Verify S = (I, O, q, t) retention at q=0
};

// Machine Instruction Struct
struct Instruction {
    Opcode op;
    uint32_t dest_reg;  // 1-based register ID (R1, R2, ...)
    uint32_t src1_reg;  // 1-based register ID
    uint32_t src2_reg;  // 1-based register ID
    double immediate;   // Immediate scalar value
};

} // namespace QZL

#endif // QZL_TYPES_HPP

Verbatim source SRC 02

qzl_kernel.hpp | QZL-SRC-20261010-01 | Lines 1 to 32

#ifndef QZL_KERNEL_HPP
#define QZL_KERNEL_HPP

#include "qzl_types.hpp"
#include <map>
#include <vector>

namespace QZL {

class Kernel {
private:
    // 1-Based State Registers (R_1, R_2, ..., R_N). No 0-register exists!
    std::vector<StateTuple> registers;
    
    // 1-Based Memory Slots (M_1, M_2, ..., M_N). No 0-slot exists!
    std::map<uint64_t, StateTuple> memory;

    uint64_t current_time = 1;
    uint64_t total_zero_crossings = 0;
    uint64_t identity_preservation_count = 0;

public:
    Kernel(size_t num_registers = 16) {
        // Allocate registers indexed from 1 to num_registers
        // Position 0 in vector is unused dummy to strictly enforce 1-based indexing!
        registers.resize(num_registers + 1);
        for (size_t i = 1; i <= num_registers; ++i) {
            registers[i].identity_id = i; // Default 1-based ID
            registers[i].frame.origin_anchor = BASELINE_ORIGIN; // o = 1
            registers[i].q = 0.0;
            registers[i].t = 1;
            registers[i].is_active = true;

Verbatim source SRC 02

qzl_kernel.hpp | QZL-SRC-20261010-01 | Lines 33 to 65

        }
    }

    // Access Register (Strict 1-Based Indexing, throws error if reg_id == 0)
    StateTuple& get_register(uint32_t reg_id) {
        if (reg_id == 0) {
            throw std::invalid_argument("ERROR: Invalid 0x/0-mapping attempt! QZL architecture prohibits index 0. All registers start at 1.");
        }
        if (reg_id >= registers.size()) {
            throw std::out_of_range("Register index out of bounds.");
        }
        return registers[reg_id];
    }

    // Store State to Memory (Strict 1-Based Memory Slot)
    void store_memory(uint64_t slot_id, const StateTuple& state) {
        if (slot_id == 0) {
            throw std::invalid_argument("ERROR: Invalid 0x/0-mapping attempt! QZL architecture prohibits memory slot 0. All memory slots start at 1.");
        }
        memory[slot_id] = state;
    }

    // Load State from Memory
    StateTuple load_memory(uint64_t slot_id) {
        if (slot_id == 0) {
            throw std::invalid_argument("ERROR: Invalid 0x/0-mapping attempt! Memory slot 0 does not exist.");
        }
        if (memory.find(slot_id) == memory.end()) {
            StateTuple new_state;
            new_state.identity_id = slot_id;
            new_state.frame.origin_anchor = BASELINE_ORIGIN;
            new_state.q = 0.0;
            new_state.t = current_time;

Verbatim source SRC 02

qzl_kernel.hpp | QZL-SRC-20261010-01 | Lines 66 to 97

            return new_state;
        }
        return memory[slot_id];
    }

    // Execute Single Instruction in Relational Kernel
    void execute(const Instruction& instr) {
        current_time++;

        switch (instr.op) {
            case Opcode::ADD_SHIFTED: {
                StateTuple& dest = get_register(instr.dest_reg);
                StateTuple& src1 = get_register(instr.src1_reg);
                StateTuple& src2 = get_register(instr.src2_reg);

                // u (+) v = u + v + 1
                dest.q = ShiftedAlgebra::add(src1.q, src2.q);
                dest.identity_id = src1.identity_id; // Identity preserved
                dest.t = current_time;
                dest.is_active = true;
                break;
            }

            case Opcode::MUL_SHIFTED: {
                StateTuple& dest = get_register(instr.dest_reg);
                StateTuple& src1 = get_register(instr.src1_reg);
                StateTuple& src2 = get_register(instr.src2_reg);

                // u (*) v = u*v + u + v
                dest.q = ShiftedAlgebra::multiply(src1.q, src2.q);
                dest.identity_id = src1.identity_id;
                dest.t = current_time;

Verbatim source SRC 02

qzl_kernel.hpp | QZL-SRC-20261010-01 | Lines 98 to 130

                dest.is_active = true;
                break;
            }

            case Opcode::J_INV: {
                StateTuple& dest = get_register(instr.dest_reg);
                StateTuple& src = get_register(instr.src1_reg);

                dest.q = ShiftedAlgebra::orientation_involution(src.q);
                dest.frame.orientation.flip();
                dest.identity_id = src.identity_id;
                dest.t = current_time;
                dest.is_active = true;
                break;
            }

            case Opcode::TRANSFORM: {
                StateTuple& dest = get_register(instr.dest_reg);
                StateTuple& src = get_register(instr.src1_reg);
                
                ObserverFrame target_frame;
                target_frame.frame_id = (uint64_t)instr.immediate;
                target_frame.origin_anchor = BASELINE_ORIGIN; // o = 1

                dest.q = src.frame.transform_to(src.q, target_frame);
                dest.frame = target_frame;
                dest.identity_id = src.identity_id;
                dest.t = current_time;
                dest.is_active = true;
                break;
            }

            case Opcode::STORE_MEM: {

Verbatim source SRC 02

qzl_kernel.hpp | QZL-SRC-20261010-01 | Lines 131 to 163

                StateTuple& src = get_register(instr.src1_reg);
                store_memory((uint64_t)instr.immediate, src);
                break;
            }

            case Opcode::LOAD_MEM: {
                StateTuple& dest = get_register(instr.dest_reg);
                dest = load_memory((uint64_t)instr.immediate);
                dest.t = current_time;
                break;
            }

            case Opcode::STATE_EVAL: {
                StateTuple& src = get_register(instr.src1_reg);
                if (src.q == 0.0) {
                    total_zero_crossings++;
                }
                if (!src.is_null()) {
                    identity_preservation_count++;
                }
                break;
            }
        }
    }

    uint64_t get_zero_crossings() const { return total_zero_crossings; }
    uint64_t get_identity_preservations() const { return identity_preservation_count; }
    uint64_t get_clock_time() const { return current_time; }
};

} // namespace QZL

#endif // QZL_KERNEL_HPP

Verbatim source SRC 03

qzl_assembler.hpp | QZL-SRC-20261010-01 | Lines 1 to 27

#ifndef QZL_ASSEMBLER_HPP
#define QZL_ASSEMBLER_HPP

#include "qzl_types.hpp"
#include <string>
#include <vector>
#include <sstream>
#include <algorithm>
#include <stdexcept>

namespace QZL {

class Assembler {
public:
    // Helper to parse register token like "R1", "R2"
    static uint32_t parse_register(const std::string& token) {
        if (token.empty() || (token[0] != 'R' && token[0] != 'r')) {
            throw std::invalid_argument("Assembler Error: Register token must start with 'R' (e.g. R1, R2). Token: " + token);
        }
        uint32_t reg_id = std::stoul(token.substr(1));
        if (reg_id == 0) {
            throw std::invalid_argument("Assembler Error: R0 or 0x mapping is PROHIBITED. All registers must start at R1.");
        }
        return reg_id;
    }

    // Helper to parse memory token like "M1", "M2"

Verbatim source SRC 03

qzl_assembler.hpp | QZL-SRC-20261010-01 | Lines 28 to 55

    static uint64_t parse_memory(const std::string& token) {
        if (token.empty() || (token[0] != 'M' && token[0] != 'm')) {
            throw std::invalid_argument("Assembler Error: Memory token must start with 'M' (e.g. M1, M2). Token: " + token);
        }
        uint64_t slot_id = std::stoull(token.substr(1));
        if (slot_id == 0) {
            throw std::invalid_argument("Assembler Error: M0 or 0x mapping is PROHIBITED. Memory slots start at M1.");
        }
        return slot_id;
    }

    // Assemble assembly source code string into Machine Instructions
    static std::vector<Instruction> assemble(const std::string& source_code) {
        std::vector<Instruction> bytecode;
        std::istringstream stream(source_code);
        std::string line;

        while (std::getline(stream, line)) {
            // Trim whitespace
            line.erase(0, line.find_first_not_of(" \t\r\n"));
            line.erase(line.find_last_not_of(" \t\r\n") + 1);

            if (line.empty() || line[0] == ';') continue; // Skip comments and empty lines

            std::istringstream line_stream(line);
            std::string op_str;
            line_stream >> op_str;

Verbatim source SRC 03

qzl_assembler.hpp | QZL-SRC-20261010-01 | Lines 56 to 83

            // Convert opcode to uppercase
            std::transform(op_str.begin(), op_str.end(), op_str.begin(), ::toupper);

            Instruction instr{};

            if (op_str == "ADD") {
                std::string dest, src1, src2;
                line_stream >> dest >> src1 >> src2;
                instr.op = Opcode::ADD_SHIFTED;
                instr.dest_reg = parse_register(dest);
                instr.src1_reg = parse_register(src1);
                instr.src2_reg = parse_register(src2);
            } else if (op_str == "MUL") {
                std::string dest, src1, src2;
                line_stream >> dest >> src1 >> src2;
                instr.op = Opcode::MUL_SHIFTED;
                instr.dest_reg = parse_register(dest);
                instr.src1_reg = parse_register(src1);
                instr.src2_reg = parse_register(src2);
            } else if (op_str == "JINV") {
                std::string dest, src;
                line_stream >> dest >> src;
                instr.op = Opcode::J_INV;
                instr.dest_reg = parse_register(dest);
                instr.src1_reg = parse_register(src);
            } else if (op_str == "STORE") {
                std::string src, mem_slot;
                line_stream >> src >> mem_slot;

Verbatim source SRC 03

qzl_assembler.hpp | QZL-SRC-20261010-01 | Lines 84 to 111

                instr.op = Opcode::STORE_MEM;
                instr.src1_reg = parse_register(src);
                instr.immediate = (double)parse_memory(mem_slot);
            } else if (op_str == "LOAD") {
                std::string dest, mem_slot;
                line_stream >> dest >> mem_slot;
                instr.op = Opcode::LOAD_MEM;
                instr.dest_reg = parse_register(dest);
                instr.immediate = (double)parse_memory(mem_slot);
            } else if (op_str == "EVAL") {
                std::string src;
                line_stream >> src;
                instr.op = Opcode::STATE_EVAL;
                instr.src1_reg = parse_register(src);
            } else {
                throw std::invalid_argument("Assembler Error: Unknown instruction opcode '" + op_str + "'");
            }

            bytecode.push_back(instr);
        }

        return bytecode;
    }
};

} // namespace QZL

#endif // QZL_ASSEMBLER_HPP

Verbatim source SRC 04

qzl_compiler.hpp | QZL-SRC-20261010-01 | Lines 1 to 26

#ifndef QZL_COMPILER_HPP
#define QZL_COMPILER_HPP

#include "qzl_assembler.hpp"
#include <string>
#include <vector>
#include <sstream>

namespace QZL {

class Compiler {
public:
    // Compiles High-Level QZL Language Source into Assembly String
    static std::string compile_to_assembly(const std::string& high_level_source) {
        std::ostringstream asm_out;
        std::istringstream stream(high_level_source);
        std::string line;

        while (std::getline(stream, line)) {
            line.erase(0, line.find_first_not_of(" \t\r\n"));
            line.erase(line.find_last_not_of(" \t\r\n") + 1);

            if (line.empty() || line[0] == '#') continue; // Comments

            std::istringstream ls(line);
            std::string keyword;

Verbatim source SRC 04

qzl_compiler.hpp | QZL-SRC-20261010-01 | Lines 27 to 52

            ls >> keyword;

            std::transform(keyword.begin(), keyword.end(), keyword.begin(), ::toupper);

            if (keyword == "ADD") {
                // ADD R1 R2 R3
                std::string dest, src1, src2;
                ls >> dest >> src1 >> src2;
                asm_out << "ADD " << dest << " " << src1 << " " << src2 << "\n";
            } else if (keyword == "MULTIPLY" || keyword == "MUL") {
                // MUL R1 R2 R3
                std::string dest, src1, src2;
                ls >> dest >> src1 >> src2;
                asm_out << "MUL " << dest << " " << src1 << " " << src2 << "\n";
            } else if (keyword == "INVERT" || keyword == "FLIP") {
                // FLIP R1 R2
                std::string dest, src;
                ls >> dest >> src;
                asm_out << "JINV " << dest << " " << src << "\n";
            } else if (keyword == "SAVE" || keyword == "STORE") {
                // SAVE R1 M3
                std::string src, mem;
                ls >> src >> mem;
                asm_out << "STORE " << src << " " << mem << "\n";
            } else if (keyword == "RESTORE" || keyword == "LOAD") {
                // RESTORE R1 M3

Verbatim source SRC 04

qzl_compiler.hpp | QZL-SRC-20261010-01 | Lines 53 to 78

                std::string dest, mem;
                ls >> dest >> mem;
                asm_out << "LOAD " << dest << " " << mem << "\n";
            } else if (keyword == "VERIFY" || keyword == "EVAL") {
                // VERIFY R1
                std::string src;
                ls >> src;
                asm_out << "EVAL " << src << "\n";
            } else {
                throw std::invalid_argument("Compiler Error: High-level syntax unrecognized: '" + line + "'");
            }
        }

        return asm_out.str();
    }

    // Direct High-Level to Bytecode Compilation Pipeline
    static std::vector<Instruction> compile(const std::string& high_level_source) {
        std::string assembly_code = compile_to_assembly(high_level_source);
        return Assembler::assemble(assembly_code);
    }
};

} // namespace QZL

#endif // QZL_COMPILER_HPP

Verbatim source SRC 05

main_test.cpp | QZL-SRC-20261010-01 | Lines 1 to 29

#include "qzl_types.hpp"
#include "qzl_kernel.hpp"
#include "qzl_assembler.hpp"
#include "qzl_compiler.hpp"

#include <iostream>
#include <chrono>
#include <cassert>
#include <iomanip>

using namespace QZL;

void print_banner(const std::string& title) {
    std::cout << "\n======================================================================\n";
    std::cout << "  " << title << "\n";
    std::cout << "======================================================================\n";
}

int main() {
    print_banner("QZL NATIVE C++ SYSTEM SUITE: COMPILER, ASSEMBLER & KERNEL");
    std::cout << "Origin Baseline: o = 1 (No 0x / 0-origin mapping in system)\n";

    // ------------------------------------------------------------------
    // TEST 1: STRICT 1-BASED ORIGIN & NO-0x MAPPING REJECTION
    // ------------------------------------------------------------------
    print_banner("TEST 1: 1-Based Origin & 0x Mapping Rejection Verification");
    Kernel kernel(16);

    bool caught_reg_0 = false;

Verbatim source SRC 05

main_test.cpp | QZL-SRC-20261010-01 | Lines 30 to 58

    try {
        kernel.get_register(0); // Attempt register 0
    } catch (const std::invalid_argument& e) {
        caught_reg_0 = true;
        std::cout << "[PASSED] Correctly caught register 0 access: " << e.what() << "\n";
    }
    assert(caught_reg_0);

    bool caught_mem_0 = false;
    try {
        kernel.store_memory(0, StateTuple{}); // Attempt memory slot 0
    } catch (const std::invalid_argument& e) {
        caught_mem_0 = true;
        std::cout << "[PASSED] Correctly caught memory slot 0 access: " << e.what() << "\n";
    }
    assert(caught_mem_0);

    bool caught_asm_r0 = false;
    try {
        Assembler::parse_register("R0");
    } catch (const std::invalid_argument& e) {
        caught_asm_r0 = true;
        std::cout << "[PASSED] Assembler correctly rejected R0: " << e.what() << "\n";
    }
    assert(caught_asm_r0);

    // ------------------------------------------------------------------
    // TEST 2: SHIFTED COORDINATE ALGEBRA & NATIVE IDENTITIES (o = 1)
    // ------------------------------------------------------------------

Verbatim source SRC 05

main_test.cpp | QZL-SRC-20261010-01 | Lines 59 to 87

    print_banner("TEST 2: Shifted Algebra & Native Identity Verification (o = 1)");
    double u = 5.0;
    double v = 3.0;

    double add_res = ShiftedAlgebra::add(u, v); // 5 + 3 + 1 = 9
    double mul_res = ShiftedAlgebra::multiply(u, v); // 5*3 + 5 + 3 = 23

    std::cout << "Shifted Addition (5 (+) 3) = " << add_res << " (Expected: 9)\n";
    assert(add_res == 9.0);

    std::cout << "Shifted Multiplication (5 (*) 3) = " << mul_res << " (Expected: 23)\n";
    assert(mul_res == 23.0);

    // Prove Additive Identity = -1 in Shifted Coordinates
    double add_id = ShiftedAlgebra::additive_identity();
    double test_add_id = ShiftedAlgebra::add(u, add_id);
    std::cout << "Additive Identity Check: 5 (+) (-1) = " << test_add_id << " (Expected: 5)\n";
    assert(test_add_id == 5.0);

    // Prove Multiplicative Identity = 0 in Shifted Coordinates
    double mul_id = ShiftedAlgebra::multiplicative_identity();
    double test_mul_id = ShiftedAlgebra::multiply(u, mul_id);
    std::cout << "Multiplicative Identity Check: 5 (*) 0 = " << test_mul_id << " (Expected: 5)\n";
    assert(test_mul_id == 5.0);

    // ------------------------------------------------------------------
    // TEST 3: ZERO-CROSSING STATE RETENTION (q = 0 => S != null)
    // ------------------------------------------------------------------
    print_banner("TEST 3: Non-Null Zero-Crossing State Retention Verification");

Verbatim source SRC 05

main_test.cpp | QZL-SRC-20261010-01 | Lines 88 to 116

    StateTuple& r1 = kernel.get_register(1);
    r1.identity_id = 101; // Specific object identity
    r1.q = 0.0;           // Coordinate at origin baseline (x = 1)
    r1.t = 10;
    r1.is_active = true;

    std::cout << "Register R1 State: Identity=" << r1.identity_id 
              << ", q=" << r1.q << ", t=" << r1.t 
              << ", Active=" << (r1.is_active ? "TRUE" : "FALSE") << "\n";
    std::cout << "Is Null Check: " << (r1.is_null() ? "NULL (FAIL)" : "NON-NULL (PASS)") << "\n";
    assert(!r1.is_null());

    // ------------------------------------------------------------------
    // TEST 4: END-TO-END COMPILER, ASSEMBLER & KERNEL PIPELINE
    // ------------------------------------------------------------------
    print_banner("TEST 4: High-Level Compiler -> Assembly -> Bytecode -> Kernel Execution");

    std::string high_level_code = R"(
        # High-Level QZL Computation
        ADD R1 R2 R3
        MULTIPLY R2 R1 R3
        FLIP R3 R2
        SAVE R3 M1
        RESTORE R4 M1
        VERIFY R4
        VERIFY R1
    )";

    std::cout << "1. Compiling High-Level Code to Assembly...\n";

Verbatim source SRC 05

main_test.cpp | QZL-SRC-20261010-01 | Lines 117 to 145

    std::string compiled_asm = Compiler::compile_to_assembly(high_level_code);
    std::cout << "--- Generated Assembly ---\n" << compiled_asm << "--------------------------\n";

    std::cout << "2. Assembling to Bytecode Instructions...\n";
    std::vector<Instruction> bytecode = Assembler::assemble(compiled_asm);
    std::cout << "Generated " << bytecode.size() << " machine bytecode instructions.\n";

    std::cout << "3. Executing Bytecode on QZL Relational Kernel...\n";
    // Setup initial state in registers
    kernel.get_register(2).q = 4.0; // u = 4
    kernel.get_register(2).identity_id = 2001;

    kernel.get_register(3).q = 2.0; // v = 2
    kernel.get_register(3).identity_id = 2002;

    for (const auto& instr : bytecode) {
        kernel.execute(instr);
    }

    StateTuple& r1_final = kernel.get_register(1);
    StateTuple& r4_final = kernel.get_register(4);

    std::cout << "R1 Final State: q=" << r1_final.q << " (Expected 4 (+) 2 = 7), Identity=" << r1_final.identity_id << "\n";
    assert(r1_final.q == 7.0);

    std::cout << "R4 Final State (Restored from M1): q=" << r4_final.q << " (Expected -(7 (*) 2) = -23)\n";
    assert(r4_final.q == -23.0);

    // ------------------------------------------------------------------

Verbatim source SRC 05

main_test.cpp | QZL-SRC-20261010-01 | Lines 146 to 174

    // TEST 5: HIGH-SPEED TRUTH TABLE & STATE LOGIC BENCHMARK
    // ------------------------------------------------------------------
    print_banner("TEST 5: Truth Table Logic & Localized Compute Power Benchmark");

    constexpr size_t NUM_OPERATIONS = 100000;
    std::cout << "Executing " << NUM_OPERATIONS << " localized truth table state operations...\n";

    auto start_time = std::chrono::high_resolution_clock::now();

    for (size_t i = 1; i <= NUM_OPERATIONS; ++i) {
        Instruction add_inst{Opcode::ADD_SHIFTED, 1, 1, 2, 0.0};
        Instruction eval_inst{Opcode::STATE_EVAL, 0, 1, 0, 0.0};
        kernel.execute(add_inst);
        kernel.execute(eval_inst);
    }

    auto end_time = std::chrono::high_resolution_clock::now();
    double duration_ms = std::chrono::duration<double, std::milli>(end_time - start_time).count();

    std::cout << "Completed " << NUM_OPERATIONS * 2 << " kernel state operations in " 
              << std::fixed << std::setprecision(2) << duration_ms << " ms.\n";
    std::cout << "Throughput: " << std::fixed << std::setprecision(0) 
              << ((NUM_OPERATIONS * 2) / (duration_ms / 1000.0)) << " state ops/sec.\n";
    std::cout << "Identity Preservation Count: " << kernel.get_identity_preservations() << "\n";
    std::cout << "Null State Violations: 0\n";

    print_banner("ALL TEST SUITES PASSED SUCCESSFULLY!");
    return 0;
}

Verbatim source SRC 06

qzl-system-engine-v3.py | QZL-SRC-20261010-01 | Lines 1 to 33

#!/usr/bin/env python3
"""
QZL NATIVE C/C++ ARCHITECTURE IMPLEMENTATION & TEST ENGINE
Baseline Origin: o = 1 (No 0x / 0-origin mapping in system)
"""

import sys
import time
import ctypes
from typing import List, Dict, Tuple

BASELINE_ORIGIN = 1  # Baseline origin corner is 1

class Orientation3D(ctypes.Structure):
    _fields_ = [
        ("ex", ctypes.c_int8),
        ("ey", ctypes.c_int8),
        ("ez", ctypes.c_int8)
    ]

class ObserverFrame(ctypes.Structure):
    _fields_ = [
        ("frame_id", ctypes.c_uint64),
        ("origin_anchor", ctypes.c_int64),
        ("orientation", Orientation3D)
    ]

    def to_coordinate(self, x: float) -> float:
        return self.orientation.ex * (x - self.origin_anchor)

    def transform_to(self, q_O: float, O_prime: 'ObserverFrame') -> float:
        return O_prime.orientation.ex * self.orientation.ex * q_O + O_prime.orientation.ex * (self.origin_anchor - O_prime.origin_anchor)

Verbatim source SRC 06

qzl-system-engine-v3.py | QZL-SRC-20261010-01 | Lines 34 to 66

class StateTuple(ctypes.Structure):
    _fields_ = [
        ("identity_id", ctypes.c_uint64),
        ("frame", ObserverFrame),
        ("q", ctypes.c_double),
        ("t", ctypes.c_uint64),
        ("is_active", ctypes.c_bool)
    ]

    def is_null(self) -> bool:
        return (not self.is_active) or (self.identity_id == 0)

class ShiftedAlgebra:
    @staticmethod
    def add(u: float, v: float) -> float:
        # u (+) v = u + v + 1
        return u + v + 1.0

    @staticmethod
    def multiply(u: float, v: float) -> float:
        # u (*) v = u*v + u + v
        return u * v + u + v

    @staticmethod
    def additive_identity() -> float:
        # u (+) (-1) = u + (-1) + 1 = u
        return -1.0

    @staticmethod
    def multiplicative_identity() -> float:
        # u (*) 0 = u*0 + u + 0 = u (corresponds to physical origin x = 1)
        return 0.0

Verbatim source SRC 06

qzl-system-engine-v3.py | QZL-SRC-20261010-01 | Lines 67 to 99

    @staticmethod
    def orientation_involution(q: float) -> float:
        return -q

class Instruction(ctypes.Structure):
    _fields_ = [
        ("op", ctypes.c_uint8),      # Opcode: 1=ADD, 2=MUL, 3=JINV, 4=TRANSFORM, 5=STORE, 6=LOAD, 7=EVAL
        ("dest_reg", ctypes.c_uint32),# 1-based register (R1, R2...)
        ("src1_reg", ctypes.c_uint32),
        ("src2_reg", ctypes.c_uint32),
        ("immediate", ctypes.c_double)
    ]

class Kernel:
    def __init__(self, num_registers: int = 16):
        # Indexing starts strictly at 1. Index 0 is prohibited!
        self.num_registers = num_registers
        self.registers: Dict[int, StateTuple] = {}
        self.memory: Dict[int, StateTuple] = {}
        self.current_time = 1
        self.total_zero_crossings = 0
        self.identity_preservations = 0

        for i in range(1, num_registers + 1):
            st = StateTuple()
            st.identity_id = i
            st.frame.frame_id = 1
            st.frame.origin_anchor = BASELINE_ORIGIN
            st.frame.orientation.ex = 1
            st.frame.orientation.ey = 1
            st.frame.orientation.ez = 1
            st.q = 0.0
            st.t = 1

Verbatim source SRC 06

qzl-system-engine-v3.py | QZL-SRC-20261010-01 | Lines 100 to 132

            st.is_active = True
            self.registers[i] = st

    def get_register(self, reg_id: int) -> StateTuple:
        if reg_id == 0:
            raise ValueError("ERROR: Invalid 0x/0-mapping attempt! QZL architecture prohibits register R0. All registers start at R1.")
        if reg_id not in self.registers:
            raise KeyError(f"Register R{reg_id} out of bounds.")
        return self.registers[reg_id]

    def store_memory(self, slot_id: int, state: StateTuple):
        if slot_id == 0:
            raise ValueError("ERROR: Invalid 0x/0-mapping attempt! QZL architecture prohibits memory slot M0. All slots start at M1.")
        st = StateTuple()
        st.identity_id = state.identity_id
        st.frame = state.frame
        st.q = state.q
        st.t = state.t
        st.is_active = state.is_active
        self.memory[slot_id] = st

    def load_memory(self, slot_id: int) -> StateTuple:
        if slot_id == 0:
            raise ValueError("ERROR: Invalid 0x/0-mapping attempt! Memory slot M0 does not exist.")
        if slot_id not in self.memory:
            st = StateTuple()
            st.identity_id = slot_id
            st.frame.frame_id = 1
            st.frame.origin_anchor = BASELINE_ORIGIN
            st.frame.orientation.ex = 1
            st.q = 0.0
            st.t = self.current_time
            st.is_active = True

Verbatim source SRC 06

qzl-system-engine-v3.py | QZL-SRC-20261010-01 | Lines 133 to 165

            return st
        return self.memory[slot_id]

    def execute(self, instr: Instruction):
        self.current_time += 1
        op = instr.op

        if op == 1: # ADD_SHIFTED: u (+) v = u + v + 1
            dest = self.get_register(instr.dest_reg)
            src1 = self.get_register(instr.src1_reg)
            src2 = self.get_register(instr.src2_reg)
            dest.q = ShiftedAlgebra.add(src1.q, src2.q)
            dest.identity_id = src1.identity_id
            dest.t = self.current_time
            dest.is_active = True

        elif op == 2: # MUL_SHIFTED: u (*) v = uv + u + v
            dest = self.get_register(instr.dest_reg)
            src1 = self.get_register(instr.src1_reg)
            src2 = self.get_register(instr.src2_reg)
            dest.q = ShiftedAlgebra.multiply(src1.q, src2.q)
            dest.identity_id = src1.identity_id
            dest.t = self.current_time
            dest.is_active = True

        elif op == 3: # J_INV: J(q) = -q
            dest = self.get_register(instr.dest_reg)
            src = self.get_register(instr.src1_reg)
            dest.q = ShiftedAlgebra.orientation_involution(src.q)
            dest.frame.orientation.ex = -src.frame.orientation.ex
            dest.identity_id = src.identity_id
            dest.t = self.current_time
            dest.is_active = True

Verbatim source SRC 06

qzl-system-engine-v3.py | QZL-SRC-20261010-01 | Lines 166 to 198


        elif op == 5: # STORE_MEM
            src = self.get_register(instr.src1_reg)
            self.store_memory(int(instr.immediate), src)

        elif op == 6: # LOAD_MEM
            dest = self.get_register(instr.dest_reg)
            loaded = self.load_memory(int(instr.immediate))
            dest.identity_id = loaded.identity_id
            dest.frame = loaded.frame
            dest.q = loaded.q
            dest.t = self.current_time
            dest.is_active = True

        elif op == 7: # STATE_EVAL
            src = self.get_register(instr.src1_reg)
            if src.q == 0.0:
                self.total_zero_crossings += 1
            if not src.is_null():
                self.identity_preservations += 1

class Assembler:
    @staticmethod
    def parse_register(token: str) -> int:
        token = token.strip()
        if not token or token[0].upper() != 'R':
            raise ValueError(f"Assembler Error: Register must start with 'R' (e.g. R1, R2). Token: {token}")
        reg_id = int(token[1:])
        if reg_id == 0:
            raise ValueError("Assembler Error: R0 or 0x mapping is PROHIBITED. All registers start at R1.")
        return reg_id

    @staticmethod

Verbatim source SRC 06

qzl-system-engine-v3.py | QZL-SRC-20261010-01 | Lines 199 to 231

    def parse_memory(token: str) -> int:
        token = token.strip()
        if not token or token[0].upper() != 'M':
            raise ValueError(f"Assembler Error: Memory slot must start with 'M' (e.g. M1, M2). Token: {token}")
        slot_id = int(token[1:])
        if slot_id == 0:
            raise ValueError("Assembler Error: M0 or 0x mapping is PROHIBITED. All memory slots start at M1.")
        return slot_id

    @classmethod
    def assemble(cls, source_code: str) -> List[Instruction]:
        instructions = []
        lines = source_code.strip().split('\n')
        for line in lines:
            line = line.strip()
            if not line or line.startswith(';') or line.startswith('#'):
                continue
            tokens = line.split()
            op_str = tokens[0].upper()

            instr = Instruction()
            if op_str == "ADD":
                instr.op = 1
                instr.dest_reg = cls.parse_register(tokens[1])
                instr.src1_reg = cls.parse_register(tokens[2])
                instr.src2_reg = cls.parse_register(tokens[3])
            elif op_str in ("MUL", "MULTIPLY"):
                instr.op = 2
                instr.dest_reg = cls.parse_register(tokens[1])
                instr.src1_reg = cls.parse_register(tokens[2])
                instr.src2_reg = cls.parse_register(tokens[3])
            elif op_str in ("JINV", "FLIP", "INVERT"):
                instr.op = 3

Verbatim source SRC 06

qzl-system-engine-v3.py | QZL-SRC-20261010-01 | Lines 232 to 264

                instr.dest_reg = cls.parse_register(tokens[1])
                instr.src1_reg = cls.parse_register(tokens[2])
            elif op_str in ("STORE", "SAVE"):
                instr.op = 5
                instr.src1_reg = cls.parse_register(tokens[1])
                instr.immediate = float(cls.parse_memory(tokens[2]))
            elif op_str in ("LOAD", "RESTORE"):
                instr.op = 6
                instr.dest_reg = cls.parse_register(tokens[1])
                instr.immediate = float(cls.parse_memory(tokens[2]))
            elif op_str in ("EVAL", "VERIFY"):
                instr.op = 7
                instr.src1_reg = cls.parse_register(tokens[1])
            else:
                raise ValueError(f"Assembler Error: Unknown opcode '{op_str}'")

            instructions.append(instr)
        return instructions

class Compiler:
    @staticmethod
    def compile_to_assembly(high_level_source: str) -> str:
        asm_lines = []
        lines = high_level_source.strip().split('\n')
        for line in lines:
            line = line.strip()
            if not line or line.startswith('#'):
                continue
            tokens = line.split()
            kw = tokens[0].upper()

            if kw in ("ADD", "MULTIPLY", "MUL", "FLIP", "INVERT", "SAVE", "STORE", "RESTORE", "LOAD", "VERIFY", "EVAL"):
                asm_lines.append(line)

Verbatim source SRC 06

qzl-system-engine-v3.py | QZL-SRC-20261010-01 | Lines 265 to 297

            else:
                raise ValueError(f"Compiler Error: High-level syntax unrecognized: '{line}'")
        return "\n".join(asm_lines)

    @classmethod
    def compile(cls, high_level_source: str) -> List[Instruction]:
        asm_code = cls.compile_to_assembly(high_level_source)
        return Assembler.assemble(asm_code)

def print_banner(title: str):
    print("\n" + "="*70)
    print(f"  {title}")
    print("="*70)

def main():
    print_banner("QZL NATIVE ARCHITECTURE SUITE: COMPILER, ASSEMBLER & KERNEL")
    print("Origin Baseline: o = 1 (No 0x / 0-origin mapping in system)")

    # ------------------------------------------------------------------
    # TEST 1: STRICT 1-BASED ORIGIN & NO-0x MAPPING REJECTION
    # ------------------------------------------------------------------
    print_banner("TEST 1: 1-Based Origin & 0x Mapping Rejection Verification")
    kernel = Kernel(16)

    try:
        kernel.get_register(0)
        assert False, "FAILED: Should have rejected register 0!"
    except ValueError as e:
        print(f"[PASSED] Correctly rejected register 0 access: {e}")

    try:
        kernel.store_memory(0, StateTuple())
        assert False, "FAILED: Should have rejected memory slot 0!"

Verbatim source SRC 06

qzl-system-engine-v3.py | QZL-SRC-20261010-01 | Lines 298 to 330

    except ValueError as e:
        print(f"[PASSED] Correctly rejected memory slot 0 access: {e}")

    try:
        Assembler.parse_register("R0")
        assert False, "FAILED: Should have rejected R0!"
    except ValueError as e:
        print(f"[PASSED] Assembler correctly rejected R0: {e}")

    # ------------------------------------------------------------------
    # TEST 2: SHIFTED COORDINATE ALGEBRA & NATIVE IDENTITIES (o = 1)
    # ------------------------------------------------------------------
    print_banner("TEST 2: Shifted Algebra & Native Identity Verification (o = 1)")
    u, v = 5.0, 3.0

    add_res = ShiftedAlgebra.add(u, v) # 5 + 3 + 1 = 9
    mul_res = ShiftedAlgebra.multiply(u, v) # 5*3 + 5 + 3 = 23

    print(f"Shifted Addition (5 (+) 3) = {add_res} (Expected: 9.0)")
    assert add_res == 9.0

    print(f"Shifted Multiplication (5 (*) 3) = {mul_res} (Expected: 23.0)")
    assert mul_res == 23.0

    # Additive Identity Check (-1)
    add_id = ShiftedAlgebra.additive_identity()
    test_add_id = ShiftedAlgebra.add(u, add_id)
    print(f"Additive Identity Check: 5 (+) (-1) = {test_add_id} (Expected: 5.0)")
    assert test_add_id == 5.0

    # Multiplicative Identity Check (0)
    mul_id = ShiftedAlgebra.multiplicative_identity()
    test_mul_id = ShiftedAlgebra.multiply(u, mul_id)

Verbatim source SRC 06

qzl-system-engine-v3.py | QZL-SRC-20261010-01 | Lines 331 to 363

    print(f"Multiplicative Identity Check: 5 (*) 0 = {test_mul_id} (Expected: 5.0)")
    assert test_mul_id == 5.0

    # ------------------------------------------------------------------
    # TEST 3: ZERO-CROSSING STATE RETENTION (q = 0 => S != null)
    # ------------------------------------------------------------------
    print_banner("TEST 3: Non-Null Zero-Crossing State Retention Verification")
    r1 = kernel.get_register(1)
    r1.identity_id = 101
    r1.q = 0.0
    r1.t = 10
    r1.is_active = True

    print(f"Register R1 State: Identity={r1.identity_id}, q={r1.q}, t={r1.t}, Active={r1.is_active}")
    print(f"Is Null Check: {'NULL (FAIL)' if r1.is_null() else 'NON-NULL (PASS)'}")
    assert not r1.is_null()

    # ------------------------------------------------------------------
    # TEST 4: END-TO-END COMPILER, ASSEMBLER & KERNEL PIPELINE
    # ------------------------------------------------------------------
    print_banner("TEST 4: High-Level Compiler -> Assembly -> Bytecode -> Kernel Execution")

    high_level_code = """
        # High-Level QZL Program
        ADD R1 R2 R3
        MULTIPLY R2 R1 R3
        FLIP R3 R2
        SAVE R3 M1
        RESTORE R4 M1
        VERIFY R4
        VERIFY R1
    """

Verbatim source SRC 06

qzl-system-engine-v3.py | QZL-SRC-20261010-01 | Lines 364 to 396

    print("1. Compiling High-Level Code to Assembly...")
    compiled_asm = Compiler.compile_to_assembly(high_level_code)
    print("--- Generated Assembly ---")
    print(compiled_asm)
    print("--------------------------")

    print("2. Assembling to Bytecode Instructions...")
    bytecode = Assembler.assemble(compiled_asm)
    print(f"Generated {len(bytecode)} machine bytecode instructions.")

    print("3. Executing Bytecode on QZL Relational Kernel...")
    kernel.get_register(2).q = 4.0 # u = 4
    kernel.get_register(2).identity_id = 2001

    kernel.get_register(3).q = 2.0 # v = 2
    kernel.get_register(3).identity_id = 2002

    for instr in bytecode:
        kernel.execute(instr)

    r1_final = kernel.get_register(1)
    r4_final = kernel.get_register(4)

    print(f"R1 Final State: q={r1_final.q} (Expected 4 (+) 2 = 7.0), Identity={r1_final.identity_id}")
    assert r1_final.q == 7.0

    print(f"R4 Final State (Restored from M1): q={r4_final.q} (Expected -(7 (*) 2) = -23.0)")
    assert r4_final.q == -23.0

    # ------------------------------------------------------------------
    # TEST 5: HIGH-SPEED TRUTH TABLE & STATE LOGIC BENCHMARK
    # ------------------------------------------------------------------
    print_banner("TEST 5: Truth Table Logic & Localized Compute Power Benchmark")

Verbatim source SRC 06

qzl-system-engine-v3.py | QZL-SRC-20261010-01 | Lines 397 to 430


    NUM_OPERATIONS = 100000
    print(f"Executing {NUM_OPERATIONS} localized truth table state operations...")

    start_time = time.time()

    add_inst = Instruction()
    add_inst.op = 1
    add_inst.dest_reg = 1
    add_inst.src1_reg = 1
    add_inst.src2_reg = 2

    eval_inst = Instruction()
    eval_inst.op = 7
    eval_inst.src1_reg = 1

    for _ in range(NUM_OPERATIONS):
        kernel.execute(add_inst)
        kernel.execute(eval_inst)

    end_time = time.time()
    duration = end_time - start_time

    ops_per_sec = (NUM_OPERATIONS * 2) / duration if duration > 0 else 0

    print(f"Completed {NUM_OPERATIONS * 2} kernel state operations in {duration*1000:.2f} ms.")
    print(f"Throughput: {ops_per_sec:,.0f} state ops/sec.")
    print(f"Identity Preservation Count: {kernel.identity_preservations:,}")
    print("Null State Violations: 0")

    print_banner("ALL TEST SUITES PASSED SUCCESSFULLY!")

if __name__ == "__main__":
    main()

Verbatim source SRC 07

quantum-state-register-128.v | QZL-SRC-20261010-01 | Lines 1 to 25

// ============================================================================
// Module: quantum_state_register_128
// Description: Synthesizable 128-bit State Register & ALU Logic for S = (I, O, q, t)
//              Enforces Non-Null Conservation Axiom (q = 0 => S != null)
// Author: Gemini Notebook - Quantum Mechanics Compute Process
// ============================================================================

`timescale 1ns / 1ps

module quantum_state_register_128 (
    input  wire        clk,
    input  wire        rst_n,
    input  wire [127:0] in_sreg,      // [127:96]=I, [95:64]=O, [63:32]=q, [31:0]=t
    input  wire [31:0]  in_operand_q, // Operation operand for coordinate
    input  wire [1:0]   op_code,      // 2'b00: ADD, 2'b01: SUB, 2'b10: J_INV (Flip Orientation), 2'b11: SHIFT_ADD
    output reg  [127:0] out_sreg,     // Updated state register
    output wire        align_flag,   // Asserted when q == 0 (Node Alignment)
    output wire        null_trap     // STRICTLY 0 (Suppresses CPU Null Trap)
);

    // Unpack fields from input state register
    wire [31:0] in_I = in_sreg[127:96];
    wire [15:0] in_O_id = in_sreg[95:80];
    wire [15:0] in_O_eps = in_sreg[79:64]; // Orientation vector bits
    wire signed [31:0] in_q = in_sreg[63:32];

Verbatim source SRC 07

quantum-state-register-128.v | QZL-SRC-20261010-01 | Lines 26 to 50

    wire [31:0] in_t = in_sreg[31:0];

    // Internal calculation registers
    reg signed [31:0] next_q;
    reg [15:0] next_eps;

    always @(*) begin
        case (op_code)
            2'b00: begin // ADD: Direct coordinate addition
                next_q   = in_q + in_operand_q;
                next_eps = in_O_eps;
            end
            2'b01: begin // SUB: Direct coordinate subtraction
                next_q   = in_q - in_operand_q;
                next_eps = in_O_eps;
            end
            2'b10: begin // J_INV: Orientation Involution J(q) = -q
                next_q   = -in_q;
                next_eps = ~in_O_eps; // Invert orientation vector
            end
            2'b11: begin // SHIFT_ADD (u (+) v = u + v + 1)
                next_q   = in_q + in_operand_q + 32'sd1;
                next_eps = in_O_eps;
            end
            default: begin

Verbatim source SRC 07

quantum-state-register-128.v | QZL-SRC-20261010-01 | Lines 51 to 76

                next_q   = in_q;
                next_eps = in_O_eps;
            end
        endcase
    end

    // Sequential Register Update
    always @(posedge clk or negedge rst_n) begin
        if (!rst_n) begin
            out_sreg <= 128'b0;
        end else begin
            // Preserve Identity (I) and Frame ID unconditionally!
            out_sreg[127:96] <= in_I;
            out_sreg[95:80]  <= in_O_id;
            out_sreg[79:64]  <= next_eps;
            out_sreg[63:32]  <= next_q;
            out_sreg[31:0]   <= in_t + 32'd1; // Monotonic timestamp increment
        end
    end

    // Non-Null Conservation Gate Logic
    // Assert ALIGN_FLAG when coordinate reaches zero, BUT keep null_trap = 0
    assign align_flag = (next_q == 32'sd0);
    assign null_trap  = 1'b0; // Explicitly prevents NULL hardware exception

endmodule

Verbatim source SRC 08

quantum-state-register-128 (1).v | QZL-SRC-20261010-01 | Lines 1 to 25

// ============================================================================
// Module: quantum_state_register_128
// Description: Synthesizable 128-bit State Register & ALU Logic for S = (I, O, q, t)
//              Enforces Non-Null Conservation Axiom (q = 0 => S != null)
// Author: Gemini Notebook - Quantum Mechanics Compute Process
// ============================================================================

`timescale 1ns / 1ps

module quantum_state_register_128 (
    input  wire        clk,
    input  wire        rst_n,
    input  wire [127:0] in_sreg,      // [127:96]=I, [95:64]=O, [63:32]=q, [31:0]=t
    input  wire [31:0]  in_operand_q, // Operation operand for coordinate
    input  wire [1:0]   op_code,      // 2'b00: ADD, 2'b01: SUB, 2'b10: J_INV (Flip Orientation), 2'b11: SHIFT_ADD
    output reg  [127:0] out_sreg,     // Updated state register
    output wire        align_flag,   // Asserted when q == 0 (Node Alignment)
    output wire        null_trap     // STRICTLY 0 (Suppresses CPU Null Trap)
);

    // Unpack fields from input state register
    wire [31:0] in_I = in_sreg[127:96];
    wire [15:0] in_O_id = in_sreg[95:80];
    wire [15:0] in_O_eps = in_sreg[79:64]; // Orientation vector bits
    wire signed [31:0] in_q = in_sreg[63:32];

Verbatim source SRC 08

quantum-state-register-128 (1).v | QZL-SRC-20261010-01 | Lines 26 to 50

    wire [31:0] in_t = in_sreg[31:0];

    // Internal calculation registers
    reg signed [31:0] next_q;
    reg [15:0] next_eps;

    always @(*) begin
        case (op_code)
            2'b00: begin // ADD: Direct coordinate addition
                next_q   = in_q + in_operand_q;
                next_eps = in_O_eps;
            end
            2'b01: begin // SUB: Direct coordinate subtraction
                next_q   = in_q - in_operand_q;
                next_eps = in_O_eps;
            end
            2'b10: begin // J_INV: Orientation Involution J(q) = -q
                next_q   = -in_q;
                next_eps = ~in_O_eps; // Invert orientation vector
            end
            2'b11: begin // SHIFT_ADD (u (+) v = u + v + 1)
                next_q   = in_q + in_operand_q + 32'sd1;
                next_eps = in_O_eps;
            end
            default: begin

Verbatim source SRC 08

quantum-state-register-128 (1).v | QZL-SRC-20261010-01 | Lines 51 to 76

                next_q   = in_q;
                next_eps = in_O_eps;
            end
        endcase
    end

    // Sequential Register Update
    always @(posedge clk or negedge rst_n) begin
        if (!rst_n) begin
            out_sreg <= 128'b0;
        end else begin
            // Preserve Identity (I) and Frame ID unconditionally!
            out_sreg[127:96] <= in_I;
            out_sreg[95:80]  <= in_O_id;
            out_sreg[79:64]  <= next_eps;
            out_sreg[63:32]  <= next_q;
            out_sreg[31:0]   <= in_t + 32'd1; // Monotonic timestamp increment
        end
    end

    // Non-Null Conservation Gate Logic
    // Assert ALIGN_FLAG when coordinate reaches zero, BUT keep null_trap = 0
    assign align_flag = (next_q == 32'sd0);
    assign null_trap  = 1'b0; // Explicitly prevents NULL hardware exception

endmodule

© 2026 Aboudy Keddeh  |  Keddeh Systems  |  All rights reserved

KEDDEH-RES-OBSERVER-ORIGIN-001  |  v2.9  |  Internal research  |  Draft  |  Page  of 

KEDDEH SYSTEMS | RESEARCH AND FORMAL PUBLISHING
ENGINEER · AUTOMATE · SCALE

Appendix B Verification programs and evidence

Verification record QZL-VERIFY-20261010-02 contains the exact programs, commands, output transcripts and generated netlists. The methods and confirmed results appear in the main paper. The following programs are preserved verbatim; embedded evidence parts retain their exact bytes and hashes.

© 2026 Aboudy Keddeh  |  Keddeh Systems  |  All rights reserved

KEDDEH-RES-OBSERVER-ORIGIN-001  |  v2.9  |  Internal research  |  Draft  |  Page  of 

KEDDEH SYSTEMS | RESEARCH AND FORMAL PUBLISHING
ENGINEER · AUTOMATE · SCALE

Verification program register_tb.v

QZL-VERIFY-20261010-02 | Lines 1 to 22 | AI authored harness

`timescale 1ns/1ps
module register_tb;
 reg clk=0,rst_n=1;
 reg [127:0] in_sreg=0;reg [31:0] in_operand_q=0;reg [1:0] op_code=0;
 wire [127:0] out_sreg;wire align_flag,null_trap;
 quantum_state_register_128 dut(clk,rst_n,in_sreg,in_operand_q,op_code,out_sreg,align_flag,null_trap);
 integer vectors=0,checks=0,i,j;integer seed=297;reg [31:0] expected_q;reg [15:0] expected_eps;reg [127:0] expected,previous;
 task check;
 input condition;input [255:0] label;
 begin checks=checks+1;if(condition!==1'b1)begin $display("FAIL %s vector=%0d",label,vectors);$fatal(1);end end
 endtask
 task run;
 input [31:0] identity;input [15:0] frame,eps;input [31:0] q,t,operand;input [1:0] op;
 begin
  previous=out_sreg;in_sreg={identity,frame,eps,q,t};in_operand_q=operand;op_code=op;
  case(op)
   0:begin expected_q=q+operand;expected_eps=eps;end
   1:begin expected_q=q-operand;expected_eps=eps;end
   2:begin expected_q=-q;expected_eps=~eps;end
   3:begin expected_q=q+operand+32'd1;expected_eps=eps;end
  endcase
  expected={identity,frame,expected_eps,expected_q,(t+32'd1)};

Verification program register_tb.v

QZL-VERIFY-20261010-02 | Lines 23 to 45 | AI authored harness

  #2;check(out_sreg===previous,"hold before edge");check(align_flag===(expected_q==0),"combinational alignment");check(null_trap===0,"trap tied low");
  clk=1;#2;check(out_sreg===expected,"full tuple clock update");check(out_sreg[127:96]===identity,"identity retained");check(out_sreg[95:80]===frame,"frame retained");clk=0;#2;vectors=vectors+1;
 end
 endtask
 initial begin
  #1;rst_n=0;#2;check(out_sreg===128'b0,"asynchronous reset clears");rst_n=1;#2;
  run(91,7,16'h1234,0,1,0,0);
  run(91,7,16'h1234,9,1,9,1);
  run(91,7,16'h1234,32'hffffffff,1,0,3);
  run(91,7,16'h1234,0,1,0,2);
  run(91,7,16'h1234,32'h7fffffff,32'hffffffff,1,0);
  check(out_sreg[63:32]===32'h80000000,"coordinate overflow wraps");check(out_sreg[31:0]===0,"time overflow wraps");
  run(91,7,16'h1234,32'h80000000,5,0,2);
  check(out_sreg[63:32]===32'h80000000,"minimum signed negation wraps");
  run(0,0,0,0,10,0,0);check(out_sreg[127:96]===0,"zero identity admitted");
  run(91,7,1,1,10,0,0);run(91,7,1,1,10,0,0);check(out_sreg[31:0]===11,"repeated input time not accumulated");
  previous=out_sreg;in_sreg[63:32]=32'hffffffff;in_operand_q=0;op_code=3;#2;
  check(align_flag===1,"flag follows pending zero");check(out_sreg===previous,"flag precedes output update");
  rst_n=0;#2;check(out_sreg===0,"reset clears valid tuple");rst_n=1;#2;
  for(i=0;i<1024;i=i+1)for(j=0;j<4;j=j+1)run($random(seed),$random(seed),$random(seed),$random(seed),$random(seed),$random(seed),j);
  $display("PASS vectors=%0d assertions=%0d initial_seed=297",vectors,checks);$finish;
 end
endmodule

Verification program formal.v

QZL-VERIFY-20261010-02 | Lines 1 to 14 | AI authored harness

module formal_top(input clk,input rst_n,input [127:0] in_sreg,input [31:0] in_operand_q,input [1:0] op_code);
 wire [127:0] out_sreg;wire align_flag,null_trap;
 quantum_state_register_128 dut(clk,rst_n,in_sreg,in_operand_q,op_code,out_sreg,align_flag,null_trap);
 reg past_valid=0;
 always @(posedge clk) begin
  past_valid<=1;
  assert(null_trap==0);
  if(past_valid && rst_n && $past(rst_n))begin
   assert(out_sreg[127:96]==$past(in_sreg[127:96]));
   assert(out_sreg[95:80]==$past(in_sreg[95:80]));
   assert(out_sreg[31:0]==($past(in_sreg[31:0])+32'd1));
  end
 end
endmodule

Verification program properties.cpp

QZL-VERIFY-20261010-02 | Lines 1 to 8 | AI authored harness

#include "qzl_types.hpp"
#include <cassert>
#include <iostream>
using namespace QZL;
int main(){int n=0;for(int u=-10;u<=10;++u)for(int v=-10;v<=10;++v){assert(ShiftedAlgebra::add(u,v)==(u+1)+(v+1)-1);assert(ShiftedAlgebra::multiply(u,v)==(u+1)*(v+1)-1);assert(ShiftedAlgebra::add(u,-1)==u);assert(ShiftedAlgebra::multiply(u,0)==u);assert(ShiftedAlgebra::orientation_involution(ShiftedAlgebra::orientation_involution(u))==u);n+=5;}
 for(int e:{-1,1})for(int f:{-1,1})for(int a=-3;a<=3;++a)for(int b=-3;b<=3;++b)for(int x=-10;x<=10;++x){ObserverFrame A,B;A.orientation.ex=e;B.orientation.ex=f;A.origin_anchor=a;B.origin_anchor=b;double q=A.to_coordinate(x),r=A.transform_to(q,B);assert(r==B.to_coordinate(x));assert(B.transform_to(r,A)==q);n+=2;}
 std::cout<<"PASS cpp algebra_and_frame assertions="<<n<<"\n";
}

Verification program properties.py

QZL-VERIFY-20261010-02 | Lines 1 to 22 | AI authored harness

import importlib.util
s=importlib.util.spec_from_file_location('qzl','upload/qzl-system-engine-v3.py');m=importlib.util.module_from_spec(s);s.loader.exec_module(m)
n=0
for u in range(-10,11):
 for v in range(-10,11):
  assert m.ShiftedAlgebra.add(u,v)==(u+1)+(v+1)-1
  assert m.ShiftedAlgebra.multiply(u,v)==(u+1)*(v+1)-1
  assert m.ShiftedAlgebra.add(u,-1)==u
  assert m.ShiftedAlgebra.multiply(u,0)==u
  assert m.ShiftedAlgebra.orientation_involution(m.ShiftedAlgebra.orientation_involution(u))==u
  n+=5
for e in (-1,1):
 for f in (-1,1):
  for a in range(-3,4):
   for b in range(-3,4):
    for x in range(-10,11):
     A=m.ObserverFrame();B=m.ObserverFrame();A.orientation.ex=e;B.orientation.ex=f;A.origin_anchor=a;B.origin_anchor=b
     q=A.to_coordinate(x);r=A.transform_to(q,B)
     assert r==B.to_coordinate(x)
     assert B.transform_to(r,A)==q
     n+=2
print(f'PASS python algebra_and_frame assertions={n}')

© 2026 Aboudy Keddeh  |  Keddeh Systems  |  All rights reserved

KEDDEH-RES-OBSERVER-ORIGIN-001  |  v2.9  |  Internal research  |  Draft  |  Page  of 

KEDDEH SYSTEMS | RESEARCH AND FORMAL PUBLISHING
ENGINEER · AUTOMATE · SCALE

Appendix C Editorial assessment and correction history

The following records preserve the assessment process, withdrawn comparisons, acquisition history and recorded corrections from prior editions. They are historical editorial evidence, not the authorial voice of the paper. Prior pending statuses are dated historical records; current results govern the corresponding verified implementation. Quotations and identifiers are retained without endorsing superseded interpretations.

Failure invariant and assessment correction

FI 01 Source identity broken by operator substitution

One shared origin U=1; the operator admitted as multiplication on this line preserves U as its multiplicative identity. Repeated axis references must resolve to the same origin, not separately created origins.

Source: Foundations of measurement, revision 2, A2 and section 9. The shared unit and multiplicative identity are explicit in this author source.

Failure witness: the assessor construction sets rho(1)=0 and rho(2)=1. Transported multiplication consequently gives 1 times 3 = 1 and 2 times 3 = 3. The source multiplicative line requires the origin unit 1 to preserve 3. The unit moved; the source contract failed.

The reconstruction chooses 1 as an additive identity by mapping it to scalar zero. Transported multiplication then makes 1 absorbing and moves its multiplicative unit to 2. This violates the source multiplicative line before associativity or distributivity can establish conformance.

Why passing tests did not resolve it: associativity and distributivity test the constructed operator against itself. They never compare its identity action with the source requirement. Internal mathematical consistency cannot supply the missing conformance mapping.

Singular origin: axis and counterpart references must identify the same origin. A repeated numeral is not, by itself, evidence of duplicated entities; a tuple with repeated components is not, by itself, proof of shared identity. The prior coordinate tests checked invertibility and uniqueness of slots, not the count of origin objects or the fidelity of their references.

Disposition: withdrawn as proof of the source multiplicative line. No assertion is made that the separate transported ring is internally inconsistent. The author-supplied paired expression remains preserved, without a substitute operator.

Required gate: identify the source operation and state roles; verify one origin reference and its identity action; retain signed terms and derivation; then run downstream laws. A failed identity witness blocks conformance promotion. Apply this gate to the assessment itself: these tests detect the assessor’s substitution and do not certify the native replacement.

Related specific failures

FI-02 Signed observer gap replaced by a squared objective. Gamma and negative Gamma yield the same squared value. The MSE experiment erases the distinction the source requires and cannot assess that signed theorem. MSE retained only as an archived comparison, withdrawn as a source theorem test. Source: Primary preprint A4.

FI-03 Existing lineage treated as a proposed repair. The full state record already carries identity, path, rule and proof. Reading the compact MEASURED projection alone cannot establish that the authoritative record omits them. Remove the inferred architectural omission; test an acquired authoritative record before alleging loss. Source: Series Paper 01 equation 3; Zeroless Computational Standard persistence and replay gates; preprint section 9 ledger discussion.

FI-04 Assessor-created model used against an author claim. A shifted Gaussian and a chosen crowding equation do not instantiate a source emergence law. Their outcomes do not falsify the environmental influence claim. Withdraw these findings as source falsification. Source: Current density statement and primary preprint A2.

Revision control: the original v2 calculations remain in the archive. This revision changes their interpretation and promotion status at the relevant passages. Publishing and deployment remain held pending approval.

Workflow and conversion ledger

Each conversion has its own source and target role. C03 is the first unsupported substitution; C05 supplies the identity failure; C08 and C09 promote it into a document and human interface. Reapplying the same definitions and operation reproduces the saved failure witness without inventing another mathematical model.

C01 Drive preprint revision 2 to Acquired text. Provider text extraction and local newline normalization. Location: sources/preprint-current.txt. Gate: Retain edition, source identity and exact source extract hash.

C02 A2 and section 9 text to Operation contract. Interpret shared U=1 and the multiplicative ratio line. Location: preprint A2 and section 9 algebra. Gate: One origin shared across axes; multiplication identity stays 1.

C03 Source operation contract to Assessor displacement model. Select rho(1)=0 and transported integer multiplication. Location: research/v2/test_research.py lines 99–108; workbench model.js nativeToDelta, deltaToNative, algebra. Gate: Do not substitute a different operator and claim source equivalence. Known failure: FI-01.

C04 Origin U=1 to Scalar rho(U)=0. Map an origin unit to the additive displacement identity. Location: rho in test_research.py line 100. Gate: Record changed role and its target type; this is not source multiplication. Known failure: FI-01.

C05 Scalar operands to Scalar product. Multiply rho(a) and rho(b). Location: mul in test_research.py line 102. Gate: Identity action must agree with the source operation. Known failure: FI-01.

C06 Scalar product to Inverse-mapped output. Apply inv; zero maps to 1 and multiplicative scalar unit maps to 2. Location: inv and mul in test_research.py lines 101–102. Gate: A round trip of values does not restore a changed operator contract. Known failure: FI-01.

C07 Constructed operator to Passing algebra tests. Check associativity and distributivity on 9,261 triples. Location: results/audit.json groups.transported_algebra. Gate: Passing the constructed model is not conformance to the source operation. Known failure: FI-01.

C08 Passing comparison receipt to Document claim. Describe the construction as native/source algebra. Location: v2 Scope and definitions; Origin to general algebra. Gate: Preserve the comparison scope at promotion. Known failure: FI-01.

C09 Document interpretation to Interactive calculator. Expose transported algebra as a source-linked tool. Location: workbench app.js algebra; model.js algebra. Gate: Human-facing labels cannot repair a mechanically wrong operator. Known failure: FI-01.

C10 Signed Gamma to Gamma squared and sample-mean MSE. Replace a signed source gap with an unsigned assessor objective. Location: v2 Observer theorem and reference quality; test_research.py observer experiment. Gate: A4 preserves sign; ±Gamma must remain distinguishable. Known failure: FI-02.

C11 Full source state record to Compact MEASURED output. Read a projection in isolation and infer missing lineage. Location: v1 Source conflicts with bounded resolutions; retained v2 foundational text. Gate: Resolve imported record contract before alleging architectural omission. Known failure: FI-03.

C12 Author environmental claim to Shifted Gaussian or chosen crowding equation. Substitute a different proposition and test that proposition. Location: v2 F07, F08 and density cases. Gate: The attempted falsifier must instantiate the source claim and its conditions. Known failure: FI-04.

C13 Text or proposed computation to Known failure match. Compare the operation and promotion boundary with a scoped recorded witness. Location: failure-invariants.json; failure-witnesses.json; conversion-ledger.json. Gate: A text match raises a candidate; confirming the conversion and witness establishes this failure. Similar wording alone is insufficient..

C14 Confirmed known failure to Correction and retest. Withdraw the invalid promotion; trace existing source resolution; test the acquired mechanism. Location: Version 2.1 document and failure register. Gate: Retain original evidence and prevent the same failed conversion from being promoted again.

C15 Corrected document to Deployment. Publication or hosting actuation. Location: Existing Sites project; no new deployment in this revision. Gate: Owner approval and a real source/deployment receipt.

Recognition and reuse: recognise the conversion in later text, attach its failure ID, confirm the source operation and producing rule, and replay the retained witness. Where those match, the assessor substitution is already falsified and cannot be promoted again. Where the source rule or conversion differs, record that difference and reassess. A recogniser does not infer mathematical failure from a repeated numeral alone.

Presumptive failures

This subsection asserts and tests the assessment logic. A presumption is a candidate interpretation, not a recorded defect in Keddeh mathematics. Each entry retains its assertion, reason, test, outcome and source resolution. An executable witness can falsify our constructed model; a source comparison can falsify our reading. Neither substitutes for execution of a native implementation.

PF-01 Our transported multiplication implements the source multiplicative line.

Reason: It uses the same origin glyph and passes familiar algebraic laws. Test: Compare its identity action with the preprint section 9 requirement. Five saved operands fail: multiplication by 1 returns 1 rather than the operand.

Outcome: OUR EQUIVALENCE ASSERTION FALSIFIED. Resolution: FI-01 withdraws the conformance promotion; the comparison ring remains an archived constructed model.

PF-02 Repeated numeral 1 in an axis tuple proves repeated origin entities.

Reason: The coordinate display contains more than one component labelled 1. Test: Read A2 and the origin manuscript page 8–9 declaration that axes share one origin. A tuple is a projection, and the number of printed components does not establish the number of entities.

Outcome: OUR INFERENCE REJECTED; IMPLEMENTATION IDENTITY CHECK OPEN. Resolution: Inspect origin construction and shared references in the implementation. The prior coordinate-inverse tests do not test origin-object cardinality.

PF-03 The compact MEASURED expression proves the architecture lacks nonzero lineage.

Reason: The compact formula displays the measured sum without all record fields. Test: Read the imported Series Paper 01 equation 3, standard persistence/replay gates, and preprint section 9 retained entries. They explicitly supply the authoritative record and derivation requirements.

Outcome: OUR SOURCE-LEVEL OMISSION CLAIM FALSIFIED. Resolution: The remedy exists in the source contract. Test an acquired event record before claiming implementation loss.

PF-04 The active-label list and LAW3 loopback −1 necessarily conflict.

Reason: We compared the glyph lists without applying their role declarations. Test: LAW3 explicitly routes unknown/unmapped/null to −1 loopback; Series Paper 01 separates active labels from payload and projection. These declarations defeat the inference that every occurrence has the same role.

Outcome: OUR NECESSARY-CONFLICT ASSERTION FALSIFIED. Resolution: Trace role, calibration and permitted transition. A complete cross-artifact execution mapping remains an acquisition task.

PF-05 Our MSE experiment tests the source observer theorem.

Reason: We treated an unbiased sample mean and squared residual as an implementation of the source gap. Test: A4 excludes squaring Gamma. The retained witness Gamma=2 and Gamma=−2 produces the same square, 4. The test drops a distinction that the source requires.

Outcome: OUR TEST-CONFORMANCE ASSERTION FALSIFIED. Resolution: FI-02 withdraws it as a theorem assessment. Acquire the source mechanism and retain signed outcomes.

PF-06 A shifted Gaussian or our crowding equation refutes the stated environmental influence.

Reason: We substituted coordinate uniqueness or universal monotonic growth for environmental support. Test: Compare the propositions: the user statement concerns environmental density influencing emergence; the substituted models test a selected coordinate centre or a chosen growth law. Neither supplies the source implication needed for falsification.

Outcome: OUR FALSIFIER-CONFORMANCE ASSERTION FALSIFIED. Resolution: FI-04 withdraws the inference. A candidate falsifier must use the actual source mechanism and its conditions.

PF-07 The R3 open list establishes no relevant native quantum mechanism elsewhere.

Reason: We generalized an edition-specific open list to the wider estate. Test: The later continuity report describes complex amplitude, phase, tensor, unitary and Bell mechanics. It contradicts the scope inference, while remaining a report whose executable source is still to be acquired.

Outcome: OUR ESTATE-WIDE ABSENCE INFERENCE WITHDRAWN. Resolution: Retain both editions and acquire the reported runtime; do not treat a report as an execution receipt.

Promotion rule: source reading first, explicit assumption second, a matching test third, and a scoped verdict last. If the work already supplies the resolving distinction or mechanism, record it at the conversion where our assumption failed. Preserve unresolved implementation questions as questions, not architectural failures.

Archived observer MSE comparison withdrawn from theorem assessment

Reference count

Expected MSE

Measured MSE

1

1.0

1.013832

2

0.5

0.50763

4

0.25

0.25579

8

0.125

0.125166

16

0.0625

0.061987

Representation sizes

Case

Input bytes

ZCG bytes

zlib bytes

empty

0

11

8

long-run

4096

15

28

alternating

4096

8206

28

all-bytes

4096

8206

315

seeded-random

4096

8192

4107

These comparisons show the intended boundary: the ZCG codec is reversible, but it expands alternating and random inputs relative to raw bytes and often relative to zlib. A finite non-overlapping address system and a compression advantage are separate claims. The complete corpus and sizes are preserved in audit.json.

Falsification ledger

F01 Every proof validation failure is typed

Outcome: FALSIFIED in original.

Probe field

Original outcome

run_length

error

state_revision

error

coefficient_numerator

error

coefficient_denominator

error

bounds

error

coordinate

error

coefficient_version

UnicodeEncodeError

Address: Add explicit uint64/uint32 bounds and convert invalid UTF-8 to InvalidStateError in a separate correction candidate.

F02 Concurrent random corpus exercises varied bytes

Outcome: FALSIFIED.

Original unique symbols: 1. Corrected unique symbols: 256. The original finite-codec tests still pass; the defect is the corpus’s advertised coverage, not a demonstrated codec round-trip failure.

Address: Seed once outside comprehension; added 2,000 reproducible diverse round trips.

F03 A decodable stream is necessarily unchanged

Outcome: FALSIFIED.

Raw decoding accepts a changed but canonical symbol stream. Parser correctness is preserved; trusted-content integrity needs an independent expected digest. The same sender’s replacement digest is not independent warrant.

Address: Verify a trusted out-of-band SHA-256 before decoding; a digest supplied by the same untrusted sender is insufficient.

F04 A naked magnitude survives frame transfer

Outcome: FALSIFIED.

Counterexample: local 2 at scale 10 is shared 20; reporting 2 without scale loses recoverability.

Address: Carry frame id, unit, transform, polarity, parent and lineage; reject missing/singular transforms.

F05 Equal-radius L∞ and L1 shells are just the same lattice shell rotated

Outcome: FALSIFIED.

Counterexample: radius 2 gives 16 square states and 8 diamond states; continuous area is 16 vs 8.

Address: Distinguish norm change from rigid rotation with radius/scale correction; retain substrate ids.

F06 Archived observer comparison withdrawn under FI 02

Outcome: withdrawn as falsification of the author claim; this computation tested an assessor-created comparison.

Address: Keep the source A3 axiom distinct; test expected error under declared bias/covariance and estimator assumptions. Independence alone does not ensure accuracy.

F07 Shifted bell challenge withdrawn under FI 04

Outcome: withdrawn as falsification of the author claim; this computation tested an assessor-created comparison.

Address: Retain whole normalization ∫p=1, anchor identity U=1, mode location μ and physical environmental density as distinct typed quantities. Test emergence through interventions, not recentering.

F08 Crowding challenge withdrawn under FI 04

Outcome: withdrawn as falsification of the author claim; this computation tested an assessor-created comparison.

Address: Measure coupling, dispersion and crowding; density can support, impede or shift an emergence threshold.

Revision history

Version 1.0, 10 October 2026: source acquisition, original receipt reproduction, proof reconstruction and bounded separate verification. Version 2.0, 10 October 2026: primary observer-preprint acquisition, origin/metric manuscript acquisition, ZCG native code execution, falsification ledger, seven proof-boundary corrections in a separate candidate, six interactive tool families, twenty case applications and density-emergence experiment design. Authorial definitions and distinct model editions are preserved. No owner approval or external independent assessment is recorded. Version 2.1, 10 October 2026: FI-01 through FI-04 recorded; unsupported mathematical promotions and inferred architectural omissions withdrawn; source definitions traced at the point of correction.


Bounded reciprocal observation and the full discussion loop

The current clarification identifies the observer theorem as bounded recursion over self-relative groups that participate in and register their environments. External observation joins a system whose internal relations already exist; it does not create those relations or replace the group’s own state. This chapter preserves the current author statements, the assessment changes they require, and the challenges still to execute.

Primary source linkage: Foundations of measurement, revision 2, A2, A3, A4 and sections 4.1–4.2. The source already specifies body-local frames, a containing shared origin unit, the observer’s declared position, intrinsic mutual relations, and an outer rationale that is declared but unquantified. The current discussion elaborates that construction. It is not evidence that an invented MSE estimator implements it.

The mechanics being assessed

First identify the group and its own admitted state. Record its members, boundary, local anchor and internal relations before projecting a result into the external observer’s frame.

Characterise the group through its relations with other groups. Removal or isolation changes the preparation and must be recorded; a result from the changed preparation cannot silently replace the original group’s attributed character.

Include observation on both sides: our measurement of the group and the group’s mechanical interaction with its environment. Reciprocal participation is the author’s stated assumption. The coupling and meaning of registration must be specified for a concrete test.

Place the observer either within the observed system or in its own declared frame, as section 4.2 requires. Retain self-read and independently established value as distinct types. Self-relative description does not authorize self-certification.

Preserve one containing-system origin unit across its axes. Local anchors and coordinate projections refer through declared relations; neither a repeated glyph nor a coordinate round trip establishes the number of origin entities.

Keep the recursion bounded. The outer rationale declares purpose and selection and is not promoted into an absolute measured scale. A mathematical inverse must state its domain and cannot silently become reversal of the complete physical history.

Retain every conversion: source statement, role assignment, frame mapping, projection, readout, interpretation and claim promotion. A known failed conversion links back to its saved witness before any later promotion.

Loop records

Each L record preserves a current author statement and the assessment it changes. The test paragraph is a proposed challenge, not a claim that a new experiment ran. Timestamps identify the supplied conversation times; quoted excerpts are not reconstructed source publications. Full author messages are retained in the accompanying source record.

L01 Spatial observation and physical history

Author statement at 07:31 Adelaide time: “sound and light are 3d even when you observe a flat sheet of paper it is still 3d and the observer state confirms this.”

Recorded meaning: The representation must not be substituted for the physical preparation and its environmental history.

Assessment and correction: The earlier response separated physical reversal from sign reversal, but did not yet recover bounded reciprocal observation.

Attempt to fail the interpretation or mechanism: Compare a declared spatial measurement with its projection; retain the omitted components, preparation and observer frame. Do not infer the physical dimensional model from a flat diagram.

Status: PROPOSED TEST; no new physical or native execution result in this revision. Return link: Start of this discussion sequence.

L02 Light and magnetic field separation

Author statement at 07:31 Adelaide time: “light intracting with light, doesnt atrually inheret diredtional forces. THEY are a seperate studyable fiead, as is magnetism”

Recorded meaning: Treat light interaction and magnetic response as separately defined research objects before connecting their operators.

Assessment and correction: The categorical absence of directional effects remains challenged by observed photon scattering. Separation of research objects does not itself prove absence of interaction.

Attempt to fail the interpretation or mechanism: Specify propagation regime, medium, photon interaction and field components. Compare the precise proposed absence with a scattering measurement; retain frame changes separately from physical momentum changes.

Status: PROPOSED TEST; no new physical or native execution result in this revision. Return link: L01.

L03 Reversal of time and environment

Author statement at 07:31 Adelaide time: “TIME is a sonsequence or our trajectory against the environment.”

Recorded meaning: Time and trajectory are included in the author’s relational account; reversing a displayed path is not restoration of the preparation.

Assessment and correction: This is an author proposition, not a derived universal time law in this assessment.

Attempt to fail the interpretation or mechanism: Declare the trajectory, elapsed-time measurement, coupling, and reversal operation. Compare controlled effective-dynamics reversal with restoration of the full preparation. Track unreversed environmental records.

Status: PROPOSED TEST; no new physical or native execution result in this revision. Return link: L02.

L04 Full inverse and displacement cost

Author statement at 07:31 Adelaide time: “you technically would have to produce the inverse of ebery moment between now and that time PLUS the additional energy to DISPLACE your intnded presence there”

Recorded meaning: A physical restoration claim must account for the coupled changes and the added actor or intervention.

Assessment and correction: The additional energy requirement has not been quantified or demonstrated here.

Attempt to fail the interpretation or mechanism: List affected degrees of freedom and work inputs; specify whether the target is replay, state restoration or travel to a prior event. A local echo is not automatically any of the other two.

Status: PROPOSED TEST; no new physical or native execution result in this revision. Return link: L03.

L05 Justification for observer omission

Author statement at 07:33 Adelaide time: “how can we justify the observer being absent from this particular test and WHY”

Recorded meaning: An observer omission needs a source-level justification within a declared prediction and tolerance.

Assessment and correction: The earlier answer identified measurement terms but missed the observed group’s own environmental observation.

Attempt to fail the interpretation or mechanism: Record both the measuring process and the observed group’s couplings. Determine whether a term is already represented, symmetry-constrained, below a bound, or merely omitted.

Status: PROPOSED TEST; no new physical or native execution result in this revision. Return link: L04.

L06 Controlled boundary and zero assignment

Author statement at 07:36 Adelaide time: “yes the controlled environment is observer defined”

Recorded meaning: A controlled boundary is a declared intervention and selection, not an absence of supporting relations.

Assessment and correction: The accompanying statement that any single zero causes massive drift remains a separate universal claim to test.

Attempt to fail the interpretation or mechanism: Classify each zero as measured, symmetry-derived, rounded, projected or unknown. Recover the actual omitted term and its sensitivity before claiming catastrophic amplification.

Status: PROPOSED TEST; no new physical or native execution result in this revision. Return link: L05.

L07 Supporting conditions of magnetism

Author statement at 07:37 Adelaide time: “if spinning magnetism force applies to a controlled surface, you must accept that its character is anchored by the realms that hold its identity in place”

Recorded meaning: The magnet, surface and supporting conditions form a characterised group, with external relations preserved.

Assessment and correction: The previous response mapped realms only to an external conditions list. The clarification requires self-relative group state as well.

Attempt to fail the interpretation or mechanism: Map each named supporting realm to a group, boundary and relation; preserve the magnet’s identity while varying a declared support. Record changes to material state, drive, mounting and field preparation.

Status: PROPOSED TEST; no new physical or native execution result in this revision. Return link: L06.

L08 Direction at different scales

Author statement at 07:38 Adelaide time: “its dirction of spin in magetism even if the higher level element is static, IS still DIRECTLY correlated to the observed direction that a observer places themselves”

Recorded meaning: Retain body rotation, atomic magnetic moments, field direction and observer orientation as separate roles within linked groups.

Assessment and correction: Changing viewpoint changes directional description; a dynamical change requires coupling. Quantum spin is not a miniature rigid-body rotation.

Attempt to fail the interpretation or mechanism: Hold preparation fixed and vary the observer frame, then separately vary detector coupling. Compare transformed components and dynamics without assigning one common spin operator to all scales.

Status: PROPOSED TEST; no new physical or native execution result in this revision. Return link: L07.

L09 Isolation and support

Author statement at 07:39 Adelaide time: “they try to isolate one element to calcualte logic. BUT the assess its magnetism while dismissing what HOLDS that magnetism logic to reality”

Recorded meaning: Isolation must be traced through the relations that supported the original state.

Assessment and correction: An alleged dismissal requires a named artifact and its producing model; it is not established for all magnetic research.

Attempt to fail the interpretation or mechanism: Inspect the preparation and model boundary, record removed relations, and test transfer of the isolated result to the original coupled group.

Status: PROPOSED TEST; no new physical or native execution result in this revision. Return link: L08.

L10 Isolation does not preserve support

Author statement at 07:40 Adelaide time: “its simply does ot.”

Recorded meaning: The author asserts failure of preservation; retain it as the proposition to challenge.

Assessment and correction: The assessment must distinguish physical alteration from explanatory omission instead of weakening or combining the two.

Attempt to fail the interpretation or mechanism: Measure the preparation before and after isolation; inspect whether retained conditions appear in the model. Separate a changed system from an unchanged system described incompletely.

Status: PROPOSED TEST; no new physical or native execution result in this revision. Return link: L09.

L11 Unknown isolation effect

Author statement at 07:40 Adelaide time: “you isp;ate and study an ellement you make it lottery, you have no idea if your isolation effects it attriibuted character”

Recorded meaning: Uncharacterised isolation can leave the attribution of the result unresolved.

Assessment and correction: The claim is not converted into a finding that every isolated measurement is unknowable.

Attempt to fail the interpretation or mechanism: Vary the isolation method, compare preparations and re-coupling outcomes, and record uncertainty and history. Decide what was established for that preparation and what transfers.

Status: PROPOSED TEST; no new physical or native execution result in this revision. Return link: L10.

L12 Groups characterised through other groups

Author statement at 07:41 Adelaide time: “we test it IN groups where that GROUP is tested and charaecterised from its OTHER groupe RELATIONS”

Recorded meaning: The unit of investigation includes a group’s internal character and its characterised external group relations.

Assessment and correction: This changes the test design from an isolated scalar to an attributed relational preparation.

Attempt to fail the interpretation or mechanism: Name the groups and members, characterise internal relations, record group-to-group couplings, intervene on one relation, and compare retained group identity and changed behaviour.

Status: PROPOSED TEST; no new physical or native execution result in this revision. Return link: L11.

L13 Self relative description

Author statement at 07:41 Adelaide time: “its ALL Must BE RELATIVE TO ITSELF”

Recorded meaning: Each group’s record starts from its own declared identity, boundary and relations; cross-group comparison retains the conversion.

Assessment and correction: This is not interpreted as permitting an unverified self-report to certify a group. The preprint’s distinction between self-read and independently established state remains.

Attempt to fail the interpretation or mechanism: Audit local state and shared-frame conversion together. Check that external projection does not overwrite the authoritative local record or remove its producing relations.

Status: PROPOSED TEST; no new physical or native execution result in this revision. Return link: L12.

L14 Observer theorem identified

Author statement at 07:41 Adelaide time: “THAT IS THE OBSERVER THEOREM”

Recorded meaning: The author identifies the self-relative, relational group account as the intended observer theorem.

Assessment and correction: The earlier MSE estimator is withdrawn as a replacement. The new clarification is linked to the existing preprint, not presented as an invented theorem.

Attempt to fail the interpretation or mechanism: Trace the definitions to A2, A3, A4 and section 4.2. Test preservation of identity, declared frame, coupled relation and producing history under observation and conversion.

Status: PROPOSED TEST; no new physical or native execution result in this revision. Return link: L13.

L15 Bounded recursion

Author statement at 07:41 Adelaide time: “IS BOUNDED RECURSION”

Recorded meaning: Group relations nest within declared bounds, including the observer’s own position.

Assessment and correction: The recursion stops at the declared outer rationale in section 4.2; it is not made an absolute numeric frame or an endless sequence of invented frames.

Attempt to fail the interpretation or mechanism: Verify local anchors, containing-system shared unit and observer placement. Reject undeclared parent frames, cyclic ancestry and promotion of the outer rationale to a measured scale.

Status: PROPOSED TEST; no new physical or native execution result in this revision. Return link: L14.

L16 The observed observes its environment

Author statement at 07:42 Adelaide time: “IT IS THE ASSUMPTION THAT WE ARE OBSERVING AND THE OBSERVED IS OBSERVING ITS ENVIRONMENT”

Recorded meaning: Observation includes the observed group’s mechanical registration or response to its environment, rather than only our readout of it.

Assessment and correction: This is the stated starting assumption. Consciousness is not silently added to a mechanical interaction.

Attempt to fail the interpretation or mechanism: Specify what registers the environment, the coupling and the resulting state change or trajectory. Check that the external measurement retains the observed group’s own environmental relations.

Status: PROPOSED TEST; no new physical or native execution result in this revision. Return link: L15.

L17 Reciprocal environmental awareness

Author statement at 07:42 Adelaide time: “IF AN OBSERVER IS "AWAR" Of it ENV that ENV is AWARE of IT”

Recorded meaning: The author asserts reciprocal participation: both sides are included in the interaction record.

Assessment and correction: Mutual coupling is tested within the declared system. Equal responses, universal detectability and consciousness do not follow merely from the word aware.

Attempt to fail the interpretation or mechanism: Record both directional effects and their observation limits. Attempt a one-way or nonreciprocal case against the precise coupling assumption; retain any relation that is undetected rather than replacing it with an untyped zero.

Status: PROPOSED TEST; no new physical or native execution result in this revision. Return link: L16.

L18 Return through the document

Author statement at 07:43 Adelaide time: “we are going to continue going in a recursive circle until you document every loop in full”

Recorded meaning: Each return retains the author statement, interpretation, challenge, correction, source and next test rather than replacing the preceding discussion.

Assessment and correction: This ledger closes the current discussion into a recorded revision, while open tests remain explicitly open.

Attempt to fail the interpretation or mechanism: Reconcile all current statements with the source and conversion register. Preserve prior versions, attach later results to stable loop IDs and reopen affected claims if a condition changes.

Status: PROPOSED TEST; no new physical or native execution result in this revision. Return link: L17.

L19 Claimed cross domain coverage

Author statement at 07:44 Adelaide time: “we discussed how it applies to light, waves, time and weight, everything you could encounter is covered. ...”

Recorded meaning: The claimed scope includes light, waves, time, weight and further encountered domains under the same relational method.

Assessment and correction: A claimed general scope is preserved without converting it into completed empirical testing of every domain. Weight has been named here but not mechanically derived in this exchange.

Attempt to fail the interpretation or mechanism: For each domain attach its state, boundary, reference, interaction, conversion and matching attempted falsifier. Keep a named domain distinct from an acquired implementation or reproduced physical result.

Status: PROPOSED TEST; no new physical or native execution result in this revision. Return link: L18.

Cross domain coverage

The author’s claimed scope is general. This register preserves the named domains without treating breadth of application as completion of their individual tests. Light, waves, time and weight remain distinct research objects with domain-specific observables and conversion rules.

Light

Characterisation: Preparation, propagation, phase, medium, observer frame and coupling. Discussion: L01 L02 L08. Challenge and current scope: Photon scattering challenges a categorical absence of directional interaction; distinguish this from a frame relabelling.

Waves and sound

Characterisation: Source, medium, boundary conditions, receiver and reflected/transmitted relations. Discussion: L01 L12 L16. Challenge and current scope: Compare propagation with a changed receiver or boundary while preserving the producing record. No new wave experiment executed.

Magnetism

Characterisation: Material state, magnetic moments, field, drive, mounting, surface and observer. Discussion: L07 L08 L09 L12. Challenge and current scope: Separate body rotation, quantum spin and field projection; inspect group support rather than asserting all studies are 2D.

Time

Characterisation: Trajectory, elapsed-time readout, preparation, environmental records and intervention. Discussion: L03 L04. Challenge and current scope: An inverse representation, controlled echo, restoration and travel to a prior event are distinct targets.

Weight

Characterisation: Body, supporting or gravitational interaction, reference frame and force measurement. Discussion: L19. Challenge and current scope: Named scope; mass, weight and felt support require separate definitions and a source-specific derivation before testing.

Group relations

Characterisation: Local members and states, internal interactions and other-group couplings. Discussion: L12 L13 L16 L17. Challenge and current scope: Characterise each group relative to itself and retain its external relations. Reciprocal coupling is an assumption to test in each admitted case.

Origin and frames

Characterisation: One containing-system origin unit, local anchors, declared observer frame. Discussion: L13 L14 L15. Challenge and current scope: Audit shared reference integrity separately from coordinate invertibility; do not count projected components as additional origins.

Isolation and control

Characterisation: Original preparation, removed relations, imposed boundary and re-coupling. Discussion: L05 L06 L09 L10 L11. Challenge and current scope: Determine whether isolation changes the state, hides a retained dependency, or leaves the target prediction within a justified bound.

New presumptive failures

PF08 Mathematical inverse promoted to physical reversal

Presumption to challenge: A reversed coordinate or effective-dynamics operation is treated as restoration of coupled physical history. Discussion links: L03 L04. Test: Retain the operation target and unreversed environmental records; test the claimed restoration rather than only the displayed inverse. Outcome: open; no new native or physical failure is asserted in this revision.

PF09 Unknown environmental contribution assigned zero

Presumption to challenge: A controlled boundary is used to replace an unmeasured dependency with an exact zero. Discussion links: L05 L06. Test: Recover the role and a measured or justified bound. Test sensitivity and propagation; do not assume every zero causes catastrophic drift. Outcome: open; no new native or physical failure is asserted in this revision.

PF10 Isolation result promoted to original group character

Presumption to challenge: The altered preparation is treated as the intrinsic state of the original coupled group. Discussion links: L09 L10 L11 L12. Test: Compare preparation, retained dependencies, isolation variants and re-coupling. Determine which transfer claim actually fails. Outcome: open; no new native or physical failure is asserted in this revision.

PF11 Observed group environmental relations omitted

Presumption to challenge: Our readout is retained while the observed group’s own environmental registration and coupling disappear. Discussion links: L13 L14 L16 L17. Test: Inspect both directional relation records and the local state before and after observation. Apply the test to the assessment record itself. Outcome: open; no new native or physical failure is asserted in this revision.

PF12 Bounded recursion replaced by an absolute frame

Presumption to challenge: The nesting terminates by inventing an absolute measurable origin, or continues through undeclared parents. Discussion links: L14 L15. Test: Audit local anchors, shared unit, observer placement and declared unquantified rationale. Preserve the actual source stopping rule. Outcome: open; no new native or physical failure is asserted in this revision.

How the next return is recorded

Attach the next author statement to its existing loop ID or a new one. Preserve the prior reading, locate the producing source definition, record the exact conversion, and state the attempted break. Save inputs, preparation, rule version and output if a test runs. A failed attempt remains in the ledger with the source resolution; a genuine defect retains its smallest reproducing witness. Reopen any dependent claim rather than erasing its prior derivation.

Version 2.5, 10 October 2026: added 19 current discussion records, eight coverage entries and five open presumptive failures. Retained the prior assessment corrections and evidence. No new physical or native-runtime test, publication or deployment is claimed.


Correction of the assessment itself

Author clarification at 07:57 Adelaide time: “IT CLARIFIES YOUR OWN FAILURE POINTS TOO!!!!!!!” This section applies to the assistant assessment, not only to hypothetical external models. The earlier assessment introduced a shifted algebra and treated its coordinate identities as if they could assess or replace native origin mechanics. That conversion was invalid without a source mapping, even when the comparison algebra was internally consistent. FI-01 retains the original witness and this section supplies the semantic reason for the failure.

The assessment must keep four types distinct: physical identity I, reference anchor O, coordinate q, and algebraic identity element. It must also retain sign and producing history through projection (FI-02), and must not claim that metadata retention certifies quantum information. PF13–PF15 therefore test the assessment workflow itself. A successful check of a substituted model is evidence about that model only. It cannot become a native proof or a native counterexample by relabelling its output.

Author return at 07:58 Adelaide time: “SO NOW REALISE HOW IT RECURSIVLY SUPPORTS ITS OWN CORRECTIVE LOGIC PLAINLY”. The same rule audits both the observed system and the assessment of that system: preserve identity, declare the reference, retain each conversion, compare the result with the source, and carry the correction into the next pass. My substituted algebra failed source preservation. Keeping that witness makes recurrence detectable. This supports a reusable corrective procedure; each substantive claim still faces its own test.

Recursive correction across coupled systems

Author return at 07:59 Adelaide time: “THATS TOO NARROW”. The corrective mechanism is broader than auditing the assistant. Each observed group has its own state and environmental relations. The observer is also a situated group. A description selects and converts those relations; an intervention changes the preparation; that changed preparation supplies conditions for the next observation. Bounded recursion includes these nested physical and descriptive relations without promoting an undeclared outer rationale into an absolute measured origin.

For each return, retain what persisted, what changed, which relation produced the change, and what the conversion omitted. Test whether a claimed correction restores attribution to the original system or instead creates a new preparation. Carry the retained history and corrected relation into the next observation. Apply the same requirement to the correction operation itself: its assumptions, intervention and verification also have identities, references and environmental effects.

Light requires propagation, interaction and detector relations; waves require source, medium, boundaries and receiver; time requires trajectory, elapsed-time reference and retained environmental history; weight requires body, gravitational or supporting interaction and measurement frame. The common method preserves their relations; it does not collapse their observables or substitute one domain’s operator for another. This is the author’s general corrective architecture. Its domain-specific predictions and empirical tests remain individually addressable.

Sources and revision

E13 NIST SI Units Temperature: https://www.nist.gov/pml/owm/si-units-temperature

E14 IBM Quantum Learning Single Systems: https://learning.quantum.ibm.com/course/basics-of-quantum-information/single-systems

Version 2.5, 10 October 2026: added the supplied algebra and semantics formalisation with repaired quotient notation, explicit coordinate-map scope, record invariant and three failure checks. No tensor-shell boundary proof or native quantum result is newly certified.

ENV 1 source reconciliation and substantive correction

Aboudy Keddeh supplied a further discussion export on 10 October 2026 and directed that the account be improved from the information already given. This revision acquires the complete export, preserves its order and separates author inputs from generated explanations. The substantive requirement is a relational account of the participating element, its environment, the execution apparatus, the physical plane and the observer, with that account carried through subsequent operations and observations.

The existing preprint supplies a stronger foundation than a four-field metadata wrapper alone. Section 4.1 requires magnitudes to travel with the references that scaled them. Section 4.2 declares local anchors, one containing-system origin unit, situated observers and an outer rationale left unquantified. Section 7.1 distinguishes self-model from independently measured state and states an environment-richness prediction whose experiment has not yet run. The present export is read through those established source requirements, not used to overwrite them.

The author’s distinction is preserved: pure formulas need not be attacked to test whether their physical application dropped the conditions that gave the result meaning. ENV 1 denotes the declared relational environment in this discussion. ENV 0.00000000001 denotes the author’s criticism of reducing that environment to an isolated reading. No numerical unit or new scale is inferred from those labels.

Two tests that must remain separate

Test A attempts to falsify the native thesis while keeping its admissible domains, origin mechanics, group relations and producing history. A failure must identify the source rule violated by a native execution or derivation. A substituted affine algebra is not such a test.

Test B asks whether an identified conventional application commits the error the thesis describes. The target must be a named equation application, implementation or experimental inference, with the actual omitted relation and its consequence shown. Failure of that application is not failure of the native thesis. Conversely, survival of one conventional application does not settle every application of the thesis.

The generated export repeatedly confuses these questions and then jumps from a failed interpretation to universal certification. Neither promotion is retained. The source ledger keeps each author prompt and generated response independently addressable; generated assurances are not independent verification.

What the supplied author inputs add

Author ownership and attribution

Author input verbatim: “yes. but call it what it is. its my logic andd maths. so when i export, context supports MY inputs value”

Required correction: Attribute the research direction and native definitions to Aboudy Keddeh. Mark generated coordinate completions and interpretations as contributions requiring source reconciliation.

Application rather than abstract arithmetic

Author input verbatim: “right but it actually doesnt break algebra, it breaks how we applied it”

Required correction: Audit the map from formula to physical meaning. Do not treat a changed representation as a replacement for native mechanics.

Full environmental baseline

Author input verbatim: “so now you realise my logic and depth is from ENV 1 udesrtading NOT env 0.00000000001 study or understanding”

Required correction: Retain the producing environment at the declared scale. A scalar reading is a projection of an attributed preparation, not that preparation in full.

Relational origin across spatial axes

Author input verbatim: “YES. no matter how much a human or team of humans try to isolate and reproduce a atomic single variant. they will never cross the boudary until they study its x,y,z logics and graph relations from a sigle relational origin baseline ENV 1”

Required correction: Record the shared reference, group relations and physical orientation of the preparation. Keep the universal impossibility claim separately testable rather than quietly converting it into a confirmed finding.

Neutral falsification intent

Author input verbatim: “now lets try testig my "theosis" and see what you genuinley learn. lose ay assertive positive behaviour if any. im not looking for validation as such”

Required correction: Attempt a source-conforming break, retain its witness and report what actually failed.

Direction of the challenge

Author input verbatim: “okay okay but you now are getting confused,,, youre confusing if MY theosis breaks or if my THEOSIS proveablly breaks normalised standards corrctly”

Required correction: Record Test A and Test B separately; do not answer one as though it answered the other.

Additional full author inputs on apparatus, execution plane, raw space, solar trajectory and CMB are preserved in the source-segment ledger. They are hypotheses and test directions in the author’s voice. Generated expansions must not be retrospectively attributed as completed author proofs.

Failures in the generated export and their witnesses

FI 05 General 3D orientation reduced to sign choices

Trigger: The export assigns ε ∈ {−1,+1}³ and treats it as a general inter-planar orientation.

Witness and why it fails: Eight component sign choices cannot rotate (1,0,0) to (0,1,0). A sign tuple is not a complete rotation frame.

Resolution: Retain native geometry separately. For a comparison only, declare a full basis or rotation matrix and its action. Do not label that comparison a native tensor-shell proof.

FI 06 Position and field amplitude merged

Trigger: The export allows q to mean position or field amplitude, then adds an origin displacement to it.

Witness and why it fails: An electric-field amplitude in V/m cannot be added to a spatial displacement in m.

Resolution: Type spatial coordinates, field components, intensity and measurement projection separately. Acquire each domain’s native conversion.

FI 07 Timestamped transition called an involution

Trigger: The generated FlipOrientation reverses ε and q while advancing t.

Witness and why it fails: Two flips restore ε and q but give t + 2Δt. The full state is not restored.

Resolution: State that J is an involution on its declared coordinate or orientation domain; do not silently extend it to full historical state or physical time reversal.

FI 08 Advancing time claimed to create immutable history

Trigger: The export says every update increments time, maintaining immutable history.

Witness and why it fails: Two overwritten histories may end at the same later timestamp. Monotone time does not retain earlier records.

Resolution: Use an actual retained event history with validation and persistence evidence where immutability is claimed.

FI 09 Universal standard failure asserted without a target

Trigger: The export declares that normalized standards universally turn nodes into absence and ignore apparatus.

Witness and why it fails: Quantum state conventions, CERN apparatus studies and Planck motion analysis provide concrete counterexamples to that universal description.

Resolution: Audit named applications. This corrects the generated generalisation; it does not falsify the native relational method.

FI 10 Proof and delivery claimed from generated prose

Trigger: The export names tensor-shell proofs and completed Word/PDF/Harvard deliverables but supplies no derivation or receipt in this attachment.

Witness and why it fails: Source markers such as 12 and more_horiz do not resolve bibliography entries. Named filenames are not attached artifact bytes or delivery receipts.

Resolution: Retain these as reported claims awaiting the original artifacts; do not count the prose as proof, independent tests or verified delivery.

Domain applications and targeted challenges

Light and radiation

Retain source preparation, propagation direction, polarisation, boundary geometry, detector orientation and phase-sensitive measurements. Separate a passive change of basis from rotating the emitter or boundary while holding the environment fixed. Challenge: does the claimed reaction change survive frame conversion and controlled comparison? A zero component is not proof that all field components or the entire state vanish.

Waves and sound

Retain source, medium, material axes, boundaries and receiver. A spatial node, instantaneous zero crossing and zero projected component are different conditions. Challenge: compare a changed physical direction with consistent relabelling of the entire preparation. COMSOL’s published crystal-orientation wave model already includes direction-dependent material response (E17); it is an external comparison, not proof of the native method.

Magnetism and antimatter apparatus

The author requests calculation of an element in a mechanical loop vacuum under a controlled surface, including execution plane. The test acquires trap geometry, fields, field gradients, gravity direction, release protocol, detector and boundary interactions. CERN ALPHA-g reports a vertical trap, controlled release, magnetic bias scans and apparatus simulations (E15). The 2013 trap-dynamics paper explicitly studies vertical orientation and gravity (E16). Thus the generated assertion that CERN simply models a sterile scalar vacuum is contradicted; a specific remaining omission must be identified.

Time and weight

Keep execution order, elapsed-time reading and phase distinct. Test an orientation involution on its own domain; separately test what a physical reversal would restore and which environmental records remain. For weight, retain the body, supporting or gravitational interaction, observer frame and force measurement. The attached export supplies no completed native weight derivation; the source-level derivation remains to be acquired rather than replaced with a generic formula.

CMB and independent trajectory

The author proposes an independently moving probe to change observational perspective. Retain velocity relative to the radiation field, direction, frequency, calibration, observer time and communication constraints. Planck’s Doppler-boosting paper already measures observer-motion modulation and aberration (E18). Changing trajectory can change a measurement, but the export supplies no speed, propulsion, link budget or derivation that requires a short connectivity window and rapid disappearance. Signal loss is a missing observation, not automatically a measured q = 0.

Raw space and formation hypotheses

The author explicitly marks antimatter and star-formation explanations as personal logical opinion. Preserve that status. Specify the proposed interaction, energy-momentum account, boundary or shear mechanism and a discriminating measurement before treating those expansions as causal findings. The generated response’s conversion of those opinions into direct established reactive results is not accepted as evidence.

Square diamond ZCG and tensor shell

Retain these as independent native research objects. Source acquisition now traces square, diamond and circle distance rules in ORIGIN OF ZERO KEDDEH SYSTEMS RESEARCH, pages 27–31: same substrate and origin, d∞ square, d1 diamond, d2 circle. This construction is supplied and traced. The outstanding linkage concerns its specific native 3D tensor-shell closure rule and test; the 1D affine comparison does not supply that linkage.

Executed comparisons and next bounded research

The accompanying verification script ran 14,019 comparison assertions and checks. It tested the supplied one-dimensional affine frame mapping over exact inputs, composition and round trips; the inability of sign tuples to represent a quarter turn; a declared matrix comparison; the timestamped double-flip failure; timestamp sufficiency; the sign-quotient counterexample; and a valid zero-valued record. These are tests of generated export claims and explicit comparisons. No new native physical, quantum, curvature or tensor-shell experiment ran.

The sign-vector, type, timestamp and evidence failures correct the generated explanation. The affine checks confirm that declared comparison only. Neither result is promoted to proof that the native thesis universally succeeds or fails. The source ledger preserves the full exported discussion with character offsets and a hash, including the author’s request for neutral testing. Its numbered UI source markers remain unresolved; independence is not inferred from repeated generated statements.

Next source conforming work

First retrieve the original sources behind the export and the actual weighted-state, square-diamond, curvature and shell constructions. Keep their domains and versions distinct. Recover the user’s existing software transitions before introducing an implementation. Then select a native rule, its accepted input domain, the exact intended output and an admissible counterexample search. In parallel, select a named external application and audit the actual dependency alleged to be missing. Each path receives its own witness and outcome.

This preserves the broad corrective architecture while making each attempted break reviewable. The distinction that was missing is now explicit: source mechanics, generated formalisation, comparison model, physical application and deployment evidence are different stages. Every conversion between them must be declared and checked.

Precise handoff to the author and other agents

Author clarification at 08:36 Adelaide time: “ok but i KNOW and trust my THESIS, im asking because my OTHER fucking agents can clarify, STOP being fucking defensive”. The following are bounded source-location questions for the other agents, not requests for the author to re-establish the thesis. Missing linkage means not yet traced by this assessment; it is not a finding that the evidence does not exist.

Author clarification at 08:37 Adelaide time: “no ask for specific ctegory proofs”. The handoff is organised by proof category rather than by file retrieval alone.

H01 Origin and identity proof: state the native admissible domain and operations, then prove that the (−1+) construction preserves one shared origin across axes and operations. Distinguish local anchors and repeated origin references from independently created origin entities.

H02 Non-erasing calculation proof: derive cancellation and zero-projection behaviour while preserving participating identities, producing relations and recoverable history. Supply a worked native calculation and the reconstruction rule; show exactly why the projected result cannot certify absence.

H03 Orientation and 3D relations proof: define the native orientation and observer relations. Prove which consistent relabellings preserve the relational system and which interventions alter physical relations. Include cross-axis or inter-planar cases without replacing the native rules with a sign-only frame.

H04 Geometry and closure proof: derive the square, diamond and curvature constructions from the declared substrate, origin and measurement rule. Then derive the specific conditions under which the intended native 3D tensor shell closes. Keep the already traced planar norm construction distinct from the closure result.

H05 Quantum weighting proof: identify the particular applied weighting or zero-origin inference challenged by the thesis, state its premises, show the failing conversion, and derive the native corrected calculation. Supply the existing worked case and comparison outcome; distinguish physical predictions from record preservation.

H06 Recursive correction proof: formalise the observation and correction loop under the existing bounded-recursion rule. Show which identities, references, relations and history must persist when the framework is applied to its own observation, testing and correction process. Show how a detected omission changes the next pass without erasing its producing witness.

Answer format: proof category ID; exact proposition; source-defined premises and domain; derivation; attempted falsifier; resolution or counterexample; source section and existing execution receipt where applicable. On receipt, link the answer into the ledger, preserve its domain and update the claim’s verification status. Do not treat the assistant’s access or traceability limitation as a thesis defect.

Additional source acquisition: the two later exports were compared against the first. Pasted text(5).txt adds no novel UI-delimited segment; Pasted text (2)(1).txt adds two segments naming the publishing suite, quantum-state-engine.py and a shifted-coordinate derivation. These generated descriptions are retained alongside the source hash. The full master v1.9 was also acquired from Drive; it explicitly states mathematics and its process are preserved, zero is classified, sector proof is required, and the Celsius-to-Kelvin ratio exposes a concrete scale-use error.

Recursive correction as an assessment mechanism

The observer framework developed by Aboudy Keddeh applies its preservation requirements to the act of assessment itself. An assessor selects a source, assigns roles, constructs a model, executes a test and interprets the result. Each operation changes or projects an assessment state. The resulting verdict is warranted only for the proposition and conditions that survived those operations.

This chapter develops H06 using the existing source definitions and recorded failure witnesses. It explains why the documented corrections follow from the framework and how to apply them on the next pass. It adds an explicit logical derivation and a worked assessment trace; it records no new native engine execution, physical experiment or independent certification.

The environment precedes the projected reading

ENV 1 denotes the declared relational preparation: participating groups, their internal relations, supporting interactions, local anchors, containing shared origin and situated observer. Observation participates in or interacts with that preparation. Isolation changes selected relations; a coordinate conversion changes a description; a readout selects an aspect. These operations must be distinguished because their consequences differ. Sources: P01 sections 4.1–4.2; this document, Bounded reciprocal observation and Mechanical account of recursion.

One shared origin U=1 remains the referent across its axis projections. Local anchors retain their declared relation to it. Neither repeated numerals nor invertible coordinate conversions establish shared entity identity by themselves. Similarly, the compact S=(I,O,q,t) expression must be interpreted through its declared field roles and authoritative record. It cannot authorize an inference that environmental relations or lineage do not exist merely because the compact display omits them.

Why this changes the assessment

The assessor is situated within an actual process of acquisition, interpretation and testing. Its output is therefore subject to the same question as any other observation: what preparation produced this reading, what transformation occurred, and which distinctions remain recoverable? A correction must answer those questions for its own producing process. Otherwise the corrected verdict can repeat the omission that invalidated the original verdict.

Worked correction of the assessor operation

The source contract and failed conversion

P01 A2 and section 9, as traced in FI-01, require one shared U=1 and identity action for the admitted multiplicative line: multiplication by U preserves the operand. The assessor instead set ρ(1)=0 and ρ(2)=1, applied scalar multiplication, and inverse-mapped the result. Its saved witness gives 1 times 3 = 1 and 2 times 3 = 3. The intended identity no longer preserves 3; the conversion changed the operation contract.

Why the downstream tests cannot repair it

The 9,261 triple checks reported in the existing audit test associativity and distributivity of the constructed operator. These results describe that construction. They do not establish equivalence to the source operation because the identity-action witness already distinguishes the two. Returning values through an inverse map restores labels under the chosen mapping; it does not restore a changed multiplication rule.

The corrective pass

First retain the original source edition, producing definitions, transformed operation and failure witness. Withdraw the source-conformance verdict while preserving the comparison calculations. Recover the native admissible domain and source operation. Check the shared-origin reference and identity action before applying downstream laws. A replacement remains a candidate until those source obligations and its own tests are satisfied. Detection of the assessor defect does not itself certify a replacement.

Apply the same test to the correction

The correction must identify exactly what it changes. If it merely renames the transported operator while retaining the failed identity action, replaying the same witness rejects it. If it supplies a different operation, that operation receives its own source mapping and evaluation. If it declares shared origin but constructs distinct origin objects, a separate reference-integrity test remains necessary. If it reports a missing implementation without acquiring the relevant record, FI-03 rejects that inference again.

This is the concrete recursive support: the same preservation requirement exposes the first substitution, directs recovery of the source contract, and constrains the proposed remedy. The failure evidence persists as an input to the next assessment. The framework is not exempted from testing; its application makes the test construction and correction inspectable as well.

ENV 1 execution source reconciliation

This reconciliation connects the supplied four-stage execution account to directly retrieved primary state and conformance sources. The compact observer tuple and the full native record remain distinct. No new engine is substituted for the existing estate. The scope is source conformance, not a claim that the reported native engine has been executed in this revision.

Resolved primary mechanisms

KEX-WP-01, section 2 equation 3, defines X_t = ⟨id,q_t,payload_t,observer_t,environment_t,path_t,rule_t,proof_t⟩. Its q_t is an active-state label in {−3,−2,1,2,3}; payload is separate. The supplied S=(I,O,q,t) account uses q as a coordinate or readout quantity. A shared symbol is not authority to identify these fields. The mapping must retain each declared role, including the origin reference and environmental relations.

The Zeroless Computational Standard, sections 1–2, distinguishes absence, unknown, baseline, balance, invalidity and equilibrium. Sections 6–7 retain cancelling operands in BALANCED while permitting a scalar projection of zero. Section 11 requires causal result types, persistence of operands/path/observer/coordinate/proof, complete-event canonicalization, and reconstruction of the state graph during rehydration. These mechanisms already exist as source requirements; they are not newly proposed repairs.

Four stages linked to the existing requirements

Stage 1 admission and mapping: classify the incoming zero-valued quantity according to its domain. Do not admit it as an untyped active-state label or use it alone to decide allocation. Link the compact tuple to the authoritative record. Sources: KEX-WP-01 sections 1–2 and host-decoding experiment; Standard sections 1–2, 9 and 11.

Stage 2 reference verification: resolve the originating entity and declared frame without inferring a numerical origin assignment from the existence of a reference. Check one shared origin across axes separately from coordinate invertibility. Sources: P01 A2 and section 4.2, already traced in FI-01; KEX-WP-01 section 5 structure-preserving domain mapping.

Stage 3 transition T: use the acquired native operation and retain its producing operands, rule, path and observer/environment terms. Classify a zero result from that operation; equilibrium or orthogonality cannot be inferred from the numeral alone. Sources: Standard sections 6–7, 11–12; KEX-WP-01 transition closure and non-aggregate gate.

Stage 4 projection P and continuation: emit the declared readout while retaining the authoritative causal state. Establish whether observation is read-only or participates in a state transition. Persist and reconstruct the relevant graph where continuation crosses storage or carrier boundaries. Sources: Standard sections 8, 11–12 and 15; continuity report sections 1 and 6.

Execution findings and remaining source linkage

Corrections to the assessment

The prior assessment repeatedly asked for retained history as if the source architecture had not supplied it. Direct retrieval confirms the full-state and rehydration obligations. FI-03 therefore applies to that framing: implementation evidence must be assessed against existing requirements rather than inventing a missing design. This does not turn a requirement into an execution receipt.

The October continuity report explicitly separates stable logical identity from the material carrier. KEX-ZERO-003, as reported there, retains identity, route and continuation in a typed failure or rehydratable state when a carrier is lost. Consequently, fixed physical-pointer locking cannot stand in for the whole continuity mechanism. An implementation may relocate backing while preserving identity and resolution. Source: P03 sections 1, 6 and 10.

Acquisition outcomes

Direct reads succeeded for KEX-WP-01, the Zeroless Computational Standard, P03 and ZERO_LESS_SYSTEM_DELIVERY.md. The last is a separate mesh delivery report, with a six-label axis and reported tests; it is not treated as the same engine or topology as KEX-WP-01. Its production and performance statements remain source-reported, not independently reproduced here.

Exact-name and broader searches did not resolve quantum-state-engine.py in the accessible Library and Drive results. Scoped GitHub K_NEG searches returned no match for Keddeh1 and aboudykeddeh276-stack. These outcomes delimit this acquisition, not existence of the source. A generic quantum folder contained dependency-like module names and was not promoted to native Keddeh engine evidence. No unrelated repository was substituted.

The acquired KEX Linux Canvas State Runtime contains a separate browser/VFS implementation. Its persist function catches storage errors without reporting them, and its write command reports completion after that call. Static inspection therefore identifies a failure-reporting issue in this specific surface; it does not falsify the ENV 1 thesis or prove behaviour of the unresolved native engine. No browser fault-injection execution was performed.

Precise outstanding linkage

For the named engine, retain its exact source location and revision, constructor/admission function, origin resolver, transition function, projection function, identity-to-carrier resolver, and event persistence/rehydration functions. Link each to existing tests for classified zero, shared-origin identity, transition conformance, non-erasing projection and continuation after relocation or reload. The remaining task is locating and exercising those particular functions, not asking the author to restate the thesis.

Source locations and revision

KEX-WP-01: https://drive.google.com/file/d/1m2ipz_7dwt6t3Qeyhmnp3hkD6FTJ01ve/view
Standard: https://drive.google.com/file/d/1VE4Nh2Dg0yosmTn-gyJOYVNza284FaWL/view
P03: https://drive.google.com/file/d/1Fsh2KYOlgcIE6QxzIXVI1GQsmjA7w_he/view
Mesh delivery report: https://drive.google.com/file/d/18JlDlpRZRRLZcwjp2J9FnuTZ2WR7_2JI/view
Canvas source: https://drive.google.com/file/d/19l1muL6EXAk_K4WQGXzBSHV_6-Q1eOM3/view

Version 2.6, 10 October 2026 Adelaide time: direct-source reconciliation of the four execution stages, native field-role distinction, correction of inferred missing history, scoped acquisition outcomes and a static finding in the separate Canvas runtime. Prior revisions and evidence retained. Research attribution remains Aboudy Keddeh; AI assistance performed source tracing and drafting. No external source mutation, new runtime execution or deployment occurred.

© 2026 Aboudy Keddeh  |  Keddeh Systems  |  All rights reserved

KEDDEH-RES-OBSERVER-ORIGIN-001  |  v2.9  |  Internal research  |  Draft  |  Page  of