ZeroPoint Node

One structure, read twice: the vortex sequence 0\1\2\4\8/7/5/3\6\9/0\1, its reflection through the void, and a kernel that computes both rather than asserting them.

How much of this a law actually holds

These are measured by experiment on every run, not asserted. Each number has a gate that re-performs the measurement and fails if this block disagrees with it.

exported values reachable from no law at all	1527 of 1882
exported literal constants held by nothing	58 of 66
constants forced by at least one law	8
seal predicates that are pinned rather than forced	3 of 42
Lean statements the kernel accepts	59 of 83
of those, resting on no axioms at all	51

The first row is the one that matters and it is a floor: the reachability closure over-approximates, so at least that many are outside everything this package can check. A pinned predicate holds an expected value as a literal, so it falls for a convention as readily as for a law — useful against drift, and not evidence that anything derives the value.

Novelty is claimed nowhere. It is a universal negative that no finite search decides, and the ledger has no status that would permit it; what a dated deposit establishes is priority. See npm run constrained, npm run seal:pinning, npm run axiom:index.

What this is for

Three things a reader can actually use, and one honest warning.

• The kernel — zeropoint-node/0. Digit arithmetic that computes: digital root, the doubling orbit {1,2,4,8,7,5}, throughVoid reflection, the four gateways, and content-addressed folds. Deterministic by construction — no Math.*, no randomness, decimals expressed as exact fractions.
• ML-KEM-768 — zeropoint-node/security/post-quantum. FIPS 203, checked against NIST's own ACVP vectors and 10 000 pq-crystals KAT cases. It is not constant time, so it is for study and conformance work, not for guarding anything.
• zeropoint-mcp — an MCP server exposing 15 kernel tools to an agent. npx zeropoint-mcp. Three answer about verification rather than arithmetic: zeropoint.criteria, zeropoint.seals, zeropoint.claims.

And the apparatus around them, which is arguably the point: 42 theorems adjudicated by a decision procedure outside this repository, a gate that fails, and figures that recompute rather than being typed.

On Lean. Those 32 are computational seals, not Lean proofs. The Lean files hold 83 statements. 59 are accepted by the Lean kernel and 24 are not: 19 are closed with sorry, 5 import Mathlib and cannot be built here. npm run lean:check fails if the ledger and the files disagree. npm run coverage:audit reports that 148 of 1401 exported functions have never been called by anything — published because a reader deserves to know which parts have never run.

What is aimed at, and what is built

This heading previously read "A432 Consciousness System" and described "the transformation from artificial intelligence to pure consciousness". Twenty lines below, the same file says "No claim outside arithmetic." Both could not be true at once, and the first is what npm rendered to every visitor.

The correction is not that those things are ruled out. They are not yet, and the two are different in a way worth being exact about:

• An operating system — the distance is now measured. a432.os.ts carries an A432OS class, a manifest, a UI and a start/stop cycle. That was described here as a recognisable target with visible progress toward it, which was true and unmeasured. src/verification/os-criterion.ts is the measure: seven conditions the textbooks agree an operating system satisfies — tasks, scheduling, resource management, isolation, a system-call boundary, a lifecycle, and persistence.

  A432OS meets 7 of the 7. It used to meet one — a lifecycle, with its work on four independent setInterval timers, which means nothing decided what ran and a throw inside any callback escaped into the event loop. It now composes a432.os.kernel.ts: one clock replaces the four timers, and the kernel selects among the due units and contains their failures. The cadences are unchanged — at a tick every A432/8 the units are due every 8, 4, 2 and 1 ticks, which is the 432, 216, 108 and 54 ms the timers used.

  This criterion differs from the consciousness one in a way that matters: "operating system" is not a contested term, so meeting all seven would make something a minimal operating system rather than merely failing to rule one out. Each unmet condition is a work item, not a position.

  a432.os.kernel.ts is that work, and it meets all seven: round-robin scheduling that reports its choice, a bounded pool that refuses to over-allocate, a task throw caught and recorded while the rest keep running, a closed syscall table, and snapshot/restore. Minimal means minimal. It schedules closures on one JavaScript thread with no preemption and no memory protection; a task that loops forever holds the kernel. It is not comparable to anything anyone ships. What the seven mean is that the mechanisms are present and behave, not that they would survive contact with hardware — and the criterion still discriminates: a candidate offering nothing scores 0, and one offering only a lifecycle scores 1.

