Skip to content

Basic Examples

Simple examples to get started with QPyth.

Bloch Sphere Visualization

Visualize |+⟩ State

from quantumpytho.modules.bloch_ascii import run_bloch_ascii

# |+⟩ state: equal superposition
run_bloch_ascii(theta=1.571, phi=0)

Output: 

State Vector Projection (θ=1.571000, φ=0.000000):
Statevector([ 0.707+0.j,  0.707+0.j], dims=(2,))
|0> state: [###########--------]   50.00% (512 shots)
|1> state: [###########--------]   50.00% (512 shots)

Visualize |i+⟩ State

from quantumpytho.modules.bloch_ascii import run_bloch_ascii

# |i+⟩ state: equal superposition with imaginary phase
run_bloch_ascii(theta=1.571, phi=1.571)

Custom State

from quantumpytho.modules.bloch_ascii import run_bloch_ascii

# Custom state at θ=π/3, φ=π/2
run_bloch_ascii(theta=1.047, phi=1.571)

Quantum Random Numbers

Generate QRNG Sequence

from quantumpytho.modules.qrng_sacred import qrng_phi_sequence

# Generate 16 random numbers with 8 qubits
sequence = qrng_phi_sequence(num_qubits=8, length=16)

print("φ-scaled random sequence:")
for i, val in enumerate(sequence):
    print(f"{i:2d}: {val:.4f}")

Statistics

from quantumpytho.modules.qrng_sacred import qrng_phi_sequence

sequence = qrng_phi_sequence(num_qubits=8, length=16)

# Calculate statistics
mean = sum(sequence) / len(sequence)
min_val = min(sequence)
max_val = max(sequence)

print(f"Mean: {mean:.4f}")
print(f"Min: {min_val:.4f}")
print(f"Max: {max_val:.4f}")

Bell Pair Entanglement

Create Bell Pair

from quantumpytho.modules.circuit_explorer import bell_pair

# Create Bell pair
result = bell_pair(shots=1024)

print("Measurement counts:")
for state, count in result['counts'].items():
    print(f"  |{state}⟩: {count}")

print("\nCircuit:")
print(result['circuit'])

Verify Entanglement

from quantumpytho.modules.circuit_explorer import bell_pair

result = bell_pair(shots=10000)

# Check if only |00⟩ and |11⟩ are present
counts = result['counts']
entangled = all(state in ['00', '11'] for state in counts.keys())

print(f"Entangled: {entangled}")
print(f"Counts: {counts}")

Hadamard Sweep

Single Hadamard

from quantumpytho.modules.circuit_explorer import hadamard_sweep

# Apply single Hadamard
result = hadamard_sweep(depth=1, shots=1024)

print("Measurement counts:")
for state, count in result['counts'].items():
    print(f"  |{state}⟩: {count}")

Multiple Hadamards

from quantumpytho.modules.circuit_explorer import hadamard_sweep

# Apply 5 Hadamards
result = hadamard_sweep(depth=5, shots=1024)

print(f"Depth: {result['depth']}")
print("Measurement counts:")
for state, count in result['counts'].items():
    print(f"  |{state}⟩: {count}")

Quantum Teleportation

Show Teleportation Circuit

from quantumpytho.modules.teleport_bridge import run_teleport_bridge
from quantumpytho.engine import QuantumEngine

engine = QuantumEngine()
result = run_teleport_bridge(engine)

print("Teleportation Circuit:")
print(result['circuit'])

VQE Simulation

Run H2 VQE

from quantumpytho.modules.vqe_h2_cli import run_vqe_h2_cli

# Run VQE for H2 molecule
run_vqe_h2_cli(max_iters=50)

Run VQE with Custom Config

from quantumpytho.modules.vqe_h2_cli import run_vqe_h2_cli
from quantumpytho.config import QuantumConfig, ExecutionMode

# Configure noisy simulation
config = QuantumConfig(
    mode=ExecutionMode.NOISY_SIMULATOR,
    noise_profile="ibm_brisbane"
)

# Run VQE with noise
run_vqe_h2_cli(config=config, max_iters=50)

Noisy Simulation

Run Circuit with Noise

from qiskit import QuantumCircuit
from quantumpytho.modules.hardware_ibm import run_with_noise

# Create circuit
qc = QuantumCircuit(2)
qc.h(0)
qc.cx(0, 1)
qc.measure_all()

# Run with IBM calibration noise
result = run_with_noise(qc, "ibm_brisbane", shots=1024)

print("Noisy simulation counts:")
for state, count in result['counts'].items():
    print(f"  |{state}⟩: {count}")

Compare Ideal vs Noisy

from qiskit import QuantumCircuit
from qiskit_aer import AerSimulator
from quantumpytho.modules.hardware_ibm import run_with_noise

# Create circuit
qc = QuantumCircuit(2)
qc.h(0)
qc.cx(0, 1)
qc.measure_all()

# Ideal simulation
ideal_sim = AerSimulator()
ideal_result = ideal_sim.run(qc, shots=1024).result()
ideal_counts = ideal_result.get_counts()

# Noisy simulation
noisy_result = run_with_noise(qc, "ibm_brisbane", shots=1024)
noisy_counts = noisy_result['counts']

print("Ideal counts:", ideal_counts)
print("Noisy counts:", noisy_counts)

Quantum Error Correction

Shor's Code

from quantumpytho.modules.qec_shor import run_shor_qec_demo
from quantumpytho.engine import QuantumEngine

engine = QuantumEngine()

# Correct bit flip error
result = run_shor_qec_demo(
    engine,
    logical_state=0,
    error_type="bit_flip",
    error_qubit=0
)

print(f"Original state: |{result['original_state']}>")
print(f"Decoded state: |{result['decoded_state']}>")
print(f"Success: {result['success']}")

Steane's Code

from quantumpytho.modules.qec_steane import run_steane_qec_demo
from quantumpytho.engine import QuantumEngine

engine = QuantumEngine()

# Correct phase flip error
result = run_steane_qec_demo(
    engine,
    logical_state=1,
    error_type="phase_flip",
    error_qubit=3
)

print(f"Original state: |{result['original_state']}>")
print(f"Decoded state: |{result['decoded_state']}>")
print(f"Success: {result['success']}")

Configuration

Set Execution Mode

from quantumpytho.config import QuantumConfig, ExecutionMode

# Ideal simulator
config = QuantumConfig(mode=ExecutionMode.SIMULATOR)

# Noisy simulator
config = QuantumConfig(
    mode=ExecutionMode.NOISY_SIMULATOR,
    noise_profile="ibm_brisbane"
)

# Hardware
config = QuantumConfig(
    mode=ExecutionMode.HARDWARE,
    backend="ibm_brisbane"
)

Use Configuration

from quantumpytho.config import QuantumConfig, ExecutionMode
from quantumpytho.engine import QuantumEngine

# Create configuration
config = QuantumConfig(
    backend="ibmq_qasm_simulator",
    shots=2048,
    mode=ExecutionMode.SIMULATOR
)

# Create engine with configuration
engine = QuantumEngine(config=config)

# Use engine
from qiskit import QuantumCircuit
qc = QuantumCircuit(2)
qc.h(0)
qc.cx(0, 1)
qc.measure_all()

result = engine.run(qc)
print(result)

Next Steps