Address Further Review Comments

Author: abhishekjiitr

quantum/deutsch_jozsa.py

@@ -25,77 +25,77 @@
 import qiskit as q
 
 
-def dj_oracle(case: str, n: int) -> q.QuantumCircuit:
+def dj_oracle(case: str, num_qubits: int) -> q.QuantumCircuit:
     """
     Returns a Quantum Circuit for the Oracle function.
     The circuit returned can represent balanced or constant function,
     according to the arguments passed
     """
-    # This circuit has n+1 qubits: the size of the input,
+    # This circuit has num_qubits+1 qubits: the size of the input,
     # plus one output qubit
-    oracle_qc = q.QuantumCircuit(n+1)
+    oracle_qc = q.QuantumCircuit(num_qubits+1)
 
     # First, let's deal with the case in which oracle is balanced
     if case == "balanced":
         # First generate a random number that tells us which CNOTs to
         # wrap in X-gates:
-        b = np.random.randint(1,2**n)
+        b = np.random.randint(1,2**num_qubits)
         # Next, format 'b' as a binary string of length 'n', padded with zeros:
-        b_str = format(b, '0'+str(n)+'b')
+        b_str = format(b, f"0{num_qubits}b") 
         # Next, we place the first X-gates. Each digit in our binary string 
         # correspopnds to a qubit, if the digit is 0, we do nothing, if it's 1
         # we apply an X-gate to that qubit:
-        for qubit in range(len(b_str)):
-            if b_str[qubit] == '1':
-                oracle_qc.x(qubit)
+        for index, bit in enumerate(b_str):
+            if bit == '1':
+                oracle_qc.x(index)
         # Do the controlled-NOT gates for each qubit, using the output qubit 
         # as the target:
-        for qubit in range(n):
-            oracle_qc.cx(qubit, n)
+        for index in range(num_qubits):
+            oracle_qc.cx(index, num_qubits)
         # Next, place the final X-gates
-        for qubit in range(len(b_str)):
-            if b_str[qubit] == '1':
-                oracle_qc.x(qubit)
+        for index, bit in enumerate(b_str):
+            if bit == '1':
+                oracle_qc.x(index)
 
     # Case in which oracle is constant
     if case == "constant":
         # First decide what the fixed output of the oracle will be
         # (either always 0 or always 1)
         output = np.random.randint(2)
         if output == 1:
-            oracle_qc.x(n)
+            oracle_qc.x(num_qubits)
 
     oracle_gate = oracle_qc.to_gate()
     oracle_gate.name = "Oracle" # To show when we display the circuit
     return oracle_gate
 
 
-def dj_algorithm(oracle: q.QuantumCircuit, n: int) -> q.QuantumCircuit:
+def dj_algorithm(oracle: q.QuantumCircuit, num_qubits: int) -> q.QuantumCircuit:
     """
     Returns the complete Deustch-Jozsa Quantum Circuit,
     adding Input & Output registers and Hadamard & Measurement Gates, 
     to the Oracle Circuit passed in arguments
     """
-    dj_circuit = q.QuantumCircuit(n+1, n)
+    dj_circuit = q.QuantumCircuit(num_qubits+1, num_qubits)
     # Set up the output qubit:
-    dj_circuit.x(n)
-    dj_circuit.h(n)
+    dj_circuit.x(num_qubits)
+    dj_circuit.h(num_qubits)
     # And set up the input register:
-    for qubit in range(n):
+    for qubit in range(num_qubits):
         dj_circuit.h(qubit)
     # Let's append the oracle gate to our circuit:
-    dj_circuit.append(oracle, range(n+1))
+    dj_circuit.append(oracle, range(num_qubits+1))
     # Finally, perform the H-gates again and measure:
-    for qubit in range(n):
+    for qubit in range(num_qubits):
         dj_circuit.h(qubit)
 
-    for i in range(n):
+    for i in range(num_qubits):
         dj_circuit.measure(i, i)
 
     return dj_circuit
 
 
-def deutsch_jozsa(case: str, n: int) -> q.result.counts.Counts:
+def deutsch_jozsa(case: str, num_qubits: int) -> q.result.counts.Counts:
     """
     Main function that builds the circuit using other helper functions, 
     runs the experiment 1000 times & returns the resultant qubit counts
@@ -107,8 +107,8 @@ def deutsch_jozsa(case: str, n: int) -> q.result.counts.Counts:
     # Use Aer's qasm_simulator
     simulator = q.Aer.get_backend("qasm_simulator")
 
-    oracle_gate = dj_oracle(case, n)
-    dj_circuit = dj_algorithm(oracle_gate, n)
+    oracle_gate = dj_oracle(case, num_qubits)
+    dj_circuit = dj_algorithm(oracle_gate, num_qubits)
 
     # Execute the circuit on the qasm simulator
     job = q.execute(dj_circuit, simulator, shots=1000)
@@ -118,8 +118,5 @@ def deutsch_jozsa(case: str, n: int) -> q.result.counts.Counts:
 
 
 if __name__ == "__main__":
-    counts = deutsch_jozsa("constant", 3)
-    print(f"Deutsch Jozsa - Constant Oracle: {counts}")
-
-    counts = deutsch_jozsa("balanced", 3)
-    print(f"Deutsch Jozsa - Balanced Oracle: {counts}")
+    print(f"Deutsch Jozsa - Constant Oracle: {deutsch_jozsa('constant', 3)}")
+    print(f"Deutsch Jozsa - Balanced Oracle: {deutsch_jozsa('balanced', 3)}")