Skip to content

Backends API Reference

This module provides quantum computing backend interfaces for QGANS Pro, supporting multiple quantum frameworks.

Base Backend

The abstract base class for all quantum backends.

QuantumBackend

class QuantumBackend:
    """
    Abstract base class for quantum computing backends.

    Provides a unified interface for different quantum computing
    frameworks like Qiskit, PennyLane, Cirq, etc.
    """

Methods

is_available()

Check if the backend is available and properly configured.

Returns:

  • bool: True if backend is available
get_device_list()

Get list of available quantum devices.

Returns:

  • List[str]: Available device names
create_circuit(n_qubits, **kwargs)

Create a new quantum circuit.

Parameters:

  • n_qubits: Number of qubits
  • **kwargs: Backend-specific parameters

Returns:

  • Circuit object (backend-dependent)
execute_circuit(circuit, shots=1024)

Execute a quantum circuit.

Parameters:

  • circuit: Quantum circuit to execute
  • shots: Number of measurement shots

Returns:

  • Execution results

Qiskit Backend

Backend implementation for IBM Qiskit framework.

QiskitBackend

class QiskitBackend(QuantumBackend):
    """
    Qiskit backend for quantum circuit execution.

    Supports IBM Quantum devices, simulators, and local backends.
    """

Usage Examples

Basic Qiskit Setup

from qgans_pro.backends import QiskitBackend

# Initialize Qiskit backend
backend = QiskitBackend(
    device="aer_simulator",  # Local simulator
    shots=1024,
    optimization_level=1
)

# Check availability
if backend.is_available():
    print("Qiskit backend ready!")

# List available devices
devices = backend.get_device_list()
print(f"Available devices: {devices}")

IBM Quantum Hardware

# Connect to IBM Quantum hardware
backend = QiskitBackend(
    device="ibmq_qasm_simulator",
    token="your_ibm_token",  # Optional if saved in config
    hub="ibm-q",
    group="open",
    project="main",
    shots=8192
)

# Create and execute circuit
circuit = backend.create_circuit(n_qubits=5)
results = backend.execute_circuit(circuit)

Advanced Configuration

# Advanced Qiskit configuration
backend = QiskitBackend(
    device="aer_simulator",
    backend_options={
        "method": "statevector",
        "precision": "double",
        "max_parallel_threads": 4
    },
    noise_model="fake_melbourne",  # Realistic noise simulation
    error_mitigation=True
)

Supported Devices

Simulators:

  • aer_simulator: General purpose simulator
  • qasm_simulator: QASM-based simulator
  • statevector_simulator: Statevector simulator
  • unitary_simulator: Unitary matrix simulator

Hardware: (Requires IBM Quantum account)

  • ibmq_qasm_simulator: Cloud simulator
  • ibmq_*: Various IBM Quantum processors

Methods

create_parameterized_circuit(n_qubits, n_layers, entanglement="linear")

Create a parameterized quantum circuit for GAN training.

Parameters:

  • n_qubits: Number of qubits
  • n_layers: Number of circuit layers
  • entanglement: Entanglement pattern ("linear", "circular", "full")

Returns:

  • ParameterizedCircuit: Qiskit parameterized circuit

apply_noise_model(noise_model)

Apply noise model to simulate realistic quantum hardware.

Parameters:

  • noise_model: Qiskit noise model or preset name

optimize_circuit(circuit, level=1)

Optimize quantum circuit for execution.

Parameters:

  • circuit: Quantum circuit to optimize
  • level: Optimization level (0-3)

Returns:

  • Optimized quantum circuit

PennyLane Backend

Backend implementation for Xanadu PennyLane framework.

PennyLaneBackend

class PennyLaneBackend(QuantumBackend):
    """
    PennyLane backend for quantum-classical hybrid computing.

    Supports various quantum devices and automatic differentiation.
    """

Usage Examples

Basic PennyLane Setup

from qgans_pro.backends import PennyLaneBackend

# Initialize PennyLane backend
backend = PennyLaneBackend(
    device="default.qubit",
    shots=None,  # Use exact simulation
    diff_method="best"  # Automatic differentiation
)

# Check available devices
print(f"Available devices: {backend.get_device_list()}")

Hardware Integration

# Connect to quantum hardware via PennyLane
backend = PennyLaneBackend(
    device="strawberryfields.fock",  # Photonic hardware
    cutoff_dim=10,
    shots=1000
)

# Or use other hardware backends
backend = PennyLaneBackend(
    device="qiskit.aer",  # Qiskit via PennyLane
    backend="aer_simulator"
)

Gradient Computation

# Enable automatic differentiation
backend = PennyLaneBackend(
    device="default.qubit",
    diff_method="parameter-shift",  # or "adjoint", "finite-diff"
    shots=None
)

# Create differentiable quantum function
qnode = backend.create_qnode(
    circuit_fn=my_circuit,
    n_qubits=4,
    trainable_params=True
)

# Compute gradients automatically
import pennylane as qml
gradient_fn = qml.grad(qnode)
gradients = gradient_fn(parameters)

Supported Devices

Simulators:

  • default.qubit: Default qubit simulator
  • default.mixed: Mixed state simulator
  • lightning.qubit: Fast C++ simulator
  • strawberryfields.fock: Photonic simulator

Hardware:

  • strawberryfields.tf: Tensorflow quantum
  • qiskit.aer: Qiskit integration
  • cirq.simulator: Cirq integration

Methods

create_qnode(circuit_fn, device, **kwargs)

Create a PennyLane QNode for automatic differentiation.

Parameters:

  • circuit_fn: Python function defining the circuit
  • device: PennyLane device
  • **kwargs: Additional QNode parameters

Returns:

  • QNode: PennyLane quantum node

enable_automatic_differentiation(method="best")

Enable automatic differentiation for gradients.

Parameters:

  • method: Differentiation method ("parameter-shift", "adjoint", "finite-diff")

set_shots(shots)

Set number of shots for sampling-based execution.

Parameters:

  • shots: Number of shots (None for exact simulation)

Backend Factory

Utilities for creating and managing backends.

create_backend(name, **kwargs)

Factory function to create backend instances.

from qgans_pro.backends import create_backend

# Create Qiskit backend
qiskit_backend = create_backend(
    name="qiskit",
    device="aer_simulator",
    shots=1024
)

# Create PennyLane backend
pennylane_backend = create_backend(
    name="pennylane",
    device="default.qubit",
    diff_method="adjoint"
)

BackendManager

Manage multiple backends simultaneously.

from qgans_pro.backends import BackendManager

# Initialize backend manager
manager = BackendManager()

# Add backends
manager.add_backend("qiskit_sim", QiskitBackend(device="aer_simulator"))
manager.add_backend("qiskit_hw", QiskitBackend(device="ibmq_qasm_simulator"))
manager.add_backend("pennylane", PennyLaneBackend(device="default.qubit"))

# Switch between backends
manager.set_active_backend("qiskit_sim")
circuit = manager.create_circuit(n_qubits=5)

# Execute on multiple backends
results = manager.execute_on_all_backends(circuit)

Backend Comparison

Compare performance across different backends:

from qgans_pro.backends import BackendBenchmark

# Benchmark backends
benchmark = BackendBenchmark()

# Add backends to compare
benchmark.add_backend("Qiskit", qiskit_backend)
benchmark.add_backend("PennyLane", pennylane_backend)

# Run benchmark
results = benchmark.run_benchmark(
    circuit_sizes=[4, 6, 8, 10],
    circuit_depths=[2, 4, 6],
    shots=[1024, 8192],
    metrics=["execution_time", "memory_usage", "accuracy"]
)

# Visualize results
benchmark.plot_results(results)

Error Handling and Debugging

Backend Validation

Validate backend configuration:

from qgans_pro.backends.validation import validate_backend

# Validate backend setup
validation_result = validate_backend(
    backend=qiskit_backend,
    test_circuits=True,
    check_connectivity=True,
    verbose=True
)

if validation_result["status"] == "success":
    print("Backend validation passed!")
else:
    print(f"Validation failed: {validation_result['errors']}")

Error Recovery

Handle backend errors gracefully:

from qgans_pro.backends.error_handling import BackendErrorHandler

# Setup error handling
error_handler = BackendErrorHandler(
    retry_attempts=3,
    fallback_backend=backup_backend,
    timeout=300  # seconds
)

# Execute with error handling
try:
    results = error_handler.safe_execute(
        backend=primary_backend,
        circuit=circuit,
        shots=1024
    )
except BackendTimeoutError:
    print("Backend timeout, switching to fallback")
except BackendUnavailableError:
    print("Backend unavailable, retrying...")

Advanced Backend Features

Custom Backend Implementation

Create custom backends for specialized hardware:

from qgans_pro.backends.base import QuantumBackend

class CustomQuantumBackend(QuantumBackend):
    """Custom backend for specialized quantum hardware."""

    def __init__(self, device_url, **kwargs):
        super().__init__(**kwargs)
        self.device_url = device_url

    def is_available(self):
        # Check if custom hardware is available
        return self._check_device_connection()

    def create_circuit(self, n_qubits, **kwargs):
        # Create circuit for custom hardware
        pass

    def execute_circuit(self, circuit, shots=1024):
        # Execute on custom hardware
        pass

# Register custom backend
from qgans_pro.backends import register_backend
register_backend("custom", CustomQuantumBackend)

# Use custom backend
custom_backend = create_backend(
    name="custom",
    device_url="https://my-quantum-device.com"
)

Backend Plugins

Extend functionality with plugins:

from qgans_pro.backends.plugins import (
    NoiseModelPlugin,
    OptimizationPlugin,
    CachePlugin
)

# Add plugins to backend
backend.add_plugin(NoiseModelPlugin(noise_level=0.01))
backend.add_plugin(OptimizationPlugin(level=2))
backend.add_plugin(CachePlugin(cache_size=1000))

# Plugins automatically applied during execution
results = backend.execute_circuit(circuit)

Best Practices

Backend Selection Guidelines

Choose appropriate backends for different use cases:

  1. Development/Testing: Use simulators (fast, reliable)
  2. Research: Use PennyLane for automatic differentiation
  3. Production: Use optimized simulators or hardware
  4. Large Circuits: Use distributed or GPU-accelerated backends

Performance Optimization

Optimize backend performance:

# Qiskit optimizations
qiskit_backend.set_options(
    shots=1024,  # Balance accuracy vs speed
    optimization_level=2,  # Optimize circuits
    memory_slots=None,  # Reduce memory usage
    max_parallel_threads=4  # Parallel execution
)

# PennyLane optimizations  
pennylane_backend.set_options(
    shots=None,  # Exact simulation when possible
    diff_method="adjoint",  # Efficient gradients
    cache=True  # Cache results
)

Error Prevention

Common pitfalls and solutions:

# Check device availability before use
if not backend.is_available():
    raise RuntimeError("Backend not available")

# Validate circuit before execution
if not backend.validate_circuit(circuit):
    circuit = backend.optimize_circuit(circuit)

# Handle device-specific limitations
max_qubits = backend.get_device_info()["max_qubits"]
if circuit.num_qubits > max_qubits:
    raise ValueError(f"Circuit too large for device ({max_qubits} qubits max)")