Update app.py

app.py

@@ -1,11 +1,4 @@
-# -*- coding: utf-8 -*-
-# pip install qiskit
-# pip install qiskit-aer
-"""
-multiply.py: Multiply two numbers using repeated fourier 
-               transform based addition.
-"""
-
+import gradio as gr
 from qiskit import QuantumRegister, QuantumCircuit, ClassicalRegister
 from qiskit import Aer, execute
 from math import pi
@@ -22,7 +15,6 @@ def createInputState(qc, reg, n, pie):
     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 
@@ -37,7 +29,6 @@ def evolveQFTState(qc, reg_a, reg_b, n, pie, factor):
         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.
@@ -49,7 +40,6 @@ def inverseQFT(qc, reg, n, pie):
         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 
@@ -69,50 +59,46 @@ def add(reg_a, reg_b, circ, factor):
     for i in range(0, n + 1):
         inverseQFT(circ, reg_a, i, pie)
 
-
-# Take two numbers as user input in binary form
-multiplicand_in = input("Enter the multiplicand.")
-l1 = len(multiplicand_in)
-multiplier_in = input("Enter the multiplier.")
-l2 = len(multiplier_in)
-# Make sure multiplicand_in holds the larger number
-if l2 > l1:
-    multiplier_in, multiplicand_in = multiplicand_in, multiplier_in
-    l2, l1 = l1, l2
-
-multiplicand = QuantumRegister(l1)
-multiplier = QuantumRegister(l2)
-accumulator = QuantumRegister(l1 + l2)
-cl = ClassicalRegister(l1 + l2)
-d = QuantumRegister(1)
-
-circ = QuantumCircuit(accumulator, multiplier, multiplicand,
-    d, cl, name="qc")
-
-circ.x(d)
-# Store bit strings in quantum registers
-for i in range(l1):
-    if multiplicand_in[i] == '1':
-        circ.x(multiplicand[l1 - i - 1])
-
-for i in range(l2):
-    if multiplier_in[i] == '1':
-        circ.x(multiplier[l1 - 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])
+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)
-    multiplier_str = list(result.keys())[0]
+                shots=2).result().get_counts(circ.name)
+
+    return list(result.keys())[0]
 
-circ.measure(accumulator, cl)
-result = execute(circ, backend=Aer.get_backend('qasm_simulator'),
-            shots=2).result().get_counts(circ.name)
+iface = gr.Interface(quantum_multiply, inputs=["text", "text"], outputs="text")
 
-print(result)
+iface.launch()