API Reference - Modules

Complete API reference for QPyth modules.

quantumpytho.config

Configuration management for QPyth.

QuantumConfig

from quantumpytho.config import QuantumConfig

config = QuantumConfig(
    backend: str = "ibmq_qasm_simulator",
    shots: int = 1024,
    mode: ExecutionMode = ExecutionMode.SIMULATOR,
    noise_profile: str | None = None
)

Parameters: - backend - Backend name for execution - shots - Number of measurement shots - mode - Execution mode (simulator, noisy_simulator, hardware) - noise_profile - Noise profile for noisy simulation

ExecutionMode

from quantumpytho.config import ExecutionMode

ExecutionMode.SIMULATOR
ExecutionMode.NOISY_SIMULATOR
ExecutionMode.HARDWARE

quantumpytho.engine

Core quantum engine for circuit execution.

QuantumEngine

from quantumpytho.engine import QuantumEngine

engine = QuantumEngine(config: QuantumConfig | None = None)

Methods: - run(circuit: QuantumCircuit, shots: int = 1024) -> dict - Run circuit - connect_hardware() -> None - Connect to IBM Quantum hardware - get_backend_info() -> dict - Get backend information

quantumpytho.modules.bloch_ascii

Bloch sphere visualization with ASCII art.

run_bloch_ascii

from quantumpytho.modules.bloch_ascii import run_bloch_ascii

run_bloch_ascii(
    theta: float,
    phi: float,
    shots: int = 1024
) -> None

Parameters: - theta - Polar angle [0, π] - phi - Azimuthal angle [0, 2π] - shots - Number of measurement shots

quantumpytho.modules.circuit_explorer

Quantum circuit exploration and demonstration.

bell_pair

from quantumpytho.modules.circuit_explorer import bell_pair

result = bell_pair(shots: int = 1024) -> dict

Returns: - counts - Measurement counts - circuit - Circuit diagram

hadamard_sweep

from quantumpytho.modules.circuit_explorer import hadamard_sweep

result = hadamard_sweep(depth: int = 3, shots: int = 1024) -> dict

Parameters: - depth - Number of Hadamard layers - shots - Number of measurement shots

quantumpytho.modules.qrng_sacred

Quantum random number generation with golden ratio scaling.

qrng_phi_sequence

from quantumpytho.modules.qrng_sacred import qrng_phi_sequence

sequence = qrng_phi_sequence(
    num_qubits: int = 8,
    length: int = 16
) -> list[float]

Parameters: - num_qubits - Number of qubits [4, 12] - length - Sequence length [8, 32]

Returns: - List of φ-scaled random numbers

quantumpytho.modules.vqe_h2_cli

VQE simulation for H2 molecule.

run_vqe_h2_cli

from quantumpytho.modules.vqe_h2_cli import run_vqe_h2_cli

run_vqe_h2_cli(
    config: QuantumConfig | None = None,
    max_iters: int = 50
) -> None

Parameters: - config - Configuration object - max_iters - Maximum optimization iterations

quantumpytho.modules.vqe_molecules

Molecule configurations and utilities.

get_molecule

from quantumpytho.modules.vqe_molecules import get_molecule

config = get_molecule(name: str) -> MoleculeConfig

Parameters: - name - Molecule name (H2, LiH, HeH+, BeH2, H2O)

Returns: - Molecule configuration object

list_molecules

from quantumpytho.modules.vqe_molecules import list_molecules

molecules = list_molecules() -> list[str]

Returns: - List of available molecule names

get_reference_energy

from quantumpytho.modules.vqe_molecules import get_reference_energy

energy = get_reference_energy(name: str) -> float

Parameters: - name - Molecule name

Returns: - Reference energy in Hartree

quantumpytho.modules.hardware_ibm

IBM Quantum hardware integration and noisy simulation.

IBMHardwareEngine

from quantumpytho.modules.hardware_ibm import IBMHardwareEngine

engine = IBMHardwareEngine(config: HardwareConfig | None = None)

Methods: - connect() -> None - Connect to IBM Quantum - run(circuit: QuantumCircuit, shots: int = 1024) -> HardwareResult - Run on hardware - list_backends() -> list[dict] - List available backends - select_backend(min_qubits: int = 1) -> str - Select backend - get_backend_info(backend: str) -> dict - Get backend information

NoisySimulatorEngine

from quantumpytho.modules.hardware_ibm import NoisySimulatorEngine

engine = NoisySimulatorEngine(noise_profile: str | None = None)

Methods: - run(circuit: QuantumCircuit, shots: int = 1024) -> NoisySimulatorResult - Run with noise - get_available_profiles() -> list[str] - List available noise profiles - get_profile_info(profile: str) -> dict - Get profile information

run_with_noise

from quantumpytho.modules.hardware_ibm import run_with_noise

result = run_with_noise(
    circuit: QuantumCircuit,
    noise_profile: str,
    shots: int = 1024
) -> dict

Parameters: - circuit - Quantum circuit to run - noise_profile - Noise profile name - shots - Number of measurement shots

quantumpytho.modules.noise_builder

Noise model construction from IBM calibration data.

parse_calibration_csv

from quantumpytho.modules.noise_builder import parse_calibration_csv

profile = parse_calibration_csv(backend_name: str) -> NoiseProfile

Parameters: - backend_name - IBM backend name

Returns: - Noise profile object

build_noise_model_from_profile

from quantumpytho.modules.noise_builder import build_noise_model_from_profile

noise_model = build_noise_model_from_profile(profile: NoiseProfile) -> NoiseModel

Parameters: - profile - Noise profile object

Returns: - Qiskit Aer noise model

get_backend_profile_names

from quantumpytho.modules.noise_builder import get_backend_profile_names

profiles = get_backend_profile_names() -> list[str]

Returns: - List of available profile names

quantumpytho.modules.qec_shor

Shor's 9-qubit error correction code.

run_shor_qec_demo

from quantumpytho.modules.qec_shor import run_shor_qec_demo

result = run_shor_qec_demo(
    engine: QuantumEngine,
    logical_state: int = 0,
    error_type: str = "none",
    error_qubit: int = 0
) -> dict

Parameters: - engine - Quantum engine instance - logical_state - Logical state (0 or 1) - error_type - Error type (none, bit_flip, phase_flip, both) - error_qubit - Qubit to inject error on

Returns: - original_state - Original logical state - encoded_qubits - Encoded qubits - error_type - Error type injected - error_qubit - Qubit error was injected on - decoded_state - Decoded logical state - success - Whether correction succeeded

quantumpytho.modules.qec_steane

Steane's 7-qubit error correction code.

run_steane_qec_demo

from quantumpytho.modules.qec_steane import run_steane_qec_demo

result = run_steane_qec_demo(
    engine: QuantumEngine,
    logical_state: int = 0,
    error_type: str = "none",
    error_qubit: int = 0
) -> dict