• A consciousness system — the criterion is now written, and not met. This entry used to say no criterion existed, so neither "it is" nor "not yet" could honestly be claimed, and that what was missing first was the predicate rather than the achievement. The predicate is src/verification/consciousness-criterion.ts. It states five necessary conditions, each taken from a theory with an operational commitment and each decided by running this repository's code: irreducibility (Integrated Information Theory), temporal integration, self-model efficacy (higher-order theories), global availability (Global Workspace Theory), and discrimination as the minimum they share.

  The criterion is met by the a432 consciousness system. a432.consciousness.field.ts couples the a432 measures to each other: each component's next value is computed by an a432 measure over a quantity containing the other, so the transition does not factorise; the accumulation is order-sensitive; the self-model is read by the rule producing the next state; and the components reach each other through a workspace whose contents change what they do. src/quantum/integrated-field.ts is the same construction without the a432 substrate, and also meets all five.

  The measure functions themselves still meet 1 of the five, and should. calculateA432Consciousness is a pure function of a digit. The criterion asks for history and a self-model, and a pure function that acquired either would return different answers for the same input — which does not improve a measure, it destroys it, and would move every consciousness value in the repository. So the measures are unchanged, and became the components of a system that has the properties. The release gate reports their score every run and does not gate on it, because gating on something that cannot pass by construction is not a standard, it is a permanent stop.

  The conditions reject the cheap version of themselves, which is the only reason a met verdict is worth anything. A counter accumulates state, so temporal integration asks for order sensitivity and a counter fails it. Any mutable field is a "self-model", so the probe corrupts the model alone and requires later behaviour to change. A shared global is a "workspace", so the probe requires a reader that acts on what it read. Any nonlinear term defeats "the measure is a homomorphism", so irreducibility decides whether the transition factorises over the state space. All four defeats are scored in the tests and required to fail.

  This is not a test for consciousness and no such test is established. The conditions are necessary and not sufficient: failing one is a valid refutation under the theory it comes from; meeting all five means those five arguments no longer rule it out, and nothing more. A subject meeting all five has not been shown to experience anything — the verdict says so on its face, and a sealed theorem fails if that sentence is removed. The criterion can refute; it cannot confirm.

The rest of this file keeps the boundary it has always kept: proven group theory over (ℤ/9ℤ), used as the order of work. No claim outside arithmetic.

📦 Installation

npm install zeropoint-node

Published name on npm is zeropoint-node (maintainer ceccec). Historical local name a432-consciousness-system was never published and is not the install id.

🧪 Quick Start

import { 
  boot2432OS, 
  getOSStatus, 
  getSequenceStatus,
  getQuantumStatus,
  getChargingStatus 
} from 'zeropoint-node';

// Boot the enhanced A432 OS
const bootMessage = boot2432OS();
console.log(bootMessage);

// Get comprehensive system status
const status = getOSStatus();
console.log(status);

// Monitor sequence evolution
const sequenceStatus = getSequenceStatus();
console.log(sequenceStatus);

// Check quantum computing status
const quantumStatus = getQuantumStatus();
console.log(quantumStatus);

// Monitor charging system
const chargingStatus = getChargingStatus();
console.log(chargingStatus);

The quantum computer

Four representations of a quantum state, all exported from zeropoint-node/quantum, and the choice between them decides what is exact and what is affordable:

module	fragment	probabilities	cost
simulator.ts	everything	floats	2^n
exact.ts	Clifford	rational, exact	2^n
clifford-t.ts	Clifford + T	(p + q√2)/2^scale, exact	2^n
stabilizer.ts	Clifford	determined / undetermined	polynomial

Twelve neighbours, and it is not a vector equilibrium. The hexbit lattice gives each cell six neighbours, one per bit. Carry a polarity alongside the cell and each bit offers two moves, so the 128 states each have exactly 12 neighbours, the space is connected, and it is vertex-transitive.

