QuantumLogics: Quantum-Inspired Computing on Classical Hardware

TL;DR: QuantumLogics is an open-source emulation stack that routes quantum-style workloads — combinatorial optimization, post-quantum crypto, tensor-network AI, molecular simulation — to ordinary CPUs via Python modules, served behind a single FastAPI "8-pillar" API. It's a research prototype, not a quantum computer, and the repo is honest about that boundary. Public at Shivay00001/quantumlogics.

The problem it solves

Real quantum hardware is scarce, expensive, and noisy. But a large family of "quantum" algorithms — simulated bifurcation for optimization, tensor-network methods for AI and chemistry, lattice-based cryptography — can be emulated or approximated on classical hardware today, and they solve real problems: logistics routing, portfolio optimization, molecular screening, post-quantum key generation.

QuantumLogics collects those techniques into one modular stack so a developer can call a quantum-inspired optimizer or a lattice crypto primitive over HTTP without standing up a quantum lab — or even a GPU cluster. Everything runs on CPU with PyTorch.

What the repository actually contains

I verified the tree on GitHub — 37 files. Ten modules, each a focused Python file (plus a Rust crate and a FastAPI service layer):

quantumlogics/
├── vq-logics-ai/        # tensor_nn.py        — tensor neural networks
├── vq-logics-api/       # main.py             — FastAPI 8-pillar service
├── vq-logics-chem/      # tensor_vqe.py       — tensor-network VQE for molecules
├── vq-logics-crypto/    # lwe_crypto.py       — LWE post-quantum cryptography
├── vq-logics-engine/    # Rust core (Cargo.toml, src/lib.rs)
├── vq-logics-fin/       # qae_finance.py      — amplitude-estimation Monte Carlo
├── vq-logics-geo/       # geo_router.py       — meta-routing
├── vq-logics-opt/       # bsb_solver.py, sb_solver.py, maxcut.py, benchmark.py
├── vq-logics-sim/       # dmrg_sim.py         — DMRG many-body simulation
├── vq-logics-sys/       # error_correction.py — surface-code QEC emulation
├── serve.py             # UQEOS API server entry point
└── docker-compose.yml   # full-stack deploy

Optimization: Ballistic Simulated Bifurcation

The strongest module is vq-logics-opt/bsb_solver.py, implementing Ballistic Simulated Bifurcation (Goto et al., 2021) — a classical algorithm inspired by quantum adiabatic evolution that outperforms standard greedy heuristics on Max-Cut and QUBO problems. The implementation is compact and real: it normalizes the coupling matrix by its spectral-radius estimate (max row sum), integrates the bSB differential equations (dy = -(a0 - a)·x + c0·interactions, hard-wall clamping of x to [-1, 1] with momentum kill on wall hits), runs a batch of 16 parallel trajectories on CPU, and returns the best spin configuration by energy. maxcut.py drives it end-to-end and even ships a result plot (maxcut_result.png); benchmark.py compares solvers.

Post-quantum cryptography: LWE

vq-logics-crypto/lwe_crypto.py implements Learning With Errors — the lattice problem underlying NIST's post-quantum standards — as a working keygen/encrypt demo: public matrix A (m×n), secret vector S, small error vector E, public key B = (A·S + E) mod q with n=256, q=3329, and single-bit encryption via a random ephemeral vector. It's educational-scale, not a standards implementation, but the math is the real LWE construction.

The other pillars

• vq-logics-ai/tensor_nn.py — tensor-network neural inference.
• vq-logics-chem/tensor_vqe.py — variational quantum eigensolver-style molecular simulation via tensor networks.
• vq-logics-sim/dmrg_sim.py — density-matrix renormalization group for many-body physics.
• vq-logics-fin/qae_finance.py — quantum amplitude-estimation-style Monte Carlo.
• vq-logics-sys/error_correction.py — surface-code error-correction emulation.
• vq-logics-geo/geo_router.py — meta-routing experiments.

These are compact proof-of-concept implementations (a few hundred bytes to ~2KB each) — real code with real math, not stubs, but research-grade rather than library-grade. The finance module is a good example of the genre: qae_finance.py is only 423 bytes, a minimal amplitude-estimation loop demonstrating the technique's shape rather than pricing real derivatives. Read these modules as executable lecture notes — each one teaches its algorithm by running it — and you'll get exactly what they're offering.

One API over all of it

vq-logics-api/main.py wraps every module in a FastAPI app ("UQEOS 8-Pillar API", v3.0.0) with eight typed endpoints: /api/v1/opt/maxcut, /api/v1/crypto/generate_keys, /api/v1/ai/infer, /api/v1/chem/simulate, /api/v1/sim/dmrg, /api/v1/fin/montecarlo, /api/v1/geo/route, /api/v1/sys/emulate_qec. The Max-Cut endpoint, for example, builds the coupling matrix from the request's edge list, runs the bSB solver with batch_size=16, and returns the best spins and energy as JSON. serve.py is the deploy entry point (uvicorn serve:app), and docker-compose.yml stands up the whole stack.

How to run it

pip install -r requirements.txt

# Run any module directly
python vq-logics-ai/tensor_nn.py
python vq-logics-opt/maxcut.py

# Or serve all 8 pillars over HTTP
uvicorn serve:app --host 0.0.0.0 --port 8000

# Docker (optional)
docker-compose up --build

Then POST an edge list to /api/v1/opt/maxcut and get a solved cut back — no quantum hardware, no GPU.

Honest status and roadmap

Status: research prototype, working. The Python modules genuinely implement the algorithms they name — I read the bSB solver and the LWE crypto end to end, and the FastAPI layer genuinely calls them. For learning quantum-inspired algorithms or prototyping optimization workloads, this is a legitimate starting point.

The honest caveats, verified in the tree:

1. The Rust engine is a placeholder. vq-logics-engine/src/lib.rs is the default Cargo template (add(2, 2) with its sample test) — the "Rust core" the README describes does not exist yet. All compute currently runs in the Python modules.
2. Emulation, not quantum advantage. Nothing here runs on a QPU or claims speedup over state-of-the-art classical solvers; the value is accessibility and education.
3. Module depth varies. The optimizer and crypto modules are substantive; several other pillars are thin wrappers awaiting expansion.

The roadmap that would make this serious: real Rust kernels behind the Python API (replacing the stub engine), published benchmarks of the bSB solver against classical baselines (OR-Tools, simulated annealing) on standard Max-Cut instances, packaging the modules as an installable library, and hardware-backed validation where a QPU is available (the author's D-Wave LaunchPad application is the natural next step for that).

Inside the solver zoo

The vq-logics-opt directory deserves a closer look because it's where the repo's engineering is densest. Alongside the ballistic solver sits sb_solver.py — the discrete simulated bifurcation variant — so the two can be compared head-to-head on the same instances. benchmark.py (~2.5KB) is the harness that runs that comparison, and maxcut.py is the end-to-end driver: generate or load a graph, solve, and write out the result plot that ships in the repo as maxcut_result.png.

This matters because simulated bifurcation is one of the few quantum-inspired algorithms with a credible claim to beating classical heuristics on certain combinatorial problems. Having both variants plus a benchmark harness in one directory turns the repo from a collection of scripts into an experiment bench: you can actually measure whether the ballistic variant's hard-wall dynamics outperform the discrete variant on your graph family, on your CPU, today.

What "emulation" honestly means here

It's worth being precise about the word "emulation," because the quantum space is full of inflated claims. Nothing in QuantumLogics runs on a quantum processing unit. What it does is implement algorithms whose design comes from quantum thinking — adiabatic evolution (simulated bifurcation), tensor-network contraction (VQE, DMRG, tensor NNs), lattice problems (LWE) — as classical programs.

That's less glamorous than "quantum computer in Python" and considerably more useful. A logistics team can call /api/v1/opt/maxcut this afternoon and get a better vehicle-routing partition than their greedy heuristic gives them. A student can read 60 lines of LWE code and understand the actual construction behind post-quantum cryptography standards. A researcher can prototype a tensor-network idea without learning a quantum SDK. The repo's README never claims quantum advantage, and the code never pretends to need a QPU — that restraint is a feature.

The service layer as a product decision

Wrapping eight research modules in one FastAPI app is a deliberate product decision, not just convenience. Each endpoint is a typed contract: edge lists in, spins and energy out; prompts in, inference results out. That turns "interesting scripts" into something a frontend, a pipeline, or another service can call. serve.py plus docker-compose.yml means the whole thing deploys as a unit, and the Dockerfile pins the environment so the PyTorch versions that the solvers were written against are the ones that run.

If you're evaluating this as infrastructure rather than education, the right question is the benchmark one: on your problem instances, does the bSB solver beat your current optimizer enough to justify an HTTP hop? The repo gives you the harness to answer that — benchmark.py is the most commercially relevant file in the project.

Frequently asked questions

Is this a real quantum computer?

No — and it doesn't claim to be. It's a classical emulation stack: quantum-inspired algorithms (simulated bifurcation, tensor networks, lattice crypto) running on ordinary CPUs via PyTorch. The point is accessibility, not quantum advantage.

What can I actually do with it today?

Solve Max-Cut/QUBO optimization problems over HTTP, generate LWE lattice keypairs, and experiment with tensor-network AI, VQE chemistry, DMRG physics, and surface-code error correction — all from one FastAPI service or by running the modules directly.

What's the catch?

The Rust acceleration layer is currently a stub, several modules are thin prototypes, and there are no published benchmarks against classical baselines yet. Treat it as a research codebase to build on, not a finished library.

The bottom line

QuantumLogics is a genuinely implemented tour of quantum-inspired computing on classical hardware, with its best work in the bSB optimizer and the LWE crypto module, served through a clean 8-endpoint API. The repo is public at github.com/Shivay00001/quantumlogics — start with python vq-logics-opt/maxcut.py and watch classical hardware do a quantum-style solve.