Category: Post-Algebraic

ROOM (Read-Only-Once Memory) is a post-algebraic, quantum-inspired cryptographic primitive developed by QSymbolic LLC.

Modeled after a quantum measurement enforcing the no-cloning theorem, ROOM ensures that a stored value (e.g., a cryptographic key) can be read once only. On the first valid access, the value is released and the register collapses irreversibly within the same clock cycle. All subsequent reads return obfuscation (pseudorandom or noise-influenced replacement values).

This repository provides the reference Verilog modules for ROOM as described in the Post-Algebraic Cryptography patent filings.

https://github.com/fcunnane/QSymbolic

⸻

✨ Key Features • Read-once enforcement — secrets collapse on first qualified read. • Metadata gating — access requires matching basis, phase, tags, or timing. • Collapse latch — same-cycle disable after release. • Obfuscation source — pseudorandom or entropy-derived replacement values. • Peer-linked collapse — entangled cells propagate collapse for group rekeying. • Entropy harvesting — collapse jitter and metastability seed RNGs.

⸻

📂 Contents • collapse_cell.v — core ROOM cell with collapse latch + obfuscation. • metadata_collapse_register.v — adds metadata predicates (basis, phase, tags). • collapse_register_entangled.v — peer-linked collapse across cells. • collapse_register_keyexchange.v — ephemeral key release with KDF. • qkd_collapse_register.v — BB84-style collapse emulation. • qkd_entangled_pair.v — entangled pair register (E91-style). • mdi_qkd_top.v — measurement-device-independent (MDI) protocol demo. • collapse_rng.v — collapse-derived entropy source. • testbench.v — simulation environment.

⸻

🔒 Security Properties • Post-algebraic & post-quantum: independent of lattice/coding hardness assumptions. • Quantum-inspired: enforces a no-cloning principle at the hardware/software level. • QKD-like intrusion detectability: unauthorized reads collapse secrets into noise, measurable via error rates. • Low power, high efficiency: collapse + KDF cycle costs far less than lattice-based PQC or optical QKD. • Composable: works in FPGA, ASIC, SIM/secure elements, and software.

⸻

🛰️ Applications • Mobile / 6G radios — ultra-low-latency ephemeral rekeying. • Satellites & swarms — low-power, high-efficiency key release; peer collapse for group rekey. • Cloud KMS / HSMs — tamper-resistant ephemeral API/tenant keys. • IoT & secure boot — one-time provisioning and firmware authentication. • ZKPs & homomorphic encryption — collapse-backed entropy for protocols.

⸻

📜 License

This project is licensed under the PolyForm Noncommercial License 1.0.0. • ✅ Free for personal, research, academic, and other noncommercial purposes. • 🚫 Not permitted for commercial use (products, services, paid offerings) without a license.

For commercial licensing (semiconductors, telecom, satellite, defense, etc.), please contact: QSymbolic LLC — Francis X. Cunnane III 📧 frank@qsymbolic.com | 🌐 qsymbolic.com

⸻

https://github.com/fcunnane/QSymbolic

⚠️ Disclaimer: This software is provided “as is”, without warranty of any kind, express or implied.

Stage 1 – FPGA / Prototype (Now)

• Form: Verilog modules on FPGA (DE10 Nano, dev boards).
• Goal: Prove collapse-on-read, entanglement, and metadata enforcement in hardware.
• Value: Establish novelty + patent protection + demo viability.
• Users: Researchers, DARPA testbeds, cryptography labs.

Stage 2 – PCIe / External Accelerator (1–3 years)

• Form: ROOM implemented on a PCIe card (like GPUs or HSMs).
• Goal: Provide a drop-in “ROOM Engine” for servers. Keys collapse in hardware, but host only sees wrapped or ephemeral outputs.
• Value: Market entry for enterprises → “Hardware unclonable key accelerator.”
• Users: Banks, defense contractors, cloud hyperscalers (pilot programs).

Stage 3 – SoC Security Co-Processor (3–6 years)

• Form: ROOM integrated as a security block inside SoCs, like AES or SHA accelerators.
• Goal: Embed ROOM into ARM/Intel/AMD chipsets as a companion primitive for secure enclaves.
• Value: On-die collapse means no bus exposure; faster adoption in consumer devices (phones, laptops).
• Users: Mobile security (Apple Secure Enclave, Google Titan), TPM replacements.

Stage 4 – CPU Enclave Integration (6–10 years)