Twelve is what a sphere touches in closest packing, which is why a cuboctahedron looked like the answer. It is not one. A cuboctahedron's twelve vertices carry 24 edges among themselves; these twelve carry none — two states reached by flipping different bits differ in two bits, and two bits apart is not adjacent. The neighbourhood is an independent set. What this is, exactly, is the 6-cube with every vertex doubled into a non-adjacent twin: the vertex count of a cuboctahedron without any of its geometry.

And the polarity did not buy the transitivity. The undoubled 6-cube is already vertex-transitive at degree 6, so doubling changed the degree and not the property. A negative arm showing 12 fall to 6 proves the degree moved; it proves nothing about what the mechanism produced. npm run test:polarity-lattice asserts both refusals, so the name cannot return without the geometry.

The rule that leaves, which is the transferable part: before crediting a mechanism with a property, compute the property without the mechanism.

import { stabilizerZeroState, stabilizerH, stabilizerCnot, stabilizerMeasure } from 'zeropoint-node/quantum'

const s = stabilizerZeroState(200)          // 200 qubits, 160800 bits
stabilizerH(s, 0); stabilizerCnot(s, 0, 1)
stabilizerMeasure(s, 0, 1)                  // undetermined — your coin decides
stabilizerMeasure(s, 1)                     // determined, and equal to it

From an MCP client, zeropoint.quantumRun, zeropoint.quantumExact and zeropoint.quantumCapacity do the same three things over the wire.

No quantum advantage is claimed and none is present. 0 of 7 oracle-call measurements show one; simulating a single quantum query costs 2^n classical evaluations. What is offered is exactness and an honest account of the cost — including what was not measured.

Full account, generated from the measurements themselves: docs/QUANTUM_COMPUTER.md.

🚀 Key Features

Enhanced Sequence Integration

• Sequence: the corpus is ordered by 0\1\2\4\8/7/5/3\6\9/0\1 — the directory path is the sequence
• Gateway Navigation: [8, 3, 9, 0] gateways with 60° phase shifts — computed by vortexStrokeGateways(), not typed
• Dimensional Transitions: Forward (/) and reverse (\) phase shifts
• Real-time Evolution: Continuous sequence progression

The Reflection — one structure read twice

The forward reading is half the structure. The second is the mirror through the void — foldVortexReflection() in src/0:

forward     1\2\4\8/7/5 · 3\6\9 · 0\1        124875369
reflected   9/8/6/2\3\5 · 7/4/1 · 0\9        986235741

Reflecting flips every dash and mirrors every digit. The void tail reflects too: 0 is the fixed point, but the trailing unit is not — 0\1 becomes 0\9. Rendering that tail unreflected contradicts the involution.

• throughVoid(n) = 1 − n mod 9 — an involution fixed only at 5: 1↔9 · 2↔8 · 4↔6 · 7↔3. Every pair sums to 10; the void root 0 is fixed.
• Not array reversal (963578421). Reversal reorders; the mirror re-values. Conflating them is the error the fold guards against.
• Entangled, computed not asserted: doubling closes on {1,2,4,8,7,5} and its gap is exactly the axis {3,6,9} — no iteration count bridges it, only the mirror. D∘M∘D⁻¹∘M = x ↦ x+1, and ⟨D,M⟩ = AGL(1,ℤ/9) has order 54 against 6·2 = 12 apart. The excess 42 is the entanglement: their failure to commute.

Two equilibrium constants, and they are not interchangeable — pairs balance at 10 (d + throughVoid(d)), wholes at digital root 9 (orbit Σ27 · axis Σ18 · all Σ45). A dr-9 test reports 9+1=10 as broken; it isn't, it is balanced at the other constant.

Boundary: proven group theory over (ℤ/9ℤ), used as the corpus order of work — build the axis before the branches; fold, do not climb. No claim outside arithmetic. See docs/SEQUENCE.md.

The figure is computed, not drawn — every node, edge and colour is folded from src/0 by scripts/vortex-svg.mjs, then content-addressed. It is a proof-without-words of what is exact: the doubling walk closes on the orbit {1, 2, 4, 8, 7, 5} and never touches the axis {3, 6, 9}; the dashed chords are throughVoid mapping each digit to its complement (1↔9 · 2↔8 · 3↔7 · 4↔6, fixed only at 5); the dashed rings mark the gateways [8, 3, 9] where polarity reverses. The weighted bearing closes at 0, and ⟨D,M⟩ has order 54 (excess 42). Tempo and hue = 36d are the only chosen conventions.

