for quantum programming, there is no one universally accepted standard or language for quantum programming yet. The most common languages used for quantum programming are those developed by the big cloud providers such as Microsoft's Q#, IBM's Qiskit, and Amazon's Braket, Google's Cirq, Rigetti Forest.
A Simple? Example
Here is an example of a simple quantum program using Qiskit, one of the most popular open-source frameworks for quantum computing:
from qiskit import QuantumCircuit, QuantumRegister, execute, Aer
# Create a 2-qubit quantum register
q = QuantumRegister(2)
# Create a quantum circuit
circuit = QuantumCircuit(q)
# Apply the Hadamard gate to the first qubit
circuit.h(q[0])
# Apply the controlled-not gate between the two qubits
circuit.cx(q[0], q[1])
# Measure the qubits
circuit.measure(q, [0, 1])
# Execute the circuit on a quantum simulator
backend = Aer.get_backend("qasm_simulator")
result = execute(circuit, backend).result()
# Print the measurement results
print(result.get_counts())
This program creates a 2-qubit quantum register, applies a Hadamard gate to the first qubit and a controlled-not gate between the two qubits, then measures the qubits and prints the results. The program uses Qiskit's QuantumCircuit class to create and manipulate the quantum circuit, and its Aer class
The above quantum program is a simple example of a quantum circuit that demonstrates the basic principles of quantum computing. In particular, it demonstrates the use of quantum gates to manipulate qubits and the use of measurements to extract information from qubits.
One practical use for this type of quantum circuit is in quantum teleportation. Quantum teleportation is a phenomenon in which the state of a quantum system can be transferred from one location to another, without any physical movement of the system itself. This is achieved by creating an entangled pair of qubits, performing a set of quantum gates on one qubit, and then measuring both qubits. The measurement results are then used to reconstruct the state of the original qubit on the receiving end.
In this example, the initial Hadamard gate on the first qubit creates a superposition state which is the first step to enable entanglement and the controlled-not gate on the second qubit is the entanglement gate, which creates the entanglement between the two qubits. The two qubits now are in an entangled state , and the state of the first qubit can be transferred to the second qubit by measuring both qubits. This measurement will also collapse the entanglement state.
It is worth noting that while this circuit is demonstrating a simplified version of quantum teleportation, this procedure is mainly a theoretical concept and a lot of advancements need to be done to be able to perform it with current technology and resources.
Let's try and go a bit deeper
A more advanced code example of a quantum program might involve using more qubits, more quantum gates, and more complex quantum algorithms. For example, Shor's algorithm is a quantum algorithm for factoring integers that has exponential speedup over classical algorithms. Here's an example of Shor's algorithm implemented again with Qiskit:
from qiskit import QuantumCircuit, QuantumRegister, ClassicalRegister, execute, Aer
from qiskit.quantum_info.operators import Operator
from math import gcd
def shor(n):
a = 2
while gcd(a, n) != 1:
a += 1
q = QuantumRegister(3)
c = ClassicalRegister(3)
circuit = QuantumCircuit(q, c)
# Perform modular exponentiation using the quantum circuit
circuit.x(q[2])
circuit.h(q[0])
circuit.barrier()
for i in range(1, len(bin(n - 1)) - 2):
circuit.barrier()
circuit.cx(q[0], q[1])
circuit.barrier()
circuit.cu1(2 * 3.14159 / 2**i, q[0], q[1])
circuit.barrier()
circuit.cx(q[0], q[1])
circuit.barrier()
circuit.cu1(2 * 3.14159 / 2**(i + 1), q[0], q[2])
circuit.barrier()
circuit.h(q[0])
circuit.barrier()
circuit.measure(q[0], c[0])
# Perform the Quantum Fourier Transform on the output
circuit.barrier()
circuit.h(q[1])
circuit.u1(3.14159, q[1])
circuit.cx(q[1], q[2])
circuit.u1(-3.14159, q[2])
circuit.cx(q[1], q[2])
circuit.u1(3.14159, q[1])
circuit.h(q[1])
circuit.barrier()
circuit.measure(q[1], c[1])
# Measure the third qubit
circuit.barrier()
circuit.measure(q[2], c[2])
backend = Aer.get_backend("qasm_simulator")
result = execute(circuit, backend, shots=1000).result()
counts = result.get_counts()
# Extract the period of the function
for state in counts:
if state[-1] == '1':
r = int(state[: -1], 2)
if r % 2 != 0:
continue
else:
break
factor = gcd(a**r % n, n)
return factor
In this example, the function shor() takes an integer n as an input, and returns one of its factors. The function starts by selecting a random a such that gcd(a,n) = 1 and creates 3-qubits quantum register, then applies a sequence of gates, measures the qubits, to perform the moduler exponentiation and the Quantum Fourier Transform,
The shor() function takes an integer n as an input and returns one of its factors. The function starts by selecting a random a such that gcd(a,n) = 1 and creates a 3-qubits quantum register.
Then the function performs a sequence of gates on the qubits to perform the modular exponentiation and the Quantum Fourier Transform. The modular exponentiation is used to calculate a^r mod n and the QFT is used to find the period of the function, which is required for the calculation of the factor.
After the sequence of gates is applied, the function measures all the qubits, and counts the results.
Then it goes through the result and looks for a state that has a 1 at the third bit and if so, it considers the first 2 bits as r, which represents the period of the function.
Then it applies the gcd formula with (a^r % n, n) to find the factor of the input n
It is worth noting that this algorithm has exponential speedup over classical algorithms, meaning it takes significantly less steps to find the factor of large integers. However this specific example is just a simulation and real-world implementations have a lot of constraints and limitations, such as noise, error-correction etc.
Wrap Up!