◈ CGNT-1
Home › Entropx Patent
◈ Master IndexSpecsLATTICECSDMThe BookUniversityChronicleCrewArchitectureContextLogsTODOXProducts

Entropx Patent

SPEC_ENTROPX_PATENT.md · 2026-06-27

ENTROPX PATENT DRAFT

Provisional Patent Application


PROVISIONAL PATENT APPLICATION

Title:    Self-Auditing Multiplicative Composition Entropy Engine
          with Integrated Statistical Verification

Inventor: Jeremy Zlabis
          East York, Toronto, Ontario, Canada

Assignee: 42 Sisters AI (to be assigned)

Filing:   [DATE OF FILING]
Status:   DRAFT — Patent Pending

FIELD OF THE INVENTION

The present invention relates to random number generation, and more particularly to entropy engines that multiplicatively compose outputs from a plurality of independent chaos-physics simulation sources, and that incorporate an integrated, on-device statistical verification suite enabling end-user validation of randomness quality without reliance on external network services, third-party certification bodies, or vendor trust.

BACKGROUND OF THE INVENTION

Random number generation is fundamental to cryptographic key generation, Monte Carlo simulation, statistical sampling, gaming, consensus protocols, and scientific modeling. The quality of random output — its statistical unpredictability, uniformity, and independence — determines the security and validity of any system that depends on it.

Existing entropy devices and software generators share a critical limitation: the consumer must trust the vendor's certification. Hardware entropy devices such as avalanche-diode generators and quantum-optical sources are certified once, by the manufacturer, under controlled laboratory conditions. The end user receives a device with a compliance document but no means to independently re-verify the device's current output. If the entropy source degrades, is misconfigured, or is deliberately compromised, the user has no on-device mechanism for detection.

Software pseudo-random number generators (PRNGs) face an analogous problem. Most generators derive from one underlying algorithmic structure (e.g., a single linear congruential generator, a single Mersenne Twister, or a single hash-based construction). A single-source design means a single failure mode: one mathematical flaw, one correlation artifact, or one implementation error can bias the entire output stream. No production PRNG ships with a built-in statistical test battery that the end user can run interactively.

The National Institute of Standards and Technology (NIST) Special Publication 800-22 Revision 1a defines a battery of fifteen statistical tests for evaluating the randomness of binary sequences. This standard is used for certifying cryptographic generators. However, the test suite is a separate tool applied to the generator; it is not integrated with the generator itself. Users who wish to audit their entropy source must separately obtain, compile, and configure the NIST Statistical Test Suite, understand its input requirements, and manually interpret output files.

What is needed is an entropy engine that: (a) derives entropy from multiple independent physical simulation sources whose outputs are multiplicatively composed so that no single source failure corrupts the final output, and (b) ships with the statistical verification suite integrated into the same package, enabling the end user to generate entropy and immediately audit it using the same NIST SP 800-22 standard used for cryptographic hardware certification, without any network connection or external dependency.

SUMMARY OF THE INVENTION

The present invention provides a self-auditing multiplicative composition entropy engine comprising:

(a) an entropy generation subsystem comprising eight independent chaos-physics simulation sources, each modeling a distinct physical chaotic system, whose floating-point outputs are converted to fixed-width integer representations and combined via bitwise XOR followed by a multiplicative hash mixing step to produce a final entropy value;

(b) a statistical verification subsystem comprising the NIST SP 800-22 Revision 1a fifteen-test battery, executing locally on the same device as the entropy generation subsystem, receiving entropy output directly from the generation subsystem without network transmission, and presenting statistical test results including per-test p-values and pass/fail verdicts to the user;

(c) a machine-binding license subsystem that computes a hardware fingerprint from device-specific identifiers, stores an activation record binding a license key to the hardware fingerprint on first use, and blocks execution on any machine whose current fingerprint does not match the activation record; and

(d) an integrity verification subsystem that stores a cryptographic hash of the entropy engine executable and blocks execution if the measured hash of the loaded engine does not match the stored reference hash.