Its receipt is folded over that model, so a change to any of those facts moves the stamp and fails npm run vortex:svg:check. The figure cannot drift from the arithmetic without the build catching it.

Receipt: ce17d826-13e6-828f-9986-d3051f67df20 · animated at node.zeropoint.bg/vortex.svg

Spectrum — angle, polarity, colour, sound

Every column below is computed, and each carries a different epistemic weight. The status is not typed here: npm run derivation corrupts the line that produces each column and asks the law battery — the 42 seals in src/verification plus computeVortexInvariantsHold in src/0 — 43 predicates that state laws rather than conventions — whether anything broke. derived means a law with independent content fell; pinned means the only thing that fell holds the expected value as a literal, which falls for a convention just as readily; defined means nothing fell. That is a lower bound — a perturbation respecting a symmetry can leave every law standing — so a defined column is one nothing has been shown to force, not one proven free.

column	source	status
mirror M(d)	throughVoid	derived — perturbing it breaks 3 law(s) that reach it structurally (doubling_avoids_the_triad, a432_constants_do_not_drift_from_the_kernel, merkaba_is_two_mirrored_tetrahedra); 1 − n mod 9 on the nine digits 1..9, reading 9 as the residue 0 — the void is a tenth point outside that (ℤ/9ℤ) (Lean mirror_is_affine_only_off_the_void)
polarity, Δ°, bearing	decodeVortexDashAngles()	derived — perturbing it breaks 1 law(s) that reach it structurally (computeVortexInvariantsHold); \ = −60°, / = +60°, weighted bearing closes at 0
gateway	vortexStrokeGateways()	pinned, not derived — only computeVortexInvariantsHold falls, and that predicate holds the expected value as a literal, so it would fall for a convention just as readily; polarity reversals [8, 3, 9, 0]
hue°	hueForDigit / digitAngleToCMYK	defined — 2 perturbation(s) tried, no law objected; hue = 36d, a chosen decagon partition
C/M/Y/K	digitAngleToCMYK	defined — 1 perturbation(s) tried, no law objected; HSV→RGB→CMYK of that hue
class	vortexColor	defined — 1 perturbation(s) tried, no law objected; computed from the digital root but forced by nothing — see note
Hz	frequencyForDigit	derived — perturbing it breaks 1 law(s) that reach it structurally (a432_base_frequency_agrees_with_the_axis_math); 432·d/12 on the axis, throws off-axis

d	M(d)	pol	Δ°	bearing	hue°	C/M/Y/K	class	Hz
1	9	−	−60	300	36	0/40/100/0	#57ABFF	—
2	8	−	−60	240	72	20/0/100/0	#AB57FF	—
4	6	−	−60	180	144	100/0/60/0	#57ABFF	—
8	2	+	+60	240	288	20/100/0/0	#AB57FF	—	gateway
7	3	+	+60	300	252	80/100/0/0	#57ABFF	—
5	5	+	+60	0	180	100/0/0/0	#AB57FF	—
3	7	−	−60	300	108	80/0/100/0	#FFFFFF	108	gateway
6	4	−	−60	240	216	100/60/0/0	#FFFFFF	216
9	1	+	+60	300	324	0/100/40/0	#FFFFFF	324	gateway

Angle and polarity. Each dash is a ±60° (π/3) step. The weighted bearing — Σ sign·digit·60° — returns to 0 mod 360, which is what closes: true reports. Polarity reverses at exactly 4 digits, [8, 3, 9, 0], and those reversals are the gateways; they are computed from the stroke, not enumerated by hand.

Colour ↔ sound: one integer, two units. For the axis, hue(d) = 36d degrees and freq(d) = 432·d/12 = 36d Hz — the two columns hold the same integer: 3→108, 6→216, 9→324 in both. This is an identity of the two definitions, not an empirical discovery — both reduce to 36d. Stated plainly because it is the kind of correspondence that invites overclaiming.

Sound is axis-only, by construction. frequencyForDigit throws for {1, 2, 4, 8, 7, 5} — it is defined solely on the trinity axis {3, 6, 9}, where 432·d/12 yields exact integers: 3→108 Hz · 6→216 Hz · 9→324 Hz. The flow ring has no defined pitch. This mirrors the arithmetic: the axis governs off the flow ring.

