Version 4.1 - The Async Quantum Revolution

🎊 Released: January 2026

Q-Store v4.1.1 is now available! Revolutionary async execution architecture with real-world IonQ integration. Built on the solid foundation of v4.0.0’s verification, profiling, and visualization capabilities.

🎆 The 2026 Quantum Breakthrough

From Quantum-Enhanced to Quantum-First

Q-Store v4.1 represents a fundamental architectural transformation - moving from quantum as a helper to quantum as the primary compute engine. With async execution and optimized circuit batching, we achieve 10-20× speedup over sequential quantum execution.

Core Philosophy: “Make quantum the primary compute, with minimal classical overhead and zero-blocking async execution.”

Performance Reality Check

While v4.1 is dramatically faster than v4.0, classical GPUs (183-457× faster) remain the best choice for production training of large datasets. Quantum advantages emerge in specific use cases: small datasets, complex feature spaces, and research applications. See the honest performance comparison below.

GitHub Discussions: Share your thoughts on the v4.1 async design

🎯 What’s New in v4.1

Aspect	v4.0 (Current)	v4.1 (New)	Impact
Architecture	Quantum-enhanced classical	Quantum-first (70% quantum)	🎆 14× more quantum compute
Execution	Sequential circuits	Async parallel (10-20×)	🎊 Never blocks on I/O
Storage	Blocking I/O	Async Zarr + Parquet	🎁 Zero-blocking writes
Performance vs v4.0	Baseline	10-20× faster	🎉 Major improvement!
Performance vs GPU	Much slower	Still 85-183× slower	⚠️ GPU wins for speed
Layers	Mixed classical/quantum	Pure quantum pipeline	✨ Minimal classical overhead
PyTorch	Broken	Fixed + async support	🌟 Production-ready

Note: Real-world test with IonQ Simulator on Cats vs Dogs (1,000 images): 38.1 minutes vs 6-12 seconds for GPU

🎊 Key Innovations (Unique to Q-Store v4.1)

1. ⚡ AsyncQuantumExecutor: Non-blocking circuit execution with 10-20× throughput
2. 🎆 Quantum-First Layers: 70% quantum computation (vs 5% in v4.0)
3. 💾 Zero-Blocking Storage: Async Zarr checkpoints + Parquet metrics
4. 🚀 Local Chip Optimization: Direct quantum chip access eliminates network latency
5. 🎁 Fixed PyTorch Integration: QuantumLayer with proper async support
6. ✨ Multi-Basis Measurements: Extract more features per circuit execution

🎉 The Reality Check: When Quantum Wins

🎆 Two Different Comparisons

Understanding the Numbers

There are two different performance stories to understand:

1. v4.1 vs v4.0 (Internal quantum improvement): 10-20× faster
2. Quantum vs Classical GPU (The real competition): Performance depends on infrastructure

Comparison 1: v4.1 vs v4.0 (Quantum Internal) ✅

Fashion MNIST Training (1000 samples):

Q-Store v4.0 (Sequential):  ~45 minutes
Q-Store v4.1 (Async):       ~30-45 seconds (local chip)
                            ~3-4 minutes (cloud IonQ)

Result: 60-90× FASTER (local) or 10-15× FASTER (cloud)

What changed?

• v4.0: Submit circuit → wait → result → next circuit (sequential)
• v4.1: Submit 10-20 circuits at once → poll in background (parallel)
• Local chip: Eliminates 200ms network latency per batch

Comparison 2: Quantum vs Classical GPU (Real Competition) 🏆

Fashion MNIST Training (1000 samples):

Classical GPU (A100):           ~2-3 minutes
Q-Store v4.1 (Cloud IonQ):      ~3-4 minutes (0.7-1.0× slower)
Q-Store v4.1 (Local IonQ):      ~30-45 seconds (3-5× FASTER!) 🎊

Why is local quantum faster?

Factor	Cloud IonQ	Local IonQ	Advantage

🎁 Architecture Highlights

Quantum-First Layer Pipeline

v4.0 Architecture (5% quantum):

model = Sequential([
    Flatten(),                              # Classical
    Dense(128, activation='relu'),          # Classical (95% compute)
    Dense(64, activation='relu'),           # Classical (95% compute)
    QuantumLayer(n_qubits=4, depth=2),     # Quantum (5% compute)
    Dense(10, activation='softmax')         # Classical (95% compute)
])
# Total: 95% classical, 5% quantum

v4.1 Architecture (70% quantum) 🎊:

model = Sequential([
    Flatten(),                                    # Classical (5%)
    QuantumFeatureExtractor(n_qubits=8, depth=4), # Quantum (40%)
    QuantumPooling(n_qubits=4),                   # Quantum (15%)
    QuantumFeatureExtractor(n_qubits=4, depth=3), # Quantum (30%)
    QuantumReadout(n_qubits=4, n_classes=10)     # Quantum (5%)
])
# Total: 30% classical, 70% quantum ✨

🌟 New Quantum-First Layers

1. QuantumFeatureExtractor

Replaces classical Dense layers with quantum circuits:

from q_store.layers import QuantumFeatureExtractor

layer = QuantumFeatureExtractor(
    n_qubits=8,
    depth=4,
    entanglement='full',  # 'linear', 'full', 'circular'
    measurement_bases=['Z', 'X', 'Y'],  # Multi-basis for rich features
    backend='ionq'
)

# Async forward pass (never blocks!)
features = await layer.call_async(inputs)

# Output dimension: n_qubits × len(measurement_bases)
# Example: 8 qubits × 3 bases = 24 features per sample

Key innovations:

• ✨ Multi-basis measurements (more information per circuit)
• ⚡ Async execution (never blocks on IonQ latency)
• 🎁 Parallel submission (batch all samples at once)

2. QuantumNonlinearity

Quantum-native activation functions:

from q_store.layers import QuantumNonlinearity

layer = QuantumNonlinearity(
    n_qubits=6,
    nonlinearity_type='amplitude_damping',  # or 'phase_damping', 'parametric'
    strength=0.1
)

# Natural quantum nonlinearity - no classical compute!
output = await layer.call_async(inputs)

Advantage: Natural quantum nonlinearity vs classical ReLU/Tanh

3. QuantumPooling

Information-theoretically optimal compression:

from q_store.layers import QuantumPooling

layer = QuantumPooling(
    n_qubits=8,
    pool_size=2,
    pooling_type='partial_trace'  # or 'measurement'
)

# Reduces 8 qubits → 4 qubits
pooled = await layer.call_async(inputs)

4. QuantumReadout

Multi-class quantum measurement:

from q_store.layers import QuantumReadout

layer = QuantumReadout(
    n_qubits=4,
    n_classes=10,
    readout_type='computational'
)

# Returns class probabilities via Born rule
probs = await layer.call_async(features)  # Shape: (batch_size, n_classes)

⚡ AsyncQuantumExecutor

The Problem: IonQ Latency Kills Performance

Sequential Execution (v4.0):

for sample in batch:
    result = ionq.execute(circuit, sample)  # ⏱️ Wait 2s
    # Blocked! Cannot do anything else!
# Total: 32 samples × 2s = 64s per batch ❌

Async Execution (v4.1) 🎊:

async def train_batch(batch):
    # Submit ALL circuits at once (non-blocking)
    futures = [
        ionq.execute_async(circuit, sample)
        for sample in batch
    ]

    # Do other work while waiting!
    preprocess_next_batch()
    update_metrics()

    # Await all results
    results = await asyncio.gather(*futures)
    return results

# Total: 32 samples in parallel = ~2-4s per batch ✅
# Result: 16-32× faster!

AsyncQuantumExecutor Features

from q_store.runtime import AsyncQuantumExecutor

executor = AsyncQuantumExecutor(
    backend='ionq',
    max_concurrent=100,      # 100 circuits in flight
    batch_size=20,            # Submit 20 at once
    cache_size=1000           # LRU cache for results
)

# Non-blocking submission
future = await executor.submit(circuit)

# Batch submission
results = await executor.submit_batch(circuits)

# Automatic caching (instant for repeated circuits)
# Background polling (never blocks)
# Connection pooling (better utilization)

💾 Zero-Blocking Storage Architecture

The Problem: Storage I/O Blocks Training

v4.0 (blocking):

for batch in training:
    loss = train_batch(batch)

    # BLOCKS training loop! ⏱️
    save_checkpoint(model)       # ~500ms
    log_metrics(loss)            # ~100ms

# Lost 600ms per batch to I/O ❌

v4.1 (async) 🎊:

async def train():
    for batch in training:
        loss = await train_batch(batch)

        # Fire-and-forget (never blocks!)
        metrics_logger.log(loss)             # 0ms blocking ✅
        await checkpoint_manager.save(model) # Async in background ✅

# Zero blocking on I/O! 🎉

Storage Stack

from q_store.storage import (
    AsyncMetricsLogger,
    CheckpointManager,
    AsyncBuffer
)

# Async Parquet metrics (never blocks)
metrics = AsyncMetricsLogger(
    output_path='experiments/run_001/metrics.parquet',
    buffer_size=1000
)

await metrics.log(TrainingMetrics(
    epoch=1,
    step=100,
    train_loss=0.342,
    circuit_execution_time_ms=107,
    cost_usd=0.05
))

# Async Zarr checkpoints (compressed)
checkpoints = CheckpointManager(
    checkpoint_dir='experiments/run_001/checkpoints'
)

await checkpoints.save(
    epoch=10,
    model_state=model.state_dict(),
    optimizer_state=optimizer.state_dict()
)

Storage hierarchy:

1. L1 - In-Memory: Model parameters, gradients (O(1) ns access)
2. L2 - Async Buffer: Pending writes (O(1) μs access)
3. L3 - Zarr Checkpoints: Model state (async write, ms latency)
4. L4 - Parquet Metrics: Training telemetry (async append, ms latency)

🔧 Fixed PyTorch Integration

The Problem in v4.0

# v4.0: Broken!
from q_store.torch import QuantumLayer

layer = QuantumLayer(n_qubits=4, depth=2)
print(layer.n_parameters)  # AttributeError! ❌

The Solution in v4.1 🎊

# v4.1: Fixed + async!
from q_store.torch import QuantumLayer
import torch.nn as nn

class HybridQNN(nn.Module):
    def __init__(self):
        super().__init__()
        self.quantum = QuantumLayer(
            n_qubits=8,
            depth=4,
            backend='ionq'
        )
        self.output = nn.Linear(24, 10)  # 8 qubits × 3 bases = 24 features

    def forward(self, x):
        # Async execution with autograd support
        x = self.quantum(x)
        return self.output(x)

# Standard PyTorch training
model = HybridQNN()
optimizer = torch.optim.Adam(model.parameters())
criterion = nn.CrossEntropyLoss()

for epoch in range(10):
    for batch_x, batch_y in train_loader:
        optimizer.zero_grad()
        loss = criterion(model(batch_x), batch_y)
        loss.backward()  # Quantum gradients computed via SPSA
        optimizer.step()

What’s fixed:

• ✅ n_parameters property now works
• ✅ Async execution integrated with PyTorch autograd
• ✅ Proper gradient estimation via SPSA
• ✅ GPU tensor support (CUDA)
• ✅ DistributedDataParallel compatibility

🎊 When to Use Q-Store v4.1

✅ Excellent Use Cases

1. Quantum ML Research 🔬

• Testing quantum ML algorithms and architectures
• Publishing papers on quantum machine learning
• Algorithm development with free IonQ simulator
• Exploring quantum advantage in specific domains
• Benchmarking quantum vs classical approaches

2. Small Dataset Problems 📊

• <1,000 training samples where data is expensive
• Non-convex optimization landscapes
• Problems where classical gets stuck in local minima
• Better loss landscape exploration via quantum tunneling
• Comparable accuracy (58% vs 60% classical on quick tests)

3. Educational Applications 🎓

• Teaching quantum machine learning concepts
• University courses on quantum computing
• Hands-on quantum circuit design
• Understanding quantum-classical hybrid systems

4. Algorithm Prototyping 🧪

• Cost-free experimentation with quantum circuits
• Testing new quantum layer architectures
• Validating quantum ML hypotheses
• Zero cost with IonQ simulator

⚠️ Not Recommended For

1. Production Training at Scale ❌

• Large datasets (>1K samples)
• Time-critical applications
• Use classical GPUs: 183-457× faster, $0.01 vs $1,152+ cost
• Real QPU costs: $1,152 (Aria) to $4,480 (Forte) per run

2. Speed-Critical Applications ❌

• Real-time inference
• High-throughput services (>100 req/s)
• GPU training: 7.5s vs 38 minutes for 1K images
• Network latency dominates (55% of execution time)

3. Cost-Sensitive Deployments ❌

• Budget-constrained projects
• GPU cost: $0.01 per training run
• Quantum cost: $1,152-$4,480 per run on real QPU
• Simulator is free but 183-457× slower than GPU

📊 Honest Performance Table (Real Test Data)

Test: Cats vs Dogs (1,000 images, 5 epochs, 180×180×3 RGB)

Metric	NVIDIA H100	NVIDIA A100	NVIDIA V100	IonQ Cloud (v4.1.1)	Winner
Training Time	5s	7.5s	12.5s	2,288s (38.1 min)	🏆 GPU (457×)
Time per Epoch	1.0s	1.5s	2.5s	457s (7.6 min)	🏆 GPU (305×)
Samples/Second	40	26.7	16	0.35	🏆 GPU (114×)
Cost per Run	$0.009	$0.010	$0.012	$0 (simulator)	🏆 Quantum (free)
Cost (Real QPU)	$0.009	$0.010	$0.012	$1,152-$4,480	🏆 GPU (115,200×)
Energy	700W	400W	300W	50-80W	🏆 Quantum (5×)
Accuracy	60-70%	60-70%	60-70%	58.5%	🤝 Comparable
Loss Exploration	Local optima	Local optima	Local optima	Better	🏆 Quantum
Production Ready	✅ Yes	✅ Yes	✅ Yes	❌ Research only	🏆 GPU

🎆 Performance Optimizations

1. Adaptive Batch Scheduler

from q_store.runtime import AdaptiveBatchScheduler

scheduler = AdaptiveBatchScheduler(
    min_batch_size=10,
    max_batch_size=100,
    target_latency_ms=5000
)

# Adjusts batch size based on:
# - Queue depth
# - Circuit complexity
# - Historical latency
batch_size = scheduler.get_batch_size(
    queue_depth=15,
    circuit_complexity=50
)

2. Multi-Level Caching

from q_store.runtime import MultiLevelCache

cache = MultiLevelCache()

# L1: Hot parameters (100 entries, <1ms)
# L2: Compiled circuits (1000 entries, ~10ms)
# L3: Results (10000 entries, ~100ms)

result = cache.get_result(circuit_hash, params_hash)

# Cache statistics
stats = cache.stats()
print(f"Total hit rate: {stats['total_hit_rate']:.2%}")

3. Native Gate Compilation

from q_store.compiler import IonQNativeCompiler

compiler = IonQNativeCompiler()

# Compile to IonQ native gates (30% speedup!)
native_circuit = compiler.compile(circuit)

# Native gates: GPi(φ), GPi2(φ), MS(φ)
# vs universal gates: RY, RZ, CNOT

🔄 Migration from v4.0

What’s Compatible ✅

• ✅ All v4.0 verification APIs (circuit equivalence, properties, formal)
• ✅ All v4.0 profiling APIs (circuit profiler, performance analyzer)
• ✅ All v4.0 visualization APIs (circuit diagrams, Bloch sphere)
• ✅ TensorFlow integration (just add async support)
• ✅ Backend configurations

What’s New in v4.1 🎊

# v4.0: Sequential execution
from q_store.tf import QuantumLayer

layer = QuantumLayer(n_qubits=4)
output = layer(inputs)  # Blocks until done

# v4.1: Async execution (recommended!)
from q_store.layers import QuantumFeatureExtractor

layer = QuantumFeatureExtractor(n_qubits=8, depth=4)
output = await layer.call_async(inputs)  # Non-blocking! 🎊

# v4.1 also supports synchronous API for compatibility
output = layer.call_sync(inputs)  # Works, but slower

Migration Checklist

• Update to async training loops (optional, but 10-20× faster than v4.0)
• Replace classical Dense layers with QuantumFeatureExtractor (14× more quantum)
• Switch to AsyncMetricsLogger for storage (zero blocking)
• Enable CheckpointManager for Zarr checkpoints (compressed, async)
• For PyTorch: Update to fixed QuantumLayer (n_parameters works now!)
• Understand performance: GPU is faster for production, quantum excels at research
• Test with async executor (max_concurrent=100 recommended)

🎁 Installation

# Install Q-Store v4.1.1 (January 2026)
pip install q-store==4.1.1

# With async support
pip install q-store[async]==4.1.1

# Full installation (all backends)
pip install q-store[all]==4.1.1

# Development installation
git clone https://github.com/yucelz/q-store
cd q-store
pip install -e ".[dev,async]"

🎉 Quick Start Example

import asyncio
from q_store.layers import (
    QuantumFeatureExtractor,
    QuantumPooling,
    QuantumReadout
)
from q_store.runtime import AsyncQuantumExecutor
from q_store.storage import AsyncMetricsLogger, CheckpointManager

async def train_quantum_model():
    # Build quantum-first model (70% quantum!)
    model = Sequential([
        Flatten(),
        QuantumFeatureExtractor(n_qubits=8, depth=4, backend='ionq'),
        QuantumPooling(n_qubits=4),
        QuantumFeatureExtractor(n_qubits=4, depth=3),
        QuantumReadout(n_qubits=4, n_classes=10)
    ])

    # Setup async storage (never blocks!)
    metrics = AsyncMetricsLogger('experiments/run_001/metrics.parquet')
    checkpoints = CheckpointManager('experiments/run_001/checkpoints')

    # Async training loop
    for epoch in range(10):
        for batch_x, batch_y in train_loader:
            # Forward pass (async, non-blocking)
            predictions = await model.forward_async(batch_x)

            # Loss & gradients
            loss = criterion(predictions, batch_y)
            gradients = await model.backward_async(loss)

            # Optimizer step
            optimizer.step(gradients)

            # Log metrics (async, never blocks!)
            await metrics.log(TrainingMetrics(
                epoch=epoch,
                loss=loss.item(),
                circuit_execution_time_ms=107
            ))

        # Checkpoint (async, compressed)
        if epoch % 10 == 0:
            await checkpoints.save(epoch, model.state_dict())

    print("✅ Training complete! 10-20× faster than v4.0 🎊")
    print("Note: Classical GPUs are still 183-457× faster for large-scale training")

# Run async training
asyncio.run(train_quantum_model())

📈 Real Performance Report

For detailed performance analysis including:

• Real-world benchmark results (Cats vs Dogs dataset)
• Network latency analysis (55% overhead)
• Cost comparison (GPU vs QPU: $0.01 vs $1,152)
• Bottleneck identification and optimization recommendations
• When quantum makes sense vs when to use classical

See the full Q-Store v4.1.1 Performance Report

Ready to explore quantum ML? ⭐ Star us on GitHub and join the quantum research community! 🎊

🎆 Now Available

Q-Store v4.1.1 is available on PyPI! Perfect for quantum ML research, algorithm development, and educational applications. Free IonQ simulator access for unlimited experimentation.