• Form: ROOM primitives available as ISA extensions (e.g., ROOM_LOAD, ROOM_ENTANGLE).
• Goal: Standardize ROOM as part of trusted execution environments (Intel SGX vNext, AMD SEV, ARM TrustZone+).
• Value: Cloud-scale adoption → ephemeral keys for SaaS, finance, military workloads.
• Users: Cloud providers, defense, healthcare, governments.

Stage 5 – Ubiquity (10+ years)

• Form: ROOM cells as standard CMOS memory primitive, like SRAM or DRAM cells.
• Goal: Every chip has ROOM at transistor level. Collapse enforced everywhere.
• Value: Universal “no-cloning on read” security baseline → hardware guarantees instead of software policies.
• Users: Everyone — from smartphones to satellites.

🚀 Strategic Takeaway

ROOM moves up the adoption ladder:

FPGA → PCIe card → SoC security core → CPU enclave → universal primitive.

At the CPU-enclave stage, ROOM becomes the de facto hardware standard for unclonable key lifecycles — the logical endpoint for post-algebraic cryptography.

For decades, digital security has relied on algebraic hardness assumptions: factorization, discrete logarithms, and lattices. From RSA to elliptic curves to today’s post-quantum algorithms, the foundation has always been mathematical. But what if the next leap forward doesn’t come from math at all?

What if security came from the hardware itself?

Enter CMOS Keys™ — a new class of hardware primitives that collapse on read, enforce forward secrecy by design, and represent the first wave of Post-Algebraic Cryptography.

Why Algebraic Security Isn’t Enough

• Cloneable: Traditional keys are just numbers in memory. If an attacker reads them once, they can copy them forever.
• Persistent: Keys stored in RAM, flash, or HSMs remain available until explicitly erased.
• Algebra-dependent: Even “post-quantum” cryptography still assumes attackers are limited by certain math problems.

These weaknesses all share a common trait: they treat keys as static data.

The CMOS Keys Breakthrough

CMOS Keys are not just data — they are circuits.

A CMOS Key is instantiated inside silicon as a read-once memory cell. The moment it is accessed under the correct condition, it delivers its true value and then collapses into an obfuscated state, enforced at the transistor level.

• 🔒 Read-Once: Keys can only be accessed a single time.
• ⏳ Ephemeral: The act of use destroys the original.
• 🛡 Unclonable: There is no static copy to extract or leak.
• ⚡ Standard CMOS: Built entirely in existing semiconductor processes — no exotic hardware required.

Post-Algebraic Cryptography

We call this paradigm Post-Algebraic Cryptography because it steps outside the algebraic assumptions that have defined cryptography since the 1970s.

Instead of securing secrets with mathematical difficulty, CMOS Keys secure them with physics and circuit behavior. A post-algebraic system does not care whether quantum computers succeed or fail, because its guarantees are not based on factoring, lattices, or any other algebraic structure.

This is cryptography anchored in hardware collapse, not algebra.

Applications of CMOS Keys

• Forward Secrecy by Default: Every key collapses after first use, enforcing perfect forward secrecy without complex protocols.
• Tamper-Resistant Hardware: CMOS Keys can’t be cloned, even with invasive attacks.
• HSMs and TPMs: A new generation of security modules where keys are never persistent.
• Cloud Security: Ephemeral keys that disappear after use, eliminating long-term exposure.
• Military & Critical Infrastructure: Secure communication without relying on fragile algebraic hardness assumptions.

Why Now?

The world is racing to prepare for the post-quantum era, but most efforts still depend on unproven algebraic hardness. CMOS Keys are different: they are manufacturable in today’s silicon fabs, deployable in existing security architectures, and provably eliminate entire categories of attack by design.

This isn’t just post-quantum.

This is post-algebraic.

Closing Vision

“We’ve tried to protect secrets with math for 50 years. CMOS Keys protect them with physics. This is bigger than post-quantum — this is Post-Algebraic Cryptography.”

The age of storable keys is ending. The age of CMOS Keys is beginning.

July 31, 2025

Virginia Beach, VA — Today, QSymbolic LLC is proud to announce the official patent submission for ROOM – Read Only Once Memory, a new hardware memory primitive built for the post-quantum era.

ROOM is a secure memory architecture that enforces one-time readout using deterministic CMOS logic. Upon first access, each ROOM register collapses irreversibly, making the stored value permanently inaccessible. No reset. No reuse. No cloning.

🔐 Built for What’s Next

In conventional systems, memory is reusable by design — and that’s a problem when the data is a cryptographic key, authentication secret, or ephemeral credential. ROOM addresses this by bringing quantum-inspired collapse behavior to classical hardware.

ROOM is engineered for:

• Air-gapped, tamper-evident key delivery
• Post-quantum and post-algebraic cryptography
• Secure embedded provisioning in zero-trust environments
• Symbolic entropy handling and deterministic collapse control
• Emulation of QKD-like guarantees in purely classical logic

Using a suite of patented primitives — including collapse enforcement, metadata-gated access, and entangled register behavior — ROOM establishes a new security baseline for sensitive memory.

📄 What’s Included in the Patent

Filed as a Continuation-in-Part (CIP) of the Triangle Symbolic Processing Framework (TSPF), the ROOM patent application includes:

• Collapse Primitive: Memory registers that self-destruct on read, enforceable in the same clock cycle
• Metadata Primitive: Registers that conditionally permit readout based on time, identity, or phase
• Entanglement Primitive: Interdependent memory collapse across registers for structured correlation
• Hardware-based key exchange workflows for post-quantum delivery
• Real-world implementation details in CMOS, ASIC, and FPGA

The system is suitable for integration into hardware security modules (HSMs), trusted platform modules (TPMs), secure microcontrollers, and defense-grade embedded platforms.

🧩 No Trademark, by Design

QSymbolic is not trademarking the word ROOM — intentionally.

We believe ROOM should become an industry-standard term, like RAM or ROM. We invite researchers, engineers, and hardware vendors to adopt the term ROOM to describe any read-once, collapse-enforced memory structure — with or without our reference design.

ROOM is not just a technology. It’s a behavior.

⚙️ What Comes Next

Now that the patent has been filed, QSymbolic will begin:

• Demonstrating ROOM on FPGA
• Publishing the ROOM specification and open HDL components
• Preparing submissions to peer-reviewed venues (e.g., NDSS 2026)
• Exploring licensing and partnership opportunities in secure hardware sectors

ROOM will also anchor QSymbolic’s upcoming secure key exchange appliance and memory security IP core offerings.

For inquiries, partnerships, or technical details, contact frank@qsymbolic.com or visit qsymbolic.com.

QSymbolic – Memory You Can’t Clone™

PATENT PENDING

Trust is Broken. Key Generation Shouldn’t Be.

In a world moving rapidly toward post-quantum cryptography, we’re still stuck with one of the oldest assumptions in security: just trust the box. Whether it’s an operating system, a TPM, a cloud HSM, or even a certified TRNG, we’ve been conditioned to believe that whatever spits out a cryptographic key has done so honestly.

But where’s the proof?

What we need — and what we’ve never truly had — is a verifiable entropy oracle: a system that not only generates cryptographic keys, but proves they were generated uniquely, freshly, and securely.

That’s what CollapseRAM is.

CollapseRAM: A New Class of Secure Entropy Hardware

CollapseRAM is a novel architecture based on symbolic computation. It generates entropy using symbolic registers in ambiguous states — akin to quantum superposition — and collapses them in a one-way, read-once fashion. Once a register collapses, its value is locked, and further reads yield a fixed bit.

But here’s the crucial difference: every collapse event is recorded, hashed (e.g. using SHA3), and signed or timestamped to produce a verifiable proof of entropy generation. This isn’t just keygen — this is provable entropy origination.

Each key generated by CollapseRAM:

• Is derived from non-reversible symbolic collapse
• Cannot be reused or replayed
• Is never exposed to system memory
• Is optionally wrapped with a post-quantum public key (e.g. Kyber)
• Produces a tamper-evident hash proof (e.g. of the form SHA3(key + timestamp + session_id))

The result is a key you can use — and prove was never seen, reused, or faked.

Why This Matters More Than Ever

For years, we’ve relied on HSMs, smartcards, and kernel APIs like /dev/random or getrandom() to give us our cryptographic backbone. These systems may be certified, but they all rely on the same basic trust model: if it came from the black box, it must be good.

CollapseRAM challenges that model.

With verifiable entropy collapse, you no longer need blind trust. Instead, you get:

• Proof that your key was fresh
• Proof that your key was unique
• Proof that your key never existed outside the appliance

That level of assurance isn’t just valuable — it’s necessary in a world where quantum threats are real and state-level actors have both motive and means to manipulate entropy.

Aligning With NIST and NSA Standards

CollapseRAM is designed to work within existing cryptographic frameworks:

• SP 800-90B: Meets and exceeds entropy source requirements
• FIPS 140-3: Enforces strict key lifecycle and separation
• FIPS 203 (Kyber): Wraps keys in post-quantum-safe envelopes
• CNSA 2.0: Suitable for use in national security systems

Whereas traditional HSMs may be compliant, they do not expose any verifiable entropy audit trail. CollapseRAM offers both compliance and accountability.

This Is More Than an HSM

CollapseRAM isn’t just another crypto box. It’s a fundamentally new concept:

• A read-once entropy appliance
• A symbolic register processor
• A verifiable key oracle
• A quantum-resistant trust anchor

It can generate AES-256 keys, deliver them wrapped via Kyber, and record a log that proves each key was freshly born and securely bound to the recipient.

And it works with today’s Internet stack — including TLS, VPNs, and encrypted messaging — while being future-ready for PQ-TLS and PQ-VPN.

What’s Next

CollapseRAM is real. It’s working. And it’s heading to NDSS.

If you’re a cryptographer, developer, or standards contributor, I invite you to explore the idea of provable entropy. Whether you’re building encrypted messaging apps, zero-trust infrastructure, or post-quantum VPNs, CollapseRAM can change the way you think about key generation.

Because in the end, it’s not just about trusting the box — it’s about building a world where we don’t have to.

For decades, cryptographic security has depended on algebra. Whether it’s factoring large primes, computing discrete logarithms, or solving structured lattice problems, most encryption systems rely on the hardness of mathematical problems. This includes not only traditional protocols like RSA and Diffie–Hellman, but also newer post-quantum candidates like Kyber, which is based on structured lattices and modular polynomials.

But all of these systems share a common vulnerability: they can be attacked by algorithms that exploit their underlying mathematical structures. Shor’s algorithm, for instance, breaks RSA and elliptic curve cryptography on a sufficiently powerful quantum computer. And even the most promising lattice-based systems are still fundamentally mathematical, meaning they remain within reach of future algebraic attacks, whether quantum or classical.

This raises a natural question: what if we moved beyond algebra entirely? What if our cryptographic systems didn’t rely on math at all—not even hard math, just no math?

This is the foundation of a new concept: post-algebraic key exchange. Rather than depending on structured mathematical problems to secure a key exchange, post-algebraic systems like CollapseRAM derive shared secrets from symbolic logic, entropy, and ephemeral memory behavior. These systems don’t use exponentiation, modular arithmetic, or polynomial operations. Instead, they use entropy inputs—such as time-stamped randomness—combined with symbolic memory registers that collapse in a one-time, irreversible way.

Here’s how it works in practice. Each party generates a blob of entropy, such as a SHA256 hash of current time, a device-specific fingerprint, and some randomness. They then derive a symbolic register based on a shared seed or session context. This register doesn’t store values in the usual sense—it represents a symbolic structure that collapses when read. Both parties combine their entropy blobs, hash them, and use that combined value to collapse the register. The result is a shared key. But—and this is key—once the collapse occurs, the register is consumed. It can’t be read again. It can’t be reused. This is known as “write-once, read-once” or WORO memory logic.

Because there’s no algebra involved, there’s nothing to invert. No equation to solve. No structure to attack. Even if an attacker records the entropy blobs, they cannot retroactively reconstruct the symbolic register or the exact collapse behavior unless they had access to it before it collapsed.

This makes post-algebraic systems fundamentally different from—and arguably more resilient than—existing cryptographic schemes. They are not just post-quantum. They are post-algebraic. They do not attempt to resist mathematical inversion. They avoid it altogether.

CollapseRAM is currently the leading example of this paradigm. It enforces ephemeral key exchange by design. It produces keys that are bound to entropy and symbolic state, not to algebraic coordinates. It’s fast, lightweight, memory-driven, and doesn’t require any special hardware to operate. In use cases where key reuse is dangerous or long-term storage of private keys is risky—such as in zero-trust environments, stateless servers, or secure enclave communication—post-algebraic systems offer real and practical benefits.

There’s still much work to be done. We need formal security models for these kinds of systems, and new analysis tools that don’t rely on algebraic reasoning. But the promise is clear. If cryptography is going to survive the coming decades, it may not just need to evolve beyond current mathematics. It may need to leave math behind altogether.

CollapseRAM is one step in that direction.

PATENT PENDING