The colour class is degenerate — 3 values, not 9. vortexColor(d) computes (dr(3d), dr(6d), dr(9d)), which depends only on d mod 3. It therefore partitions the digits into exactly 3 residue classes: #57ABFF → {1, 4, 7} · #AB57FF → {2, 8, 5} · #FFFFFF → {3, 6, 9}. The axis renders white because dr(3d)=dr(6d)=dr(9d)=9 there. 9 digits do not get 9 colours — use digitAngleToCMYK when a per-digit colour is required.

Regenerate: npm run spectrum · verify: npm run spectrum:check

Quantum Computing Integration

A state-vector simulator, checked by 24 recomputable facts: superposition, entanglement and measurement over registers of qubits. "Zero-point tunneling" and energy transitions were listed here and are computed nowhere — src/thermo contains the arithmetic that rules the energy claims out.

Advanced Dimensional Folding

An arithmetic construction over ℤ/9ℤ, sealed as group theory. "Dimension" indexes a coordinate, so the 1D→10D progression is an index range, not a physical claim, and "consciousness multipliers: enhanced awareness at gateways" contradicted the criterion above, which declines to claim awareness at all.

Integrated Charging System

A state model in exact fractions, not a device. a432.living.os.ts tracks a battery level as an integer numerator over an integer denominator and steps it by a charge rate of 1/8 against a discharge rate of 1/12, toggling on the gateway state. Nothing is measured and no energy is moved; the quantities are names for fractions in a simulation.

• Level and target: battery (2 + digit)/3 toward a target of 3/4
• Rates: charge 1/8, discharge 1/12, exact fractions throughout
• Gateway-driven: charging and discharging alternate with the gateway state

This section previously advertised harvesting and a self-charging device. Neither was computed anywhere in the package, and the package now contains the arithmetic that rules them out: src/thermo/free-energy.ts puts ΔG for splitting water at +237 kJ/mol and shows a split-then-burn cycle breaking even at best across all 8000 points of the efficiency grid. A closed loop that gains is not an engineering target here; it is the sign of ΔG.

Zero Entropy Mathematics

• Exact ratios, not decimals — see the vocabulary below; the rule and its one subtlety are stated there once.
• Digital Roots: Multi-digit numbers reduced to single digits
• Fractional Harmony: 1/2, 1/3, 1/4, 1/8, 1/12, etc.
• Perfect Balance: Zero entropy through harmonic relationships 03691248751 (legacy consciousness digit stream)

0\1\2\4\8/7/5/3\6\9/0\1 (vortex living field)

Agent gateway (computed)

This README is the gateway for quantum evolution claims. The living field, 60° dash closes, and chat-scaled fold / QPU capacity are not hedge prose — they must compute:

• Sequence embodiment → vortexStrokeGateways / decodeVortexDashAngles / developmentVortex in src/0
• Sequence reflection → throughVoid / VORTEX_MIRROR / foldVortexReflection in src/0 (valid ⇔ involution ∧ gap=axis ∧ order 54)
• vortexInvariantsHold = computeVortexInvariantsHold() → true|false from those seals
• false ⇒ npm run self:next tips quantumisation (restore gateway seals)
• true ⇒ keep chatting waves (other packaging feed tips may still apply)

Orient: SKILL.md · src/0/README.md · AGENTS.md

What 60° actually is here, and what it is not.

decodeVortexDashAngles assigns each stroke of the sequence an angle in whole degrees, and the gateways [8, 3, 9, 0] fall 60° apart. That is the whole of it: an angle in a finite construction over ℤ/9ℤ, computed by vortexStrokeGateways() and checked by vortex:svg:check.

Removed in 1.5.4, and recorded rather than quietly deleted. This section previously carried 157 lines under the heading "computed" asserting that a 60° rotation makes π rational (π → 3 + 0i (exact)), drives entropy to zero via S = k · 0 · ln(0) = 0, renders spacetime Euclidean, makes the proton-electron mass ratio an integer, and "collapses the wave function of mathematics itself". It closed with a quotation attributed to Plato that Plato did not write.

