app.py

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()