KEDDEH SYSTEMS | RESEARCH AND FORMAL PUBLISHING ENGINEER · AUTOMATE · SCALE Observer Origin Environment and Relational Geometry White paper | KEDDEH-RES-OBSERVER-ORIGIN-001 | Version 2.9 Aboudy Keddeh — Systems Architect Keddeh Systems | Internal research | Draft Research paper with formal propositions algorithms and verified implementation evidence 10 October 2026 | Australia Adelaide | Internal research | Draft Authorship and licensing Research and architecture: Aboudy Keddeh, Systems Architect. AI assistance: source organization, derivation drafting, local verification and editorial preparation. Intellectual authorship, execution evidence and independent approval are recorded separately. Copyright notice: © 2026 Aboudy Keddeh. Publisher: Keddeh Systems. Licence profile: KEDDEH-RESERVED-1.0. All rights reserved. No licence is granted by this document. Separate written permission governs reuse, redistribution and implementation, subject to applicable law. Third-party material retains its own rights. Authorship identifies intellectual contributions. Copyright ownership and legal publishing capacity are recorded separately; this template does not assert an assignment of rights or grant patent, trademark or software licences. Approval: Not yet recorded. Independent assessor: Not yet recorded. Distribution is controlled by the document classification and owner authorization. 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 ||²=(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 #include #include #include #include #include #include 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 #include namespace QZL { class Kernel { private: // 1-Based State Registers (R_1, R_2, ..., R_N). No 0-register exists! std::vector registers; // 1-Based Memory Slots (M_1, M_2, ..., M_N). No 0-slot exists! std::map 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 #include #include #include #include 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 assemble(const std::string& source_code) { std::vector 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 #include #include 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 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 #include #include #include 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 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(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 #include 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="<