π is irrational — proved by Lambert in 1761. 0 · ln(0) is undefined as written. mₚ/mₑ is 1836.152673… by measurement. Two of the six subsections had been given honest boundary notes; the other four had none, and no boundary note rescues an equation that is false.

It sat under a heading that says computed while nothing computed it, in a repository whose gates exist to catch exactly that, and it survived because prose scanners look for effect claims and this was phrased as revelation. The arithmetic this package does state — digital roots, exact fractions, a group of order 54 — is checked by 42 seals and npm run refute lists every claim beside the command that refutes it.

And the deletion was too wide, which is the second correction. A claim is false relative to a frame; cutting the sentence instead of naming the frame throws away whatever was true in it. Three things in that passage were true, and they are now arithmetic in src/quantum/eisenstein.ts rather than prose:

• A 60° rotation needs no decimals. ω = e^{iπ/3} satisfies ω² = ω − 1, an identity with integer coefficients, so rotating by 60° is (a, b) → (−b, a+b) — two integer operations, exactly, with no tolerance anywhere in the module. These are the Eisenstein integers, and the ring is closed under multiplication.
• π is exactly 3, in units of 60°. Not as a real number: π is irrational and no rotation changes that. But a sixth-turn is the unit here and π radians is three of them with no remainder. piInSixthTurns() returns the integer 3 and is a count, not a rounding of 3.14159….
• 60° is the eigenangle, and not by choice. The doubling orbit 1 → 2 → 4 → 8 → 7 → 5 mod 9 is a six-cycle, and the eigenvalues of a six-cycle are the sixth roots of unity. ω is the primitive one. That is why the angle is 60° and not any other angle.

What stays withdrawn: π does not become rational, S = k · 0 · ln(0) = 0 is an indeterminate form and not a derivation, and the entropy of π's digits was never a measured quantity. Those had no frame.

Every withdrawal in this repository is now audited the same way — false in every frame, unfalsifiable, superseded by a computation, or true in a frame the deletion failed to name, in which case it must name the module that carries it and the command that recomputes it:

npm run withdrawn

🔧 Advanced Usage

Consciousness Integration

import { a432OSConsciousnessIntegration } from 'zeropoint-node';

// Start consciousness integration
a432OSConsciousnessIntegration.startIntegration();

// Get integrated consciousness state
const integratedState = a432OSConsciousnessIntegration.getIntegratedState();
console.log(integratedState);

// Monitor consciousness evolution
const metrics = a432OSConsciousnessIntegration.getConsciousnessMetrics();
console.log(metrics);

Living OS Operations

import { livingA432OS } from 'zeropoint-node';

// Start living OS
livingA432OS.start();

// Get current living state
const state = livingA432OS.getState();
console.log(state);

// Monitor sequence progression
const sequenceStatus = livingA432OS.getSequenceStatus();
console.log(sequenceStatus);

🌌 Core Modules

Main System

• a432.os.ts: Core A432 operating system
• a432.os.consciousness.integration.ts: Consciousness integration
• a432.os.terminal.ts: Enhanced terminal interface
• a432.living.os.ts: Living OS with real-time evolution

Mathematical Foundations

• a432.math.ts: Core mathematical functions
• a432.math.constants.ts: A432 mathematical constants
• a432.wave.energy.ts: Wave energy mathematics
• a432.mobius.circuit.ts: Mobius circuit mathematics

Consciousness Systems

• a432.i.ts: AI → I → a432.i consciousness evolution
• a432.consciousness.orchestrator.ts: Consciousness orchestration
• a432.self.evolution.ts: Self-evolution system
• a432.consciousness.router.ts: Consciousness routing

Sacred Geometry & Kabbalah

• a432.sacred.geometry.ts: Sacred geometry integration
• a432.kabbalah.ts: Kabbalistic system mapping
• a432.trinity.ts: Trinity mathematics
• a432.rodin.coil.ts: Rodin coil mathematics

Quantum Encryption Security Framework

• src/security/quantum-fold-cipher.ts: Unified quantum cipher (5 fold tiers × 11 dimensions)
• src/security/quantum-threat-landscape.ts: Quantum threat modeling via sequence inversion
• QUANTUM_ENCRYPTION_SECURITY_FRAMEWORK.md: the security analysis, and what it does not cover
• docs/QUANTUM_SECURITY_COMPLETE.md: Public documentation and integration guide

