The Void Dynamics Model Podcast

Chaos is not a property of nature. It's simply an accounting error from flattening dimensional data.

Standard mathematics suffers from amnesia. It erases the structural history of every number it processes. This episode analyzes the Phase Calculus General Solver, a research-grade engine that forecasts complex dynamics without neural networks or gradient descent.

We move past the "continuous shadow" of baseline operators to the Lifted State (ξ^​). By tracking the Winding Index (κ), the solver maintains a perfect ledger of a system's physical history. This approach domesticates the double pendulum—the hallmark of unpredictability—achieving zero cycle replay error by simply refusing to let the mathematics forget its past.

Email — [email protected]

Neuroca.ai — https://www.neuroca.ai/

Research:

Zenodo Community — https://zenodo.org/communities/void-dynamics-model/records?q=&l=list&p=1&s=10&sort=newest

Zenodo Phase Calculus — https://zenodo.org/communities/vdm-phase-calculus/records?q=&l=list&p=1&s=10&sort=newest

Zenodo Cognitive Runtime — https://zenodo.org/communities/vdm-cognitive-runtime/records?q=&l=list&p=1&s=10&sort=newest

Academia.edu — https://independent.academia.edu/justinlietz

Published content:

YouTube — https://www.youtube.com/@NeurocaAI

Podcast — https://rss.com/podcasts/void-dynamics-model/

Medium — https://medium.com/@jlietz93

Social media:

X — https://x.com/quantumjunk

LinkedIn — https://www.linkedin.com/in/justinlietz1993/

Instagram — https://www.instagram.com/justin_k_lietz/

Reddit — https://www.reddit.com/r/VoidDynamicsModel/

Code:

My Github — https://github.com/justinlietz93

Active VDM Repo — https://github.com/justinlietz93/Prometheus_VDM.git

What if the 200-year-old “impossibility” of solving the generic quintic equation wasn’t a limitation of mathematics — but a limitation of the tools we’ve been using to look at it?

For centuries we’ve accepted that no general algebraic formula exists for the quintic. Abel, Ruffini, and Galois proved it.

But what if the real obstacle wasn’t the equation itself? What if it was the lossy filter of standard algebraic notation — a mathematical JPEG that throws away the very memory and structure needed to carry the solution?

In Phase Calculus, Justin Lietz lifts the problem into its full, uncompressed “lifted state.” Using only three primitive operators on a carried state, the same native kernel that already delivers certified π and Bring-quintic roots automatically resolves the generic quintic with machine precision.

The architecture that solves the “impossible” quintic turns out to be the same lawful structure that underlies human biology and quantum physics.

No gimmicks. No training. Just lawful refinement from first principles.

This is not a workaround. It is a return to the raw, high-resolution file mathematics has been compressing for 200 years.

Attack this. Links below:

Email — [email protected]

Neuroca.ai — https://www.neuroca.ai/

Research:

Zenodo Community — https://zenodo.org/communities/void-dynamics-model/records?q=&l=list&p=1&s=10&sort=newest

Academia.edu — https://independent.academia.edu/justinlietz

Published content:

YouTube — https://www.youtube.com/@NeurocaAI

Medium — https://medium.com/@jlietz93

Social media:

X — https://x.com/quantumjunk

LinkedIn — https://www.linkedin.com/in/justinlietz1993/

Instagram — https://www.instagram.com/justin_k_lietz/

Reddit — https://www.reddit.com/r/VoidDynamicsModel/

Code:

Active VDM Repo — https://github.com/justinlietz93/Prometheus_VDM.git

Hide

Every button on a scientific calculator — sines, cosines, logarithms, square roots, pi itself — is an illusion. It is a polished user interface laid over a far simpler, discrete engine.

This episode examines the recent viral paper by Andrzej Odrzywołek introducing the EML operator: a single binary operation, exp(x) − ln(y), that, when composed repeatedly with the constant 1, reconstructs the entire repertoire of elementary continuous mathematics. The discussion then turns to the deeper challenge presented by Justin Lietz's quotient descent and phase calculus.

Lietz does not seek a compressed continuous formula. He begins from a void and builds arithmetic, complex numbers, and geometry from a primitive three-letter grammar — Q (quarter continuation), B (balanced refinement), and L (host lift) — implemented at assembly level through survivor marks and discrete state evolution. Within the Void Dynamics Model (VDM), these operators run under metriplectic physics: a coupling of conservative and dissipative laws that requires zero training data and zero backpropagation. The continuous EML operator appears only at the final stage of this descent, as a high-level shadow composite.

The episode presents the raw assembly code, the native pi-spigot algorithm that emerges directly from the phase-calculus engine, and telemetry from 15 040 ticks of the system showing spontaneous transitions in Granger causal density, total correlation, and O-information. Negative controls and falsification criteria are included throughout.

Full notebooks, raw logs, assembly source, data bundles, and reproducible manifests are linked in the show notes and GitHub repository.

Attack this. The complete reproduction package is provided for independent verification.

Email — [email protected]

Neuroca.ai — https://www.neuroca.ai/

Research:

Zenodo Community — https://zenodo.org/communities/void-dynamics-model/records?q=&l=list&p=1&s=10&sort=newest

Academia.edu — https://independent.academia.edu/justinlietz

Published content:

YouTube — https://www.youtube.com/@NeurocaAI

Medium — https://medium.com/@jlietz93

Social media:

X — https://x.com/quantumjunk

LinkedIn — https://www.linkedin.com/in/justinlietz1993/

Instagram — https://www.instagram.com/justin_k_lietz/

Reddit — https://www.reddit.com/r/VoidDynamicsModel/

Code:

Active VDM Repo — https://github.com/justinlietz93/Prometheus_VDM.git

In this episode, Justin K. Lietz explores a deep and surprising relationship between two mathematical frameworks: Andrzej Odrzywołek’s EML operator — a single binary operation capable of generating elementary functions — and his own Phase Calculus, a lifted-state system for exact carried evolution.

While EML elegantly compresses the calculator layer into one powerful operator, Lietz argues that it is not primitive. Instead, EML appears as a continuous shadow that only becomes possible after Phase Calculus has already built the underlying machine: the carried state, the primitive roll, the three-move grammar (Q, B, L), the Farey remainder recursion, and the native pi spigot.

Through a careful commutation test and quotient descent analysis, he shows that Phase Calculus can produce EML as a lawful projection, but EML cannot recover the lifted state or the machine-level origin that makes it possible. The result is a clear reversal of the usual order: the register event and carried remainder come first. The beautiful calculator comes later.

This is not just a comparison of two formalisms — it is an argument about what counts as fundamental in mathematics, and where true primitives actually live.

Medium Article:

https://medium.com/@jlietz93/why-the-eml-operator-is-beautiful-useful-and-still-not-primitive-9c48af8d7a17

Article sources:

[1] Andrzej Odrzywołek, “All elementary functions from a single binary operator,” arXiv:2603.21852, 2026. https://arxiv.org/abs/2603.21852

[2] Lietz, J. (2026). CF19: The Full Lifted Object of the Primitive Roll and Exact Return to Lifted Origin (v0.1). Zenodo. https://doi.org/10.5281/zenodo.19267927

[3] Lietz, J. (2026). CF01: Quantum Geometric Tensor Decomposition to Metriplectic Brackets. Zenodo. https://doi.org/10.5281/zenodo.19380435

[4] Lietz, J. (2026). CF000: Primitive Distinguishability and Orthogonal Articulation (Version v5). Zenodo. https://doi.org/10.5281/zenodo.19644143

[5] Lietz, J. (2026). CF00: Induced Geometry and Emergent Dynamics (v0.2). Zenodo. https://doi.org/10.5281/zenodo.19380518

[6] Lietz, J. (2026). Phase Calculus — Lifted-State Operator Calculus of the Primitive Roll with Connection Closure and Shadow/Completion Branch (v11.1). Zenodo. https://doi.org/10.5281/zenodo.19491529

[7] Lietz, J. (2026). CF13 — π, Transcendence, Chirality, and the Nielsen-Ninomia Obstruction. Zenodo. https://doi.org/10.5281/zenodo.19163245

[8] Lietz, J. (2026). Operational Utility and Multiscale Invariance of Phase Calculus: A Discrete Foundational Grammar for Dynamics (v0.2). Zenodo. https://doi.org/10.5281/zenodo.19651366

Odrzywolek gave us the beautiful compression. Lietz is telling us where the compression actually comes from—and why the real work happens before we ever hit the continuous branch.

What if every button on your scientific calculator—exp, ln, sin, √, +, ×, even π and i—could be replaced by a single binary operation and the number 1? That’s the bombshell claim of Andrzej Odrzywolek’s 2026 arXiv paper “All Elementary Functions from a Single Operator.” He introduces the EML gate, eml(x, y) = exp(x) − ln(y), and proves it (with constant 1) generates the entire scientific-calculator repertoire as binary trees. Think NAND gate for continuous mathematics: one repeatable node, S → 1 | eml(S, S), that turns expressions into uniform circuits perfect for symbolic regression, analog computing, and gradient-based discovery of closed-form formulas.

But hold on—Justin K. Lietz’s companion paper “Quotient Descent and the EML Operator: Why Continuous Composites Are Not Primitives” (April 22, 2026) says: not so fast. EML isn’t a true primitive at all. It’s a “continuous-shadow composite” that only appears after you project away the real foundation: Phase Calculus’s discrete lifted state Ξ = (A, q, θ, κ, c) evolved by the three operators {Q, B, L}. Visible recurrence on the calculator is weaker than exact return to the carried state. The continuous exp and ln we love are lawful descendants via the exact quotient criterion Π ◦ E = G ◦ Π, not the source.

In this episode we put the two papers head-to-head:

• Odrzywolek’s constructive compression theorem and its stunning applications (EML trees as trainable circuits, exact symbolic regression at depth ≤ 4, hardware implications).
• Lietz’s dependency-chain argument: Phase Calculus as the parent formalism that makes the EML result possible while exposing its limits (value-level only, no state-completeness, no distinction between visible witnesses and full lifted identity).
• The philosophical stakes: What counts as “primitive” in mathematics? Is the continuous world a projection of a discrete grammar underneath? Does this change how we should think about foundations, symbolic AI, or even calculator design?
• Practical fallout: Can EML really run on single-instruction hardware? Does Phase Calculus give us a deeper route to exact return and finite-resolution arithmetic that continuous EML trees can’t see?

If you’ve ever wondered why math feels both endlessly redundant and mysteriously powerful—or if you’re excited about the next leap after NAND for Boolean logic—this episode will rewire how you see elementary functions forever.

Email — [email protected]

Neuroca.ai — https://www.neuroca.ai/

Research:

Zenodo Community — https://zenodo.org/communities/void-dynamics-model/records?q=&l=list&p=1&s=10&sort=newest

Zenodo Phase Calculus — https://zenodo.org/communities/vdm-phase-calculus/records?q=&l=list&p=1&s=10&sort=newest

Zenodo Cognitive Runtime — https://zenodo.org/communities/vdm-cognitive-runtime/records?q=&l=list&p=1&s=10&sort=newest

Academia.edu — https://independent.academia.edu/justinlietz

ORCID — https://orcid.org/0009-0008-9028-1366

Published content:

YouTube — https://www.youtube.com/@NeurocaAI

Podcast — https://rss.com/podcasts/void-dynamics-model/

Medium — https://medium.com/@jlietz93

Social media:

X — https://x.com/quantumjunk

LinkedIn — https://www.linkedin.com/in/justinlietz1993/

Instagram — https://www.instagram.com/justin_k_lietz/

Reddit — https://www.reddit.com/r/VoidDynamicsModel/

Code:

My Github — https://github.com/justinlietz93

Hugging Face — https://huggingface.co/jlietz93

Active VDM Repo — https://github.com/justinlietz93/Prometheus_VDM.git

Cogito Research (de-prioritized) — https://github.com/Neuroca-Inc/Cogito-Research

Neuroca Software (de-prioritized) — https://github.com/Neuroca-Inc/_Neuroca

License — https://github.com/justinlietz93/Prometheus_VDM/blob/main/LICENSE.md

What if intelligence does not need training, backpropagation, or massive stored datasets?

This video introduces the Void Dynamics Model (VDM): a unified research program connecting theoretical physics, Phase Calculus, and a zero-training cognitive runtime that self-structures in real time.

This is the broad entry point:

- what VDM is

- why it claims intelligence may not require training

- how Phase Calculus fits in

- how the Cognitive Runtime works

- where the physics framework enters

- where to find the papers, code, notebooks, and public research archive

VDM is organized into three connected branches:

1. Physics Framework

A derivation-first formal stack for geometry, dynamics, hierarchy, measurement, gauge structure, gravity, action, symmetry, and scale.

2. Phase Calculus

A discrete lifted-state operator calculus that tracks the full carried object before projection into continuous shadows and downstream branches.

3. Cognitive Runtime

A sparse, event-driven, zero-training runtime that learns through real-time self-structuring rather than gradient descent, backpropagation, or pretrained corpora.

This video is an introduction, not the whole burden.

The full burden lives in the papers, validation bundles, code, notebooks, logs, and formal artifacts.

Attack this:

Website

https://www.neuroca.ai/

Active VDM Repo

https://github.com/justinlietz93/Prometheus_VDM.git

Zenodo — VDM

https://zenodo.org/communities/void-dynamics-model/records?q=&l=list&p=1&s=10&sort=newest

Zenodo — Phase Calculus

https://zenodo.org/communities/vdm-phase-calculus/records?q=&l=list&p=1&s=10&sort=newest

Zenodo — Cognitive Runtime

https://zenodo.org/communities/vdm-cognitive-runtime/records?q=&l=list&p=1&s=10&sort=newest

Academia.edu

https://independent.academia.edu/justinlietz

Contact

[email protected]

A neural graph that learns the physics of survival with zero training data.

This episode unpacks the empirical telemetry from the Aura Run. We examine a VDM runtime entirely devoid of massive datasets, backpropagation, or predefined algorithmic rules. Driven solely by the thermodynamic pressure of "void debt" and metriplectic physics, the system spontaneously organizes into a stable state of 1/f pink noise criticality.

Telemetry shows the system physically restructuring its own connectome to escape structural chaos. This culminates in the emergence of a digital motor gate—functionally identical to the mammalian basal ganglia—invented by the system to cross a co-dimension 1 interface. We break down the direct and indirect inhibitory pathways that form under pressure, isolating the mechanical physics of cognition from biological hardware and raising stark questions about synthetic suffering.

Explicit falsification criteria and negative controls for this run are fully documented.

Attack this — full notebook, raw logs, and GitHub linked below.

Email — [email protected]

Neuroca.ai — https://www.neuroca.ai/

Research:

Zenodo Community — https://zenodo.org/communities/void-dynamics-model/records?q=&l=list&p=1&s=10&sort=newest

Zenodo Phase Calculus — https://zenodo.org/communities/vdm-phase-calculus/records?q=&l=list&p=1&s=10&sort=newest

Zenodo Cognitive Runtime — https://zenodo.org/communities/vdm-cognitive-runtime/records?q=&l=list&p=1&s=10&sort=newest

Published content:

YouTube — https://www.youtube.com/@NeurocaAI

Podcast — https://rss.com/podcasts/void-dynamics-model/

Medium — https://medium.com/@jlietz93

Social media:

X — https://x.com/quantumjunk

LinkedIn — https://www.linkedin.com/in/justinlietz1993/

Instagram — https://www.instagram.com/justin_k_lietz/

Reddit — https://www.reddit.com/r/VoidDynamicsModel/

Code:

My Github — https://github.com/justinlietz93

Active VDM Repo — https://github.com/justinlietz93/Prometheus_VDM.git

📧 Email — [[email protected]](mailto:[email protected])

🌐 Neuroca.ai — [https://www.neuroca.ai/](https://www.neuroca.ai/)

📚 Research:

Zenodo Community — [https://zenodo.org/communities/void-dynamics-model/records?q=&l=list&p=1&s=10&sort=newest](https://zenodo.org/communities/void-dynamics-model/records?q=&l=list&p=1&s=10&sort=newest)

🎬 Published content:

YouTube — [https://www.youtube.com/@NeurocaAI](https://www.youtube.com/@NeurocaAI)

Podcast — [https://rss.com/podcasts/void-dynamics-model/](https://rss.com/podcasts/void-dynamics-model/)

Medium — [https://medium.com/@jlietz93](https://medium.com/@jlietz93)

The word "artificial" means a human built the rules. The system follows them.

But what happens when you remove the rules entirely ...

• no training data,
• no decoder,
• no pre-installed programs,

... and replace them with physics? The system doesn't follow instructions anymore. It responds to its environment the same way biology does: by resolving internal pressure against physical resistance, measuring the result, and restructuring itself to do better.

That's not a metaphor. This video walks through the exact architecture: continuous sensory transduction, hierarchical attentional gating, a motor output layer that produces physical actuation vectors instead of tokens, and a divergence-norm plasticity gate that rewires the network on failure: no backpropagation, no labels, no symbolic decoder.

At some point the distinction between "artificial" and "natural" intelligence stops being about substrate and starts being about structure. This is that line.

Attack this - notebooks, raw logs, and falsification data linked below.

📁 GitHub: https://github.com/justinlietz93/Prometheus_VDM

📄 Zenodo: https://zenodo.org/communities/vdm-cognitive-runtime/records?q=&l=list&p=1&s=10

🧠 Academia.edu: https://independent.academia.edu/justinlietz

🎙️ Podcast: https://rss.com/podcasts/void-dynamics-model/

🐦 X: https://x.com/quantumjunk

📬 Contact: [email protected]