Quantum Computing Code Examples

🐍 Python Examples

Basic Bell State Creation

import uvq

# Initialize UVQ client
client = uvq.QuantumClient(api_key="uvq_live_your_key_here")

# Create Bell state circuit
circuit = uvq.Circuit()
circuit.h(0)          # Hadamard gate on qubit 0
circuit.cnot(0, 1)    # CNOT gate from qubit 0 to 1
circuit.measure([0, 1])  # Measure both qubits

# Execute circuit
job = client.execute(circuit, shots=1024)
result = job.get_result()

print(f"Bell state results: {result.get_counts()}")
# Expected output: {'00': ~512, '11': ~512}

Grover's Search Algorithm

import uvq
import numpy as np

def grovers_search(client, marked_item, num_items=4):
    """
    Grover's algorithm to find a marked item
    """
    num_qubits = int(np.log2(num_items))
    circuit = uvq.Circuit()
    
    # Initialize superposition
    for i in range(num_qubits):
        circuit.h(i)
    
    # Grover iterations
    iterations = int(np.pi/4 * np.sqrt(num_items))
    for _ in range(iterations):
        # Oracle (marks the target item)
        circuit.oracle(marked_item, num_qubits)
        
        # Diffusion operator
        circuit.diffusion(num_qubits)
    
    circuit.measure_all()
    
    # Execute and get result
    job = client.execute(circuit, shots=1000)
    return job.get_result().get_counts()

# Usage
client = uvq.QuantumClient(api_key="your_api_key")
result = grovers_search(client, marked_item=3)
print(result)  # Should find item 3 with high probability

🟨 JavaScript/Node.js Examples

Quantum Random Number Generator

const UVQ = require('uvq-sdk');

const client = new UVQ.QuantumClient({
    apiKey: 'uvq_live_your_key_here',
    baseUrl: 'https://api.uvq.net/v1'
});

async function generateQuantumRandom(bits = 8) {
    const circuit = new UVQ.Circuit();
    
    // Add Hadamard gates to create superposition
    for (let i = 0; i < bits; i++) {
        circuit.h(i);
    }
    
    // Measure all qubits
    circuit.measureAll();
    
    try {
        const job = await client.execute(circuit, { shots: 1 });
        const result = await job.getResult();
        
        // Convert measurement to integer
        const bitString = Object.keys(result.counts)[0];
        return parseInt(bitString, 2);
    } catch (error) {
        console.error('Quantum execution failed:', error);
        throw error;
    }
}

// Usage
generateQuantumRandom(8)
    .then(randomNum => {
        console.log(`True quantum random number: ${randomNum}`);
    })
    .catch(console.error);

Quantum Teleportation Protocol

const UVQ = require('uvq-sdk');

async function quantumTeleportation(client, stateToTeleport) {
    const circuit = new UVQ.Circuit();
    
    // Prepare the state to teleport on qubit 0
    if (stateToTeleport.includes('X')) circuit.x(0);
    if (stateToTeleport.includes('Y')) circuit.y(0);
    if (stateToTeleport.includes('Z')) circuit.z(0);
    
    // Create Bell pair between qubits 1 and 2
    circuit.h(1);
    circuit.cnot(1, 2);
    
    // Bell measurement on qubits 0 and 1
    circuit.cnot(0, 1);
    circuit.h(0);
    circuit.measure([0, 1]);
    
    // Apply corrections to qubit 2 based on measurement
    circuit.conditionalX(2, 1);  // X correction if qubit 1 is |1⟩
    circuit.conditionalZ(2, 0);  // Z correction if qubit 0 is |1⟩
    
    // Measure the teleported state
    circuit.measure(2);
    
    const job = await client.execute(circuit, { shots: 1000 });
    return await job.getResult();
}

// Usage
const client = new UVQ.QuantumClient({apiKey: 'your_key'});
quantumTeleportation(client, 'X')  // Teleport |+⟩ state
    .then(result => console.log('Teleportation result:', result));

🔗 cURL/REST API Examples

Simple Hadamard Gate

curl -X POST https://api.uvq.net/v1/quantum/execute \
  -H "Authorization: Bearer uvq_live_your_key_here" \
  -H "Content-Type: application/json" \
  -d '{
    "circuit": {
      "qubits": 1,
      "gates": [
        {"type": "H", "target": 0}
      ],
      "measurements": [0]
    },
    "shots": 1000
  }'

Quantum Fourier Transform

curl -X POST https://api.uvq.net/v1/quantum/execute \
  -H "Authorization: Bearer uvq_live_your_key_here" \
  -H "Content-Type: application/json" \
  -d '{
    "circuit": {
      "qubits": 3,
      "gates": [
        {"type": "H", "target": 0},
        {"type": "CRZ", "control": 1, "target": 0, "angle": 1.5708},
        {"type": "CRZ", "control": 2, "target": 0, "angle": 0.7854},
        {"type": "H", "target": 1},
        {"type": "CRZ", "control": 2, "target": 1, "angle": 1.5708},
        {"type": "H", "target": 2},
        {"type": "SWAP", "targets": [0, 2]}
      ],
      "measurements": [0, 1, 2]
    },
    "shots": 1024
  }'

🚀 Advanced Examples

Variational Quantum Eigensolver (VQE)

import uvq
import numpy as np
from scipy.optimize import minimize

def vqe_ansatz(params, num_qubits):
    """Create parameterized quantum circuit for VQE"""
    circuit = uvq.Circuit()
    
    # Layer 1: RY rotations
    for i in range(num_qubits):
        circuit.ry(i, params[i])
    
    # Layer 2: Entangling gates
    for i in range(num_qubits - 1):
        circuit.cnot(i, i + 1)
    
    # Layer 3: More RY rotations
    for i in range(num_qubits):
        circuit.ry(i, params[num_qubits + i])
    
    return circuit

def cost_function(params, client, hamiltonian, num_qubits):
    """Compute expectation value of Hamiltonian"""
    circuit = vqe_ansatz(params, num_qubits)
    
    # Add measurements for each Pauli term in Hamiltonian
    expectation = 0
    for pauli_term, coeff in hamiltonian:
        temp_circuit = circuit.copy()
        temp_circuit.add_pauli_measurement(pauli_term)
        
        job = client.execute(temp_circuit, shots=1000)
        result = job.get_result()
        expectation += coeff * result.expectation_value()
    
    return expectation

# H2 molecule Hamiltonian example
H2_hamiltonian = [
    ('II', -1.0523732),
    ('IZ', -0.39793742),
    ('ZI', -0.39793742),
    ('ZZ', -0.01128010),
    ('XX', 0.18093119)
]

# Optimize
client = uvq.QuantumClient(api_key="your_key")
initial_params = np.random.random(4)  # 2 qubits, 2 layers

result = minimize(
    cost_function, 
    initial_params,
    args=(client, H2_hamiltonian, 2),
    method='COBYLA'
)

print(f"Ground state energy: {result.fun}")
print(f"Optimal parameters: {result.x}")

📦 SDK Installation

Python SDK

pip install uvq-quantum

Node.js SDK

npm install uvq-sdk

Configuration

# Set environment variable
export UVQ_API_KEY="uvq_live_your_key_here"

# Or create config file ~/.uvq/config.json
{
  "api_key": "uvq_live_your_key_here",
  "base_url": "https://api.uvq.net/v1",
  "timeout": 30
}