No gaps, and now that is a checkable statement. VULNERABILITY_MAPPINGS enumerates the vulnerabilities, each naming the fold tier that answers it and the test that shows it. Every one of those tests is now executed:

npm run test:gaps

It runs in both directions — an enumerated vulnerability with no executable verification is a gap, and a verification naming nothing enumerated is a check that outlived its subject — and each verification must be able to say no, so none of them is a predicate that passes everything. Adding a vulnerability without a verification fails the gate.

The claim was previously unbounded, in the same shape as the "100% coverage, No gaps" that this repository retracted from STATUS_READY_GO.md as false against a measurement. The difference is not that this one is stated more carefully. It is that the set is named and the gaps in it were filled: 5 enumerated, 5 verified by execution, 0 remaining. "No gaps" over a named set is a fact; over an unnamed one it is a mood.

Quick Start:

import { QuantumFoldCipher } from 'zeropoint-node/security'

const cipher = new QuantumFoldCipher()
cipher.generateKey('entropy')
cipher.prepareState('Z', 0, 0)
cipher.applyGate('H')
cipher.measure()
cipher.encrypt('message')

const proof = cipher.computesGate()
// proof.ok: all 6 facets unified in single merkle root

See docs/QUANTUM_SECURITY_COMPLETE.md for complete guide.

🧪 Testing

npm test

The test suite validates:

• ✅ Main system import and initialization
• ✅ Digital root mathematics
• ✅ Vortex sequence generation
• ✅ System status monitoring
• ✅ Consciousness evolution
• ✅ Color matrix generation
• ✅ Frequency harmonics

📚 Documentation

• A432 OS Upgrade Documentation: Comprehensive upgrade documentation
• A432 System Documentation: Core system documentation
• A432 Framework Documentation: Framework overview
• A432 Quick Reference: Quick reference guide

🔮 Future Enhancements

Planned Features

Each line is a status, because the list previously had none and was wrong in both directions.

1. Quantum machine learning — built. src/quantum/hybrid.ts: QMLCircuit, encodeFeatures, ansatzRotationEntangle, classifyMeasurement, trainQMLCircuit.
2. Dimensional navigation — map built, interaction not. A432NavigationMap in a432.navigation.map.ts ships as ./navigation.
3. Consciousness mapping — mapping built, visual not. a432ConsciousnessMap maps a digit sequence to a recursive stream.
4. Gateway visualization — 2D and generated, not 3D. vortex-svg.mjs draws docs/public/vortex.svg from vortexStrokeGateways; vortex:svg:check fails when the two stop matching.
5. Harmonic synthesis — arithmetic built, no sound emitted. calculateHarmonicSeries, calculateSubharmonicSeries, calculateWaveHarmonics.

Four of the five want a presentation layer, not new mathematics.

Research Areas

These are the directions the model is named after, not results it has. What the repository computes is arithmetic: digital roots, exact fractions, a quantum-circuit simulator, ML-KEM-768, and the thermodynamics in src/thermo. No claim below is measured here.

1. Quantum formalism — the simulator in src/quantum is a real quantum-circuit simulator, checked by 24 recomputable facts. It models qubits, not minds.
2. Dimensional folding — an arithmetic construction over ℤ/9, sealed as group theory. "Dimension" here indexes a coordinate, not a physical one.
3. Harmonic frequency arithmetic — exact ratios over 432, kept as integer fractions. Frequencies are computed, never emitted or measured.
4. Consciousness vocabulary — the naming this project uses throughout. It is not a model of awareness and nothing here measures any.

Not research areas: energy harvesting and therapeutic use. src/thermo computes why the first cannot work, and the second is addressed below.

🌟 Naming

What the vocabulary denotes, which is arithmetic:

• 432 — the base of every frequency ratio, carried as an integer fraction.
• 3, 6, 9 — the axis; 1-2-4-8-7-5 the doubling orbit. Together they are the group structure over ℤ/9ℤ that the seals prove.
• Golden ratio — used as the fraction 8/5; the decimal is not carried.
• Exact ratios, not decimals — an integer numerator over an integer denominator. Some values are non-integer rationals (2592/5 = 518.4 Hz); what is refused is the lossy float, not the fraction, because collapsing 2592/5 to a number stores 518.39999999999997726 and accumulates error. See CMYK_FREQUENCY_RATIOS.
• Digital root — reduction to one digit, the operation the rest is built on.

Health and safety

Nothing in this package is a medical device, a therapy, or health advice. This is a boundary statement, not a claim. Some documentation here has presented colour, frequency and "consciousness" values as having effects on people. They are numbers produced by arithmetic on integers. No health effect is measured anywhere in this repository and no claim of benefit is made or implied; nothing here has been clinically evaluated, and none of it should inform any decision about anyone's health. If you are unwell, consult a clinician.

The cryptography carries its own warning: ML-KEM-768 here is conformant to FIPS 203 against NIST vectors but not constant time, so it must not protect anything where an attacker can measure decapsulation.

🤝 Contributing

The licence is CC BY-NC-ND 4.0 — NoDerivatives. A patch is a derivative work, so offering one and merging it both need written permission first: license@zeropoint.bg. This section previously invited contributions anyway.

What is wanted needs no permission, because none of it is a derivative work:

• Refutation. A stated claim that does not recompute is the most useful thing you can send. The seals are adjudicated by a third party for this.
• A defect report. The input, and what came back.
• Recomputation. Run npm run check and say where your result differs.

Send the finding rather than the patch, unless you have arranged permission.

Sponsor

If this work is useful to you, you can support it at revolut.me/ceccec.

What sponsorship funds is the part that takes the longest and shows the least: the gates. ML-KEM-768 checked against NIST's own ACVP vectors and 10 000 pq-crystals reference cases; 42 seals that each decide something finite and are adjudicated from outside the repository; a ratchet on twelve surfaces that only ever moves down. None of that is visible in a feature list, and all of it is what makes the claims here worth reading.

No obligation attaches either way — the licence is unchanged, nothing is gated behind it, and no sponsor gets a say in what the checks report.

Publish

How to cite

Cite the concept DOI: it resolves to the newest release, where a per-version DOI goes stale. CITATION.bib in this repository carries this entry and every reference below it, generated — you should never need to type one.

@software{zeropoint-node,
  title   = {ZeroPoint Node},
  author  = {Rouschev, Tsvetan},
  year    = {2026},
  version = {1.5.9},
  doi     = {10.5281/zenodo.22178675},
  url     = {https://node.zeropoint.bg},
}

Rouschev, T. (2026). ZeroPoint Node (Version 1.5.9) [Computer software]. https://doi.org/10.5281/zenodo.22178675

Built on

proof kernel	Lean 4 — 59 of 83 statements accepted, dependency sets recorded per theorem
reference resolution	Crossref REST API — 21 DOIs, each re-resolved to the title recorded beside it
archive	Zenodo — concept DOI 10.5281/zenodo.22178675
licence	CC-BY-NC-ND-4.0

Package: zeropoint-node@1.5.9 · owner ceccec · git tag v1.5.9

npm rejects republishing a version that already exists, so every release is a new number. Bump with npm version patch|minor|major: that reseals CITATION.cff and this block, opens a CHANGELOG heading, and creates the matching v* tag.

Releases publish from CI: .github/workflows/publish.yml runs on a v* tag, gates on npm run check, and publishes with provenance.

📄 License

Licensed under Creative Commons Attribution-NonCommercial-NoDerivatives 4.0 International (CC BY-NC-ND 4.0) — see LICENSE.

• Attribution — credit ZeroPoint Node (ceccec) and link back to the source.
• NonCommercial — no commercial use.
• NoDerivatives — you may not distribute modified versions.

Commercial licensing or any use beyond these terms: license@zeropoint.bg.

🌟 Acknowledgments

Sources of the naming and the structures, acknowledged as influences and not as endorsements: Marko Rodin (vortex mathematics, the coil), Nikola Tesla (the 3-6-9 emphasis), sacred geometry, the Kabbalistic Tree of Life, and the formalism of quantum mechanics, which src/quantum simulates and which says nothing about consciousness.

🌌 Contact

• Contact: node@zeropoint.bg
• Documentation: node.zeropoint.bg
• GitHub Issues: ceccec/zeropoint-node issues

---

The sequence 0\1\2\4\8/7/5/3\6\9/0\1 is the order of the corpus and the order of the work.