Implement Deutsch-Jozsa Algorithm In Qiskit

Signed-off-by: Abhishek Jaisingh <abhi2254015@gmail.com>

Author: abhishekjiitr

quantum/deutsch_jozsa.py

@@ -0,0 +1,100 @@
+#!/usr/bin/env python3
+"""
+Implement Deutsch-Josza Algorithm in Qiskit.
+
+References:
+- https://en.wikipedia.org/wiki/Deutsch-Jozsa_algorithm
+- https://qiskit.org/textbook/ch-states/atoms-computation.html#4.2-Remembering-how-to-add-
+""" # noqa
+
+import numpy as np
+import qiskit as q
+
+
+def dj_oracle(case: str, n: int) -> q.QuantumCircuit:
+    # We need to make a QuantumCircuit object to return
+    # This circuit has n+1 qubits: the size of the input,
+    # plus one output qubit
+    oracle_qc = q.QuantumCircuit(n+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)
+        # Next, format 'b' as a binary string of length 'n', padded with zeros:
+        b_str = format(b, '0'+str(n)+'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)
+        # 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)
+        # Next, place the final X-gates
+        for qubit in range(len(b_str)):
+            if b_str[qubit] == '1':
+                oracle_qc.x(qubit)
+
+    # 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_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:
+    dj_circuit = q.QuantumCircuit(n+1, n)
+    # Set up the output qubit:
+    dj_circuit.x(n)
+    dj_circuit.h(n)
+    # And set up the input register:
+    for qubit in range(n):
+        dj_circuit.h(qubit)
+    # Let's append the oracle gate to our circuit:
+    dj_circuit.append(oracle, range(n+1))
+    # Finally, perform the H-gates again and measure:
+    for qubit in range(n):
+        dj_circuit.h(qubit)
+    
+    for i in range(n):
+        dj_circuit.measure(i, i)
+    
+    return dj_circuit
+
+
+def deutsch_jozsa(case: str, n: int) -> q.result.counts.Counts:
+    """
+    >>> deutsch_jozsa("constant", 3)
+    {'000': 1000}
+    >>> deutsch_jozsa("balanced", 3)
+    {'111': 1000}
+    """
+    # 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)
+
+    # Execute the circuit on the qasm simulator
+    job = q.execute(dj_circuit, simulator, shots=1000)
+
+    # Return the histogram data of the results of the experiment.
+    return job.result().get_counts(dj_circuit)
+
+
+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}")