MāyāPramāṇa: Quantum Sensor Digital Twins on MayaLucIA

C++ Track: Deployment

Wed, 25 Feb 2026 12:00:00 +0100

C++ is the deployment language of MāyāPramāṇa — the bridge from understanding to hardware. The same Bloch equation solver that runs interactively in Python and type-checks in Haskell must eventually execute in real-time on a Red Pitaya FPGA controlling an actual magnetometer.

Pure Core / Effectful Shell

The architecture separates:

Pure core — physics, signal processing, estimation algorithms. No I/O, no global state, no allocations in the hot path. These are the same functions as in Haskell, translated to C++ templates.
Effectful shell — hardware I/O (ADC/DAC), logging, calibration, network communication. Side effects are quarantined at the boundary.

This separation makes the core testable, portable, and comprehensible. The shell adapts to the deployment target (Red Pitaya, desktop simulation, or browser via WebAssembly).

Haskell Track: Executable Specification

Wed, 25 Feb 2026 12:00:00 +0100

Haskell is the specification language of MāyāPramāṇa. If the Python track asks “what happens?”, the Haskell track asks “what must happen?” Types encode physical units, function signatures encode signal flow, and QuickCheck properties encode the laws of physics.

Why Haskell for Physics?

Signal processing is inherently compositional. A lock-in amplifier is:

demodulate . lowpass . mix_with_reference . sample

Each stage is a pure function; the pipeline is their composition. Haskell makes this composition explicit and type-safe. A Kalman filter is a state monad; a PID controller is a feedback arrow. The language’s abstractions map directly onto the physics.

Interactive Demo: The Bloch Sphere

Wed, 25 Feb 2026 12:00:00 +0100

The Bloch sphere is the geometric representation of a two-level quantum system — every point on the sphere corresponds to a pure state, every point inside to a mixed state. Watching a spin precess on the Bloch sphere builds intuition that no equation can replace.

What the Demo Will Show

An interactive 3D Bloch sphere in the browser where the user can:

Apply a static field and watch Larmor precession
Turn on optical pumping and see the state spiral toward the poles
Add relaxation (T₁, T₂) and observe the magnetisation decay
Sweep the RF field and find the resonance condition
Compare the quantum spin dynamics with the Bloch vector approximation

Applications Context

The same physics drives optically pumped magnetometers (OPMs) used for:

Lesson 00: The Bloch Equations

Wed, 25 Feb 2026 12:00:00 +0100

“I think I can safely say that nobody understands quantum mechanics.” — Richard Feynman

The Bloch equations describe how a magnetic moment precesses, relaxes, and responds to resonant driving fields. They are the foundation of everything that follows in the magnetometer: optical pumping, Larmor precession, signal demodulation, and state estimation all reduce to solving these equations under different conditions.

What This Lesson Covers

Starting from a single spin-½ in a static magnetic field, the lesson builds up to the full Bloch vector equations through:

Python Track: Interactive Exploration

Wed, 25 Feb 2026 12:00:00 +0100

Python is the exploration language of MāyāPramāṇa — the medium for quick experiments, interactive plots, and org-babel notebooks. When you want to see what happens when you change the pump rate or sweep the RF frequency, you reach for Python.

Role in the Three-Language Architecture

Language	Role	Strength
Python	Exploration	Fast iteration, plotting, org-babel integration
Haskell	Specification	Type safety, QuickCheck property testing
C++	Deployment	Real-time performance, FPGA bridge

The Python track implements the same physics as Haskell and C++, but optimises for readability and interactivity rather than performance or type safety. NumPy and SciPy handle the numerics; Matplotlib handles the visualisation; org-babel handles the narrative.