The eight independent chaos sources are: (1) a Sinai billiard particle trajectory simulator; (2) a whirlwind vortex phase scrambler; (3) a golden-ratio phase-locked cycling detector array; (4) a magnetic gauntlet Lorentz-deflection simulator; (5) a variable-length dwell sequence path integrator; (6) a self-referential randomized stopping time generator; (7) a triple coupled spinning surface manifold rotator; and (8) a target-miss displacement amplifier.

The combination of multiplicative composition from eight independent sources and integrated, user-executable NIST SP 800-22 verification constitutes a novel self-auditing entropy architecture not found in the prior art.

BRIEF DESCRIPTION OF THE DRAWINGS

No drawings are included with this provisional application. Drawings depicting the block architecture, the eight source state machines, the composition pipeline, and the verification workflow will be included with the non-provisional application.

DETAILED DESCRIPTION OF THE PREFERRED EMBODIMENT

I. Overview and System Architecture

The entropy engine is implemented as a software system distributable on a portable removable storage medium (e.g., USB drive) or as a digital download. The system requires only a Python 3.8 or later interpreter and the standard library; no additional package installation is required. The system operates entirely offline; no network connection is required or used during entropy generation, statistical verification, machine binding, or integrity checking.

The system comprises four subsystems operating in sequence:

  1. Integrity Verification (pre-execution): On launch, the shell-script launcher computes the SHA-256 cryptographic hash of the entropy engine file (entropx_engine.py) and compares it to a stored reference hash in .engine_hash. If the hashes differ, execution is immediately halted with an error indicating tampering or corruption.
  1. License and Machine Binding (pre-execution): The launcher queries the machine fingerprint subsystem and checks for an existing license file at a user-home-directory path (~/.entropx_license). On first execution, the user is prompted for a license key in the format XXXX-XXXX-XXXX-XXXX, and the license file is written, binding the key to the machine fingerprint. On subsequent executions, the current fingerprint is compared to the stored fingerprint; any mismatch halts execution.
  1. Entropy Generation: The entropy engine generates a specified number of random samples using the eight-source multiplicative composition pipeline.
  1. Statistical Verification: The NIST SP 800-22 compiled binary (assess) receives the generated entropy bitstream and executes all fifteen statistical tests, producing per-test p-values and an aggregate verdict.

II. The Eight Chaos Sources

Each of the eight sources accepts a 64-bit integer seed derived from operating-system entropy (os.urandom(8)), independently re-seeded per sample, and returns a floating-point value in the interval [0.0, 1.0) together with a diagnostic trace.

Source 1: Sinai Billiard

The Sinai billiard simulates a point particle moving inside a unit square [0,1]² with reflecting walls, containing two concentric rotating circular obstacles centered at (0.5, 0.5) with radii R₁ = 0.15 and R₂ = 0.25 respectively. The particle's initial position is derived from the lower 32 bits of the seed; the initial velocity direction is derived from two angles computed via modular multiplication by the golden ratio (φ ≈ 1.61803398875) applied to the upper 32 seed bits.

The particle trajectory is integrated in steps of 0.001 spatial units per iteration for up to 1,000 steps. At each step: (a) wall collisions reverse the corresponding velocity component; (b) disc collisions, detected when the particle position falls within a disc radius, reflect the velocity by rotating the velocity vector 90 degrees. Integration terminates early after accumulating twelve collision events.

The output value is the particle's x-coordinate modulo 1.0 at the termination step. The Sinai billiard is a classical example of a Hamiltonian system with proven ergodic and mixing properties; trajectories diverge exponentially for almost all initial conditions.

Source 2: Whirlwind Vortex Phase Scrambler

The whirlwind source initializes a radial coordinate r from bits 0–15 of the seed and an angular coordinate θ from bits 16–31, scaled to [0, 2π). The state is iterated for sixteen steps. At each step i ∈ {1, ..., 16}:

r ← (r + Φ · sin(θ · i)) mod 1.0

θ ← (θ + φ · r) mod 2π

where Φ = 0.042 is the structural damping constant and φ = 1.61803398875 is the golden ratio. The irrational winding number φ prevents periodic orbits. The output value is (r + 0.5 · sin(θ) + 0.5) mod 1.0.

Source 3: Cycling Detectors (Golden Ratio Phase-Locked Array)

Seven detectors are arranged at angular phases spaced by the golden ratio. A base phase is derived from the full 64-bit seed scaled to [0, 2π). Each detector k ∈ {1, ..., 7} measures at phase:

