Cambridge University quantum CLI
t|ket˙ (pronounced "ticket") is a leading quantum software development platform that optimizes quantum circuits for various quantum hardware platforms. The following guide provides a detailed list of commands, usage examples, and advanced techniques for working with t|ket˙.
To use t|ket˙, you need to install the pytket package.
# Install pytket
pip install pytketTo enable support for specific quantum backends, you might need to install additional packages. For example:
# Install IBMQ backend
pip install pytket-extensions[pytket-ibmq]
# Install AQT backend
pip install pytket-extensions[pytket-aqt]
# Install Amazon Braket backend
pip install pytket-extensions[pytket-braket]- Basic Circuit Creation
Create a simple quantum circuit.
from pytket import Circuit
from pytket.circuit.display import render_circuit_jupyter
# Initialize a circuit with 2 qubits and 2 classical bits
circuit = Circuit(2, 2)
circuit.H(0).CX(0, 1).measure_all()
# Render the circuit
render_circuit_jupyter(circuit)- Adding Gates to the Circuit
Add various quantum gates to the circuit.
circuit = Circuit(2, 2)
circuit.X(0).H(1).CX(0, 1).Rz(0.5, 0).Ry(1.0, 1).Rz(1.5, 0).measure_all()
render_circuit_jupyter(circuit)- Basic Optimization
Optimize a quantum circuit to reduce gate count and improve execution.
from pytket.passes import SequencePass, FullPeepholeOptimise, RemoveRedundancies
# Define an optimization pass sequence
optimization_pass = SequencePass([FullPeepholeOptimise(), RemoveRedundancies()])
# Apply the optimization to the circuit
optimized_circuit = circuit.copy()
optimization_pass.apply(optimized_circuit)
# Compare original and optimized circuits
print("Original circuit:")
render_circuit_jupyter(circuit)
print("Optimized circuit:")
render_circuit_jupyter(optimized_circuit)- Advanced Optimization Techniques
Use advanced techniques to optimize for specific backends.
from pytket.passes import CXMappingPass, RoutingPass
# Define a mapping pass for a specific architecture
mapping_pass = CXMappingPass(target_device)
# Apply routing and mapping passes to the circuit
advanced_optimization_pass = SequencePass([mapping_pass, RoutingPass()])
advanced_optimization_pass.apply(optimized_circuit)
print("Circuit after advanced optimization:")
render_circuit_jupyter(optimized_circuit)- IBM Quantum Experience
Execute a circuit on IBMQ backend.
from pytket.extensions.qiskit import AerBackend, IBMQBackend
from qiskit import IBMQ
# Load IBMQ account
IBMQ.load_account()
# Initialize IBMQ backend
ibmq_backend = IBMQBackend("ibmq_qasm_simulator")
# Compile and execute the circuit
compiled_circuit = ibmq_backend.get_compiled_circuit(circuit)
result = ibmq_backend.run(compiled_circuit)
# Print result
print(result.get_counts())- Amazon Braket
Execute a circuit on Amazon Braket backend.
from pytket.extensions.braket import BraketBackend
from braket.aws import AwsDevice
# Initialize Amazon Braket backend
braket_backend = BraketBackend(AwsDevice("arn:aws:braket:::device/qpu/ionq/ionQdevice"))
# Compile and execute the circuit
compiled_circuit = braket_backend.get_compiled_circuit(circuit)
result = braket_backend.run(compiled_circuit)
# Print result
print(result.get_counts())- Rigetti
Execute a circuit on Rigetti backend.
from pytket.extensions.pyquil import ForestBackend
# Initialize Rigetti backend
forest_backend = ForestBackend()
# Compile and execute the circuit
compiled_circuit = forest_backend.get_compiled_circuit(circuit)
result = forest_backend.run(compiled_circuit)
# Print result
print(result.get_counts())- Error Mitigation Techniques
Apply error mitigation techniques in your quantum experiments.
from pytket.passes import NoiseAwarePlacementPass
# Define a noise-aware placement pass
noise_mitigation_pass = NoiseAwarePlacementPass()
# Apply the noise mitigation pass to the circuit
noise_mitigation_pass.apply(compiled_circuit)
print("Circuit after noise mitigation:")
render_circuit_jupyter(compiled_circuit)- Simulating Noise
Simulate noise in your quantum circuits.
from pytket.extensions.qiskit import AerBackend
# Initialize Aer backend with noise model
aer_backend = AerBackend(noise_model="ibmq_vigo_noise_model")
# Compile and execute the circuit with noise simulation
compiled_circuit = aer_backend.get_compiled_circuit(circuit)
result = aer_backend.run(compiled_circuit)
# Print result
print(result.get_counts())- Variational Quantum Eigensolver (VQE)
Implement the VQE algorithm using t|ket˙.
import numpy as np
from scipy.optimize import minimize
from pytket import Circuit
from pytket.extensions.qiskit import AerBackend
# Define the ansatz
def ansatz(params):
circuit = Circuit(2)
circuit.Ry(params[0], 0)
circuit.Ry(params[1], 1)
circuit.CX(0, 1)
return circuit
# Define the cost function
def cost_function(params):
backend = AerBackend()
circuit = ansatz(params)
circuit.measure_all()
compiled_circuit = backend.get_compiled_circuit(circuit)
result = backend.run(compiled_circuit)
counts = result.get_counts()
cost = counts.get("00", 0) / sum(counts.values())
return cost
# Optimize the parameters
initial_params = np.random.rand(2)
result = minimize(cost_function, initial_params, method="Nelder-Mead")
print(result.x)- Storing and Retrieving Results
Store quantum task results and retrieve them later.
import json
# Store results to a file
with open("results.json", "w") as f:
json.dump(result.get_counts(), f)
# Retrieve results from a file
with open("results.json", "r") as f:
loaded_counts = json.load(f)
print(loaded_counts)- Hybrid Classical-Quantum Workflows
Combine classical and quantum computing in hybrid workflows.
def hybrid_workflow(classical_data):
# Perform classical pre-processing
processed_data = classical_data * 2
# Create and execute a quantum circuit
circuit = Circuit(2)
circuit.Ry(processed_data[0], 0)
circuit.Ry(processed_data[1], 1)
circuit.CX(0, 1)
circuit.measure_all()
# Execute the circuit on a quantum backend
backend = AerBackend()
compiled_circuit = backend.get_compiled_circuit(circuit)
result = backend.run(compiled_circuit)
# Perform classical post-processing
counts = result.get_counts()
processed_counts = {key: value / sum(counts.values()) for key, value in counts.items()}
return processed_counts
# Example classical data
classical_data = [0.5, 0.8]
# Run the hybrid workflow
result = hybrid_workflow(classical_data)
print(result)This comprehensive guide covers the installation, basic usage, advanced techniques, optimization, integration with classical computing, error mitigation, and hybrid algorithms for t|ket˙. These examples provide a thorough resource for getting started and advancing in quantum computing with t|ket˙.