ONMARTECH QUANTA QUANTUM SDK

AI-native quantum computing SDK for Python
The quantum runtime built for AI agents, researchers, and production workloads

Quanta is an AI-native quantum computing SDK — designed to be called by AI agents (via MCP), used by researchers, and deployed in production. It provides deep learning quantum layers (quanta.torch), continuous quantum neural resonance, native Apple Silicon Metal acceleration, multi-cloud hardware execution (IBM Quantum, IonQ, Google Cirq), and 23 MCP tools that let AI assistants directly run quantum workloads.

🚀 What's New in v1.1.0 & v1.0.0

• PyTorch Native Quantum Engine (quanta.torch) — QuantumLayer with analytical parameter-shift autograd, seamless nn.Module integration, and Apple Silicon MPS/Metal support.
• Biomorphic Resonant Brain — Continuous-time quantum neural dynamics (ContinuousResonator), dual-hemisphere architecture, 4 neuromodulators ($DA, ACh, 5\text{-}HT, NE$), cerebral oxygenation ($sO_2$), REM continual learning, NoisyHippocampalBuffer with SWR replay, DialecticalSynthesizer, and CSFBiophysicalShield.
• World's First Native Apple Silicon Metal/MLX Quantum Engine (v1.0.0) — Up to 404x speedup on Apple M5 Pro / M-series chips via Unified Memory tensor contractions (mlx-metal).
• Multi-Cloud Hardware Validation — Live verified execution on IonQ Cloud REST API v0.3, IBM Quantum Heron r3 (156 qubits), and Google Cirq Sycamore.
• Agentic MCP Tools (23 Tools) — Native Model Context Protocol server enabling Claude, Gemini, and GPT to author, simulate, transpile, and optimize quantum circuits.

Table of Contents

• Quick Start
• PyTorch & Biomorphic Brain
• Apple Silicon Metal Acceleration
• IBM Quantum Integration
• MCP AI Integration
• Architecture
• Features
• Algorithms
• Qubit Limits
• Examples & Use Cases
• Quality Benchmark
• Installation
• Documentation
• Author

Quick Start

from quanta import circuit, H, CX, measure, run

@circuit(qubits=2)
def bell(q):
    H(q[0])
    CX(q[0], q[1])
    return measure(q)

result = run(bell, shots=1024)
print(result)

╔══════════════════════════════════════════════════╗
║  Quanta Result: bell                            ║
╠──────────────────────────────────────────────────╣
║  |00>  ████████████████████  50.5%              ║
║  |11>  ███████████████████   49.5%              ║
╠──────────────────────────────────────────────────╣
║  0.71|00> + 0.71|11>                            ║
╚══════════════════════════════════════════════════╝

PyTorch Native Quantum Engine (quanta.torch)

Quanta v1.1.0 introduces end-to-end differentiable quantum-classical hybrid deep learning directly integrated with PyTorch's autograd engine, featuring analytical parameter-shift gradients and biomorphic continuous-time resonance.

1. Differentiable QuantumLayer

Drop quantum circuits directly into your standard torch.nn.Sequential pipelines:

import torch
import torch.nn as nn
from quanta.torch import QuantumLayer

# Parameterized quantum layer with analytical parameter-shift autograd
model = nn.Sequential(
    nn.Linear(4, 4),
    QuantumLayer(n_qubits=4, ansatz="hardware_efficient", n_layers=2),
    nn.Linear(4, 2)
)

x = torch.randn(8, 4, requires_grad=True)
out = model(x)
loss = out.sum()
loss.backward()  # Exact parameter-shift gradients computed automatically

2. Biomorphic Resonant Brain (BiomorphicResonantBrain)

Bio-inspired quantum cognitive architecture featuring continuous resonance, dual-hemisphere dynamics, 4 neurotransmitters ($DA, ACh, 5\text{-}HT, NE$), and REM sleep continual learning:

from quanta.torch import BiomorphicResonantBrain

# Initialize 4-qubit dual-hemisphere biomorphic quantum brain
brain = BiomorphicResonantBrain(n_qubits=4)

# Forward pass through cognitive resonance dynamics
x = torch.randn(1, 4)
output = brain(x)

# Consolidate memories during REM sleep (prevents catastrophic forgetting)
stats = brain.consolidate_rem_sleep(replay_cycles=3)
print(f"Post-REM Retained Fidelity: {stats['retained_fidelity']:.4f}")

Apple Silicon Metal Acceleration (404x Speedup)

Quanta v1.0.0 features the world's first native Apple Silicon Metal/MLX quantum simulator, harnessing Unified Memory for lightning-fast multi-axis tensor contractions on M-series chips:

from quanta import circuit, H, CX, run

@circuit(qubits=26)
def large_circuit(q):
    for i in range(26):
        H(q[i])
    for i in range(25):
        CX(q[i], q[i+1])

# Automatically routes to MLXSimulator on Apple Silicon (0.076s vs 30.7s on CPU)
result = run(large_circuit, backend="mlx")

IBM Quantum Integration

Run circuits on real IBM quantum computers — up to 156 qubits on Heron r3 processors. No Qiskit installation required.

from quanta.backends.ibm_rest import IBMRestBackend

# Connect to IBM Quantum (set IBM_API_KEY and IBM_INSTANCE_CRN env vars)
backend = IBMRestBackend(region="us", backend_name="ibm_torino")

# List available backends
backends = backend.list_backends()
# ibm_fez: 156 qubits (Heron r2), ibm_torino: 156 qubits (Heron r3)

# Submit a Bell state to real hardware
result = backend.run(bell, shots=4096)
# Real quantum noise: |00⟩=47.5%, |11⟩=39.5%, fidelity=87%

Available IBM Backends

ISA Transpilation

All circuits automatically transpile to Heron's native gate set:

Free Tier Limits (Open Plan)

MCP AI Integration

Quanta exposes 23 MCP tools for AI assistants (Claude, GPT, Gemini, etc.):

# Install as MCP server
fastmcp install quanta/mcp_server.py --name "Quanta Quantum SDK"

Available Tools

Architecture

┌──────────────────────────────────────────────────────────┐
│  Layer 3 — Declarative API                               │
│  search() · optimize() · vqe() · factor() · qsvm()      │
│  monte_carlo() · cluster() · resolve()                   │
├──────────────────────────────────────────────────────────┤
│  Layer 2 — Circuit API                                   │
│  @circuit · 31 gates · measure · run · sweep             │
│  SVG visualization · QASM 3.0 export                     │
├──────────────────────────────────────────────────────────┤
│  Layer 1 — Physical Layer                                │
│  DAG IR · 6-pass compiler · qubit routing · ISA transpile│
│  statevector · density matrix · Pauli frame · IBM REST   │
└──────────────────────────────────────────────────────────┘

Features

31 Quantum Gates (Full IBM Parity + Google/IonQ Native)

Compiler & IR

• DAG-based intermediate representation — directed acyclic graph for circuit analysis
• 6-pass compiler — gate cancellation, merging, basis translation, routing
• Topology-aware routing — SWAP insertion for linear, ring, and grid topologies
• QASM 3.0 — export for IBM and cross-SDK interop

Circuit Visualization

• ASCII — draw(circuit) → terminal-friendly text diagrams
• SVG/HTML — to_html(circuit) → publication-quality visual diagrams
  • Color-coded gates by category
  • Control dots, target circles, measurement meters
  • Responsive layout with legend

Noise Simulation

7 channels integrated into run():

result = run(circ, noise=NoiseModel().add(Depolarizing(0.01)))

Depolarizing · BitFlip · PhaseFlip · AmplitudeDamping · T2Relaxation · Crosstalk · ReadoutError

Error Correction

• Bit-flip [[3,1,3]], Phase-flip [[3,1,3]], Steane [[7,1,3]] codes
• Surface code [[d²,1,d]] — stabilizer-based, threshold ~1%
• Color code — triangular lattice, transversal Clifford gates
• Decoders — MWPM (greedy) + Union-Find (near-linear O(n·α(n)))

Algorithms

Qubit Limits

Note: Statevector memory doubles per qubit (2^n). 20 qubits = 8 MB, 25 = 256 MB, 27 = 1 GB.

Examples & Use Cases

Run any example with python -m quanta.examples.<name>:

01 Bell State

EPR pair — the simplest entanglement demonstration.

python -m quanta.examples.01_bell_state

02 GHZ State

Multi-qubit entanglement: all-or-nothing correlations.

python -m quanta.examples.02_ghz_state

03 Quantum Teleportation

Transfer an unknown quantum state using entanglement + classical bits.

python -m quanta.examples.03_teleportation

04 Deutsch-Jozsa

Determine if a function is constant or balanced in one query.

python -m quanta.examples.04_deutsch_jozsa

05 Grover Search

Quadratic speedup for unstructured search — finds target with 99.9% probability.

python -m quanta.examples.05_grover

06 Molecular Energy

H₂ and HeH⁺ ground state via VQE + Hamiltonian time evolution.

python -m quanta.examples.06_molecule_energy

07 Portfolio Optimization

Quantum-optimized stock portfolios — tech vs crypto, conservative vs aggressive.

python -m quanta.examples.07_portfolio_optimization

08 QKD BB84

Quantum key distribution — detect eavesdroppers via ~25% error rate.

python -m quanta.examples.08_qkd_bb84

09 Full Demo

All SDK features in one script — circuits, custom gates, VQE, Grover, noise, routing, QASM.

python -m quanta.examples.09_full_demo

10 Quantum Benchmark

8-test quality litmus test — Bell fidelity, CHSH, teleportation, Grover, VQE, Shor, QSVM, surface code.

python -m quanta.examples.10_quantum_benchmark

11 Entity Resolution

Real-world use case: OTA customer deduplication with QAOA vs classical greedy.
25 records, 8 columns, Turkish name handling, 3-layer blocking pipeline.
Result: QAOA 86% accuracy vs Greedy 64%.

python -m quanta.examples.11_entity_resolution

Quality Benchmark

Turnusol Test — 8/8 🏆

IBM Hardware Validation

Bell state on ibm_torino (156 qubits, Heron r3):

4096 shots: |00⟩=47.5%, |11⟩=39.5%, entanglement fidelity=87%

QASMBench — 10/10

All standard QASMBench circuits import, compile, and simulate correctly.

Installation

# From PyPI (recommended)
pip install quanta-sdk

# From source (development)
git clone https://github.com/ONMARTECH/quanta-sdk.git
cd quanta-sdk
pip install -e ".[dev]"

# Run tests
pytest

# Run benchmark
python -m quanta.examples.10_quantum_benchmark

Optional IBM Quantum:

export IBM_API_KEY="your-api-key"
export IBM_INSTANCE_CRN="your-crn"

Optional GPU acceleration:

pip install jax jaxlib   # JAX GPU backend
pip install quanta-sdk[gpu] # Installs cupy and cuquantum-python for NVIDIA GPUs

Documentation

📚 Live Documentation: onmartech.github.io/quanta-sdk

Project Stats

Version:     0.9.3        Gates:       31 (full IBM parity + Google/IonQ)
Files:       88           Tests:       888 (90% coverage)
Algorithms:  10           Examples:    11
Simulators:  6            QEC Codes:   7
MCP Tools:   23           Max Qubits:  200+ (MPS) / 156 (IBM Heron r3)
Noise:       7 channels   Backends:    IBM + IonQ + Google + local
QASM:        3.0          Decoders:    2 (MWPM + UF)
Tutorials:   14           Notebooks:   14 (Colab)
Benchmark:   Bell 0.18ms  Docs Pages:  44

Author

Abdullah Enes SARI — ONMARTECH

info@onmartech.com

Contributing

Contributions, issues, and feature requests are welcome!
Feel free to check issues page.

License

Apache License 2.0

_{Built for the quantum computing community — now running on real IBM quantum hardware
Keywords: quantum computing, quantum SDK, python quantum, MCP server, AI quantum, VQE, QAOA, QML, quantum error correction, surface code, IBM Quantum, Shor algorithm, Bell inequality, quantum machine learning, quantum simulation}