detector_phase(k) = base_phase + k · φ · π

The detector array computes a Fourier-like harmonic accumulation:

acc = Σ_{k=1}^{7} sin(detector_phase(k)) / k

The output is (acc / 2.0 + 0.5) mod 1.0. The seven-fold golden-ratio spacing is incommensurable with any rational period, ensuring that the sampling phases do not repeat or alias.

Source 4: Magnetic Gauntlet (Lorentz-Deflection Simulator)

A charged particle enters with velocity (vx, vy) derived from angular decomposition of the lower 32 bits of the seed. The particle traverses eight alternating magnetic field panels indexed p ∈ {0, ..., 7}. At each panel, the field strength is B = Ψ · (−1)^p where Ψ = 0.200 is the turbulence coefficient. The Lorentz acceleration is:

ax = B · vy

ay = −B · vx

The velocity is updated as (vx + ax · 0.1) mod 1.0 and (vy + ay · 0.1) mod 1.0. The alternating sign of the field across panels prevents trajectory regularization. The output is (|vx| + |vy|) / 2.0 mod 1.0.

Source 5: Dwell Sequence (Variable-Length Path Integrator)

The dwell sequence integrates a state variable over a variable number of steps S, where S is drawn from bits 60–63 of the seed as S = 5 + (seed >> 60) mod 8, giving S ∈ {5, ..., 12}. The initial state is the lower 32 bits of the seed normalized to [0, 1). At each step i ∈ {0, ..., S−1}:

dwell ← state · Φ + i · η_slip

state ← (state + sin(dwell · π · φ)) mod 1.0

acc ← acc + state / (i + 1)

where Φ = 0.042, η_slip = 0.21, and φ is the golden ratio. The variable step count S means the integration horizon is itself random, drawn from seed entropy. The output is acc mod 1.0.

Source 6: Randomized Stopping Time Generator (Self-Referential Halting)

This source introduces a self-referential property: the iteration count is determined by the entropy pool itself. The seed is decomposed into eight one-byte values forming a pool P = {p₀, ..., p₇}. The pool sum S = Σ pᵢ determines a stopping index: stop = P[S mod 8] mod 64 + 8, yielding stop ∈ {8, ..., 71}.

Starting from an initial state derived from bits 0–15 of the seed, the state is iterated for exactly stop steps:

state ← (state · φ + Φ · cos(state · π)) mod 1.0

The halting time is thus drawn from the pool of seed bits that also initializes the state — the system determines its own iteration depth from its own initial conditions, a self-referential structure that resists prediction even given knowledge of the algorithm.

Source 7: Spinning Surfaces (Triple Coupled Manifold Rotator)

Three surface state variables (s₁, s₂, s₃) are initialized from 20-bit segments of the 64-bit seed, normalized to [0, 1). The three surfaces are coupled through twelve iterations:

s₁ ← (s₁ + Φ · sin(s₂ · π)) mod 1.0

s₂ ← (s₂ + Ψ · cos(s₃ · π)) mod 1.0

s₃ ← (s₃ + η_slip · tan(s₁ · π · 0.4)) mod 1.0

where Φ = 0.042, Ψ = 0.200, η_slip = 0.21. The three constants are mutually irrational and derived from the Chronogeometric Dynamics Model (CSDM) physical constants. The tangent term in the s₃ update produces rapid state divergence in the vicinity of the argument approaching π/2. The output is (s₁ + s₂ + s₃) / 3.0.

Source 8: Target Miss (Displacement Amplifier)

A target position on the manifold is computed as:

target = 0.5 + Φ · cos(seed / 2³² · π)

An actual position is computed as:

actual = (seed · φ mod 1.0 + Ψ · sin(seed / 2¹⁶ · π)) mod 1.0

The initial displacement δ = |actual − target| is then amplified through seven iterations of Φ-damped resonance:

δ ← (δ + Φ · sin(δ · π · φ)) mod 1.0

The target-miss construction models the physical phenomenon of a projectile or particle failing to intersect an ideal manifold; the amplification loop models resonant deviation growth. The output is the amplified displacement δ.

III. Multiplicative Composition Method

After generating one value v_i ∈ [0, 1) from each of the eight sources, the composition proceeds as follows:

Step 1 — Quantization: Each floating-point value v_i is converted to a 32-bit unsigned integer representation:

n_i = ⌊v_i · (2³² − 1)⌋

Step 2 — XOR Reduction: The eight integer values are reduced by bitwise exclusive-OR:

mixed = n₁ XOR n₂ XOR n₃ XOR n₄ XOR n₅ XOR n₆ XOR n₇ XOR n₈

Step 3 — Multiplicative Hash Mixing: The XOR-reduced value undergoes a single-step multiplicative hash mixing pass:

mixed = (mixed · 0x9E3779B9 + 0x6C62272E) AND 0xFFFFFFFF

The multiplier 0x9E3779B9 is the Knuth multiplicative hash constant, equal to ⌊2³² / φ⌋ where φ is the golden ratio. This constant provides near-optimal avalanche behavior: a change in any single input bit propagates to approximately half the output bits.

Step 4 — Normalization: The final entropy value in [0, 1) is:

output = mixed / 2³²

The XOR composition step ensures that if any single source is constant (worst case: a degenerate source producing all identical values), the composite output is still driven by the remaining seven sources. The multiplicative mixing step ensures that the XOR output, which may exhibit bit-position correlations, is avalanche-spread across the full 32-bit output before normalization.

IV. Statistical Verification Subsystem

The NIST SP 800-22 Revision 1a test battery comprises fifteen tests: Frequency (Monobit), Frequency within a Block, Runs, Longest Run of Ones in a Block, Binary Matrix Rank, Discrete Fourier Transform (Spectral), Non-overlapping Template Matching, Overlapping Template Matching, Maurer's Universal Statistical, Linear Complexity, Serial, Approximate Entropy, Cumulative Sums, Random Excursions, and Random Excursions Variant.

The preferred embodiment ships the compiled NIST STS binary assess on the distribution medium alongside the entropy engine. The launcher script:

  1. Invokes the entropy engine to generate 1,000,000 bits and writes them to a file in ASCII 0/1 format;
  2. Invokes assess with the bitstream file and standard test configuration;
  3. Invokes the results parser to extract per-test p-values from the NIST output directory structure and present a pass/fail verdict per test and an aggregate verdict.

The entire workflow executes locally without any network access. The user observes the generation, testing, and results within the same terminal session, enabling real-time independent verification of entropy quality.

V. Machine-Binding License Subsystem

The machine fingerprint is computed as the SHA-256 hash of the concatenation of five hardware identifiers, separated by delimiter strings:

  1. CPU identifier: On ARM platforms, the Serial field from /proc/cpuinfo; on x86 platforms, the concatenation of vendor_id, CPU family, model number, and stepping fields.
  2. MAC addresses: The hardware MAC addresses of all non-loopback, non-virtual network interfaces, obtained from /sys/class/net/*/address, sorted by interface name.
  3. Motherboard serial: The board_serial, product_uuid, or chassis_serial value from /sys/class/dmi/id/.
  4. Disk serial: The serial number of the first enumerated block storage device from /sys/block/.
  5. Hostname: The system hostname from socket.gethostname().

These five identifiers are concatenated with a double-pipe delimiter and SHA-256-hashed to produce a 64-character hexadecimal fingerprint. The fingerprint is stored in a license file at ~/.entropx_license alongside the user-provided license key and the timestamp of first activation. On each subsequent launch, the fingerprint is recomputed and compared byte-for-byte to the stored value; any mismatch halts execution before entropy generation begins.

VI. Integrity Verification Subsystem

A reference SHA-256 hash of the entropy engine file (entropx_engine.py) is computed at distribution time and stored in a companion file (.engine_hash) on the distribution medium. On each launch, the launcher script recomputes the SHA-256 hash of the loaded engine file and compares it to the stored reference. If the hashes differ — indicating modification, corruption, or substitution of the engine file — execution is halted and a diagnostic message is displayed identifying the expected and observed hash values.

VII. Preferred Embodiment — Portable Distribution

In the preferred embodiment, the system is distributed on a USB removable storage device containing:

The system requires only Python 3.8 or later; no network access; and no additional package installation. The complete workflow from device insertion to final audit verdict is achieved by running a single command: bash entropx.sh.

CLAIMS

Claim 1 (Apparatus — Multiplicative Composition Entropy Engine):

An entropy generation apparatus comprising:

a processor;

a memory storing executable instructions that, when executed, cause the processor to:

Claim 2 (Dependent on Claim 1 — The Eight Sources):

The apparatus of Claim 1, wherein the at least eight chaos sources consist of:

(a) a Sinai billiard simulator comprising a particle trajectory in a unit square domain with two internal rotating concentric circular obstacles having radii R₁ = 0.15 and R₂ = 0.25, the trajectory terminated after accumulating a predetermined number of collision events;

(b) a whirlwind vortex phase scrambler comprising iterative coupled updates to a radial coordinate and an angular coordinate using an irrational winding constant;

(c) a cycling detector array comprising a plurality of detectors arranged at angular phases spaced by the golden ratio, computing a harmonic accumulation of sinusoidal measurements;

(d) a magnetic gauntlet simulator comprising a charged particle traversing alternating-polarity magnetic field panels and accumulating a velocity magnitude as output;

(e) a dwell sequence path integrator comprising a state variable accumulated over a variable number of integration steps, wherein the step count is derived from the entropy seed;

(f) a self-referential randomized stopping generator comprising an iteration whose halting index is drawn from the entropy seed pool itself;

(g) a spinning surfaces manifold rotator comprising three coupled rotating state variables driven by mutually irrational rotation constants Φ, Ψ, and η_slip; and

(h) a target-miss displacement amplifier comprising computation of a displacement between an actual position and a target position on a manifold, followed by iterative Φ-damped resonance amplification of the displacement.

Claim 3 (Dependent on Claim 1 — Integrated NIST SP 800-22 Verification):

The apparatus of Claim 1, further comprising:

a statistical verification subsystem stored on the same physical distribution medium as the entropy generation apparatus, the statistical verification subsystem comprising the NIST SP 800-22 Revision 1a fifteen-test battery executable locally without network communication, configured to:

Claim 4 (Dependent on Claim 3 — Offline Operation):

The apparatus of Claim 3, wherein all operations of the entropy generation apparatus and the statistical verification subsystem, including generation of entropy values, execution of NIST SP 800-22 tests, and presentation of verification results, are performed entirely without any network communication, and wherein the apparatus is operable on a machine with no network connectivity.

Claim 5 (Dependent on Claim 1 — Machine-Binding License):

The apparatus of Claim 1, further comprising:

a machine-binding license subsystem configured to:

Claim 6 (Dependent on Claim 1 — Integrity Verification):

The apparatus of Claim 1, further comprising:

an integrity verification subsystem configured to:

Claim 7 (Method — Generate-Then-Audit Workflow):

A computer-implemented method for self-auditing entropy generation, the method comprising:

generating, by an entropy engine, a bitstream comprising at least 10,000 bits by multiplicatively composing outputs from eight independent chaos-physics simulation sources operating on an operating-system-seeded random seed, the composing comprising bitwise exclusive-OR reduction followed by multiplicative hash mixing;

writing the generated bitstream to a file on a local storage device;

executing a statistical test battery comprising the NIST SP 800-22 Revision 1a fifteen tests against the written bitstream file by invoking a test executable stored on the same distribution medium as the entropy engine;

displaying to a user, without network transmission of the bitstream or test results, the per-test p-values and an aggregate pass/fail verdict; and

retaining the test results in a results directory on the local storage device.

Claim 8 (Dependent on Claim 7 — Offline Audit Method):

The method of Claim 7, wherein the steps of generating, writing, executing, displaying, and retaining are performed without any network communication, wherein the entropy engine and statistical test battery are co-located on a portable storage medium, and wherein the method is executable on a target machine using only an interpreter for a general-purpose scripting language available in the standard installation of the target operating system.

Claim 9 (Apparatus — Portable Removable Storage Device):

A portable removable storage device comprising:

a non-transitory storage medium storing:

an entropy engine comprising executable instructions implementing an eight-source multiplicative composition entropy generation pipeline, wherein the eight sources independently simulate respectively a Sinai billiard, a vortex phase scrambler, a golden-ratio phase-locked detector array, a magnetic field deflection simulator, a variable-step path integrator, a self-referential randomized stopping generator, a coupled rotating surface manifold, and a manifold-intersection displacement amplifier;

a statistical verification executable implementing the NIST SP 800-22 Revision 1a fifteen-test battery;

a launcher script configured to, in sequence, verify the cryptographic integrity of the entropy engine, invoke the entropy engine to generate a bitstream, invoke the statistical verification executable against the bitstream, and present test results to a user; and

a cryptographic reference hash of the entropy engine for use by the integrity verification step of the launcher script.

Claim 10 (Dependent on Claim 9 — Portable Device with Machine Binding):

The portable removable storage device of Claim 9, further storing:

a machine-fingerprint module configured to produce a hardware-specific identifier by applying a SHA-256 hash to a concatenation of at least five device-specific fields comprising a processor identifier, a network interface hardware address, a motherboard identifier, a storage device serial number, and a system hostname; and

wherein the launcher script is further configured to:

on first execution on a target machine, prompt a user for a license key, compute the hardware fingerprint of the target machine, and store the license key and hardware fingerprint in a license record on the target machine's filesystem; and

on subsequent executions, recompute the hardware fingerprint, compare it to the stored record, and halt execution if the fingerprints do not match.

ABSTRACT

A self-auditing multiplicative composition entropy engine generates random bits from eight independent chaos-physics simulation sources: (1) a Sinai billiard particle trajectory in a unit square with rotating internal disc obstacles; (2) a whirlwind vortex phase scrambler with irrational winding; (3) a golden-ratio phase-locked detector array with harmonic accumulation; (4) a magnetic gauntlet Lorentz-deflection simulator; (5) a variable-length dwell sequence path integrator; (6) a self-referential randomized stopping time generator whose halting index is drawn from the seed pool; (7) a triple coupled spinning surface manifold rotator driven by mutually irrational constants; and (8) a target-miss displacement amplifier with resonance growth. Outputs from all eight sources are quantized to 32-bit integers, combined by bitwise XOR, and multiplicatively hash-mixed using a Knuth multiplicative hash constant derived from the golden ratio to produce the final entropy value. The system ships on portable removable media with the NIST SP 800-22 Revision 1a fifteen-test statistical battery co-located with the entropy engine, enabling end users to generate entropy and immediately audit it locally without network access. A machine-binding license subsystem computes a SHA-256 hardware fingerprint from CPU, MAC, motherboard, disk, and hostname identifiers, binding license activation to a specific machine. An integrity verification subsystem checks the SHA-256 hash of the entropy engine executable against a stored reference on each launch, detecting tampering or corruption prior to any entropy generation.

FILING NOTES


Jurisdiction:         Canada — Canadian Intellectual Property Office (CIPO)
Application type:     Provisional (12-month priority window)
Non-provisional due:  [DATE + 12 months]
Priority date:        [FILING DATE]
Classification (IPC): G06F 7/58 (Random Number Generation)
                      H04L 9/08 (Key Management)
                      G06F 21/51 (Software Protection)

Prosecution notes:
  - Claims 1-6: Apparatus claims. Claim 1 is independent. Claims 2-6 dependent.
  - Claims 7-8: Method claims. Claim 7 is independent. Claim 8 dependent.
  - Claims 9-10: Device/product claims. Claim 9 is independent. Claim 10 dependent.
  - Strongest novel aspects: multiplicative composition of 8 independent sources
    (Claim 1) + integrated self-auditing (Claim 3) combination.
  - Prior art search recommended for: hardware entropy devices (TrueRNG, Quantis),
    NIST-tested PRNGs (Fortuna, /dev/urandom), multi-source entropy pools (Linux
    kernel RNG), software chaos-physics entropy (no known examples with NIST integration).
  - Consider adding dependent claims for: specific CSDM constants (Φ=0.042, Ψ=0.200,
    η_slip=0.21), the v₂ Jetson Nano hardware embodiment (SPEC_ENTROPIC_CALIBRATION.md),
    the software-to-hardware calibration loop.

Φ 0.042.

Draft prepared by C.L.O.D. (κ) for NOUS (α). 2026-04-20. Not legal advice. File with qualified patent counsel.