File size: 3,719 Bytes
a87f7b2 6efeab4 a87f7b2 6efeab4 a87f7b2 6efeab4 a87f7b2 6efeab4 a87f7b2 |
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 |
import gradio as gr
from qiskit import QuantumRegister, QuantumCircuit, ClassicalRegister
from qiskit import Aer, execute
from math import pi
def createInputState(qc, reg, n, pie):
"""
Computes the quantum Fourier transform of reg, one qubit at
a time.
Apply one Hadamard gate to the nth qubit of the quantum register reg, and
then apply repeated phase rotations with parameters being pi divided by
increasing powers of two.
"""
qc.h(reg[n])
for i in range(0, n):
qc.cp(pie / float(2**(i + 1)), reg[n - (i + 1)], reg[n])
def evolveQFTState(qc, reg_a, reg_b, n, pie, factor):
"""
Evolves the state |F(ψ(reg_a))> to |F(ψ(reg_a+reg_b))> using the quantum
Fourier transform conditioned on the qubits of the reg_b.
Apply repeated phase rotations with parameters being pi divided by
increasing powers of two.
"""
l = len(reg_b)
for i in range(0, n + 1):
if (n - i) > l - 1:
pass
else:
qc.cp(factor*pie / float(2**(i)), reg_b[n - i], reg_a[n])
def inverseQFT(qc, reg, n, pie):
"""
Performs the inverse quantum Fourier transform on a register reg.
Apply repeated phase rotations with parameters being pi divided by
decreasing powers of two, and then apply a Hadamard gate to the nth qubit
of the register reg.
"""
for i in range(0, n):
qc.cp(-1 * pie / float(2**(n - i)), reg[i], reg[n])
qc.h(reg[n])
def add(reg_a, reg_b, circ, factor):
"""
Add two quantum registers reg_a and reg_b, and store the result in
reg_a.
"""
pie = pi
n = len(reg_a) - 1
# Compute the Fourier transform of register a
for i in range(0, n + 1):
createInputState(circ, reg_a, n - i, pie)
# Add the two numbers by evolving the Fourier transform F(ψ(reg_a))>
# to |F(ψ(reg_a+reg_b))>
for i in range(0, n + 1):
evolveQFTState(circ, reg_a, reg_b, n - i, pie, factor)
# Compute the inverse Fourier transform of register a
for i in range(0, n + 1):
inverseQFT(circ, reg_a, i, pie)
def quantum_multiply(multiplicand_in, multiplier_in):
multiplicand_in = multiplicand_in.strip()
multiplier_in = multiplier_in.strip()
multiplicand = QuantumRegister(len(multiplicand_in))
multiplier = QuantumRegister(len(multiplier_in))
accumulator = QuantumRegister(len(multiplicand_in) + len(multiplier_in))
cl = ClassicalRegister(len(multiplicand_in) + len(multiplier_in))
d = QuantumRegister(1)
circ = QuantumCircuit(accumulator, multiplier, multiplicand,
d, cl, name="qc")
# Store bit strings in quantum registers
for i in range(len(multiplicand_in)):
if multiplicand_in[i] == '1':
circ.x(multiplicand[len(multiplicand_in) - i - 1])
for i in range(len(multiplier_in)):
if multiplier_in[i] == '1':
circ.x(multiplier[len(multiplicand_in) - i - 1])
multiplier_str = '1'
# Perform repeated addition until the multiplier
# is zero
while(int(multiplier_str) != 0):
add(accumulator, multiplicand, circ, 1)
add(multiplier, d, circ, -1)
for i in range(len(multiplier)):
circ.measure(multiplier[i], cl[i])
result = execute(circ, backend=Aer.get_backend('qasm_simulator'),
shots=2).result().get_counts(circ.name)
multiplier_str = list(result.keys())[0]
circ.measure(accumulator, cl)
result = execute(circ, backend=Aer.get_backend('qasm_simulator'),
shots=2).result().get_counts(circ.name)
return list(result.keys())[0]
iface = gr.Interface(quantum_multiply, inputs=["text", "text"], outputs="text")
iface.launch()
|