From 61a5708355279d0cfdfdd4ecd6f8bce6b393973d Mon Sep 17 00:00:00 2001 From: Kevin Joven <59969678+KevinJoven11@users.noreply.github.com> Date: Wed, 5 Oct 2022 21:44:55 -0400 Subject: [PATCH 1/7] Create q_full_adder.py This is for the #Hacktoberfest. This circuit is the quantum full adder. I saw that in the repo is the half adder so I decided to build the full adder to complete the set of adders. I hope that this is enough to be consider a contribution. Best, Kevin --- quantum/q_full_adder.py | 71 +++++++++++++++++++++++++++++++++++++++++ 1 file changed, 71 insertions(+) create mode 100644 quantum/q_full_adder.py diff --git a/quantum/q_full_adder.py b/quantum/q_full_adder.py new file mode 100644 index 000000000000..b54d09a4666e --- /dev/null +++ b/quantum/q_full_adder.py @@ -0,0 +1,71 @@ +""" +Build the quantum full adder (QFA) for any sum of +two quantum registers and one carry in. This circuit +is designed using the Qiskit framework. This +experiment run in IBM Q simulator with 1000 shots. +. +References: +https://www.quantum-inspire.com/kbase/full-adder/ +""" + +import qiskit +from qiskit import QuantumCircuit, QuantumRegister, ClassicalRegister, execute, Aer +import numpy as np + +def q_full_adder( + inp_1: int = 1, inp_2: int = 1, cin: int = 1 + ) -> qiskit.result.counts.Counts: + """ + # >>> q_full_adder(inp_1, inp_2, cin) + # the inputs can be 0/1 for qubits in define + # values, or can be in a superposition of both + # states with hadamard gate using the input value 2. + # result for default values: {11: 1000} + qr_0: ──■────■──────────────■── + │ ┌─┴─┐ ┌─┴─┐ + qr_1: ──■──┤ X ├──■────■──┤ X ├ + │ └───┘ │ ┌─┴─┐└───┘ + qr_2: ──┼─────────■──┤ X ├───── + ┌─┴─┐ ┌─┴─┐└───┘ + qr_3: ┤ X ├─────┤ X ├────────── + └───┘ └───┘ + cr: 2/═════════════════════════ + Args: + inp_1: input 1 for the circuit. + inp_2: input 2 for the circuit. + cin: carry in for the circuit. + Returns: + qiskit.result.counts.Counts: sum result counts. + """ + # build registers + qr = QuantumRegister(4, 'qr') + cr = ClassicalRegister(2, 'cr') + # list the entries + entry = [inp_1, inp_2, cin] + + quantum_circuit = QuantumCircuit(qr,cr) + + for i in range(0,3): + if entry[i] == 2: + quantum_circuit.h(i) #for hadamard entries + elif entry[i] == 1: + quantum_circuit.x(i) #for 1 entries + else: + quantum_circuit.i(i) #for 0 entries + + # build the circuit + quantum_circuit.ccx(0,1,3) # ccx = toffoli gate + quantum_circuit.cx(0,1) + quantum_circuit.ccx(1,2,3) + quantum_circuit.cx(1,2) + quantum_circuit.cx(0,1) + + quantum_circuit.measure([2,3],cr) # measure the last two qbits + + backend = Aer.get_backend('qasm_simulator') + job = execute(quantum_circuit, backend, shots=1000) + + return job.result().get_counts(quantum_circuit) + +if __name__ == "__main__": + print(f"Total sum count for state is: {q_full_adder()}") From 652795013ba658777edc224c375a66ca3e4cc532 Mon Sep 17 00:00:00 2001 From: "pre-commit-ci[bot]" <66853113+pre-commit-ci[bot]@users.noreply.github.com> Date: Thu, 6 Oct 2022 01:46:47 +0000 Subject: [PATCH 2/7] [pre-commit.ci] auto fixes from pre-commit.com hooks for more information, see https://pre-commit.ci --- quantum/q_full_adder.py | 44 +++++++++++++++++++++-------------------- 1 file changed, 23 insertions(+), 21 deletions(-) diff --git a/quantum/q_full_adder.py b/quantum/q_full_adder.py index b54d09a4666e..b802a66bea19 100644 --- a/quantum/q_full_adder.py +++ b/quantum/q_full_adder.py @@ -1,5 +1,5 @@ """ -Build the quantum full adder (QFA) for any sum of +Build the quantum full adder (QFA) for any sum of two quantum registers and one carry in. This circuit is designed using the Qiskit framework. This experiment run in IBM Q simulator with 1000 shots. @@ -8,27 +8,28 @@ https://www.quantum-inspire.com/kbase/full-adder/ """ -import qiskit -from qiskit import QuantumCircuit, QuantumRegister, ClassicalRegister, execute, Aer import numpy as np +import qiskit +from qiskit import Aer, ClassicalRegister, QuantumCircuit, QuantumRegister, execute + def q_full_adder( inp_1: int = 1, inp_2: int = 1, cin: int = 1 - ) -> qiskit.result.counts.Counts: +) -> qiskit.result.counts.Counts: """ # >>> q_full_adder(inp_1, inp_2, cin) # the inputs can be 0/1 for qubits in define # values, or can be in a superposition of both # states with hadamard gate using the input value 2. - # result for default values: {11: 1000} + # result for default values: {11: 1000} qr_0: ──■────■──────────────■── │ ┌─┴─┐ ┌─┴─┐ qr_1: ──■──┤ X ├──■────■──┤ X ├ │ └───┘ │ ┌─┴─┐└───┘ qr_2: ──┼─────────■──┤ X ├───── - ┌─┴─┐ ┌─┴─┐└───┘ + ┌─┴─┐ ┌─┴─┐└───┘ qr_3: ┤ X ├─────┤ X ├────────── - └───┘ └───┘ + └───┘ └───┘ cr: 2/═════════════════════════ Args: inp_1: input 1 for the circuit. @@ -38,34 +39,35 @@ def q_full_adder( qiskit.result.counts.Counts: sum result counts. """ # build registers - qr = QuantumRegister(4, 'qr') - cr = ClassicalRegister(2, 'cr') + qr = QuantumRegister(4, "qr") + cr = ClassicalRegister(2, "cr") # list the entries entry = [inp_1, inp_2, cin] - quantum_circuit = QuantumCircuit(qr,cr) + quantum_circuit = QuantumCircuit(qr, cr) - for i in range(0,3): + for i in range(0, 3): if entry[i] == 2: - quantum_circuit.h(i) #for hadamard entries + quantum_circuit.h(i) # for hadamard entries elif entry[i] == 1: - quantum_circuit.x(i) #for 1 entries + quantum_circuit.x(i) # for 1 entries else: - quantum_circuit.i(i) #for 0 entries + quantum_circuit.i(i) # for 0 entries # build the circuit - quantum_circuit.ccx(0,1,3) # ccx = toffoli gate - quantum_circuit.cx(0,1) - quantum_circuit.ccx(1,2,3) - quantum_circuit.cx(1,2) - quantum_circuit.cx(0,1) + quantum_circuit.ccx(0, 1, 3) # ccx = toffoli gate + quantum_circuit.cx(0, 1) + quantum_circuit.ccx(1, 2, 3) + quantum_circuit.cx(1, 2) + quantum_circuit.cx(0, 1) - quantum_circuit.measure([2,3],cr) # measure the last two qbits + quantum_circuit.measure([2, 3], cr) # measure the last two qbits - backend = Aer.get_backend('qasm_simulator') + backend = Aer.get_backend("qasm_simulator") job = execute(quantum_circuit, backend, shots=1000) return job.result().get_counts(quantum_circuit) + if __name__ == "__main__": print(f"Total sum count for state is: {q_full_adder()}") From 18102cb518ecbe75fa17c593e1ee3253e46b920b Mon Sep 17 00:00:00 2001 From: Kevin Joven <59969678+KevinJoven11@users.noreply.github.com> Date: Wed, 5 Oct 2022 21:51:02 -0400 Subject: [PATCH 3/7] Erase the unused numpy library --- quantum/q_full_adder.py | 1 - 1 file changed, 1 deletion(-) diff --git a/quantum/q_full_adder.py b/quantum/q_full_adder.py index b802a66bea19..9597a53bc336 100644 --- a/quantum/q_full_adder.py +++ b/quantum/q_full_adder.py @@ -8,7 +8,6 @@ https://www.quantum-inspire.com/kbase/full-adder/ """ -import numpy as np import qiskit from qiskit import Aer, ClassicalRegister, QuantumCircuit, QuantumRegister, execute From 2bd9282e85e4d7df94a45b0b246e3b6644b025be Mon Sep 17 00:00:00 2001 From: Kevin Joven <59969678+KevinJoven11@users.noreply.github.com> Date: Sat, 15 Oct 2022 17:36:20 -0400 Subject: [PATCH 4/7] Create the doctest. --- quantum/q_full_adder.py | 68 +++++++++++++++++++++++------------------ 1 file changed, 39 insertions(+), 29 deletions(-) diff --git a/quantum/q_full_adder.py b/quantum/q_full_adder.py index 9597a53bc336..7dbef1b2fc7d 100644 --- a/quantum/q_full_adder.py +++ b/quantum/q_full_adder.py @@ -1,5 +1,5 @@ """ -Build the quantum full adder (QFA) for any sum of +Build the quantum full adder (QFA) for any sum of two quantum registers and one carry in. This circuit is designed using the Qiskit framework. This experiment run in IBM Q simulator with 1000 shots. @@ -9,64 +9,74 @@ """ import qiskit -from qiskit import Aer, ClassicalRegister, QuantumCircuit, QuantumRegister, execute +from qiskit import QuantumCircuit, QuantumRegister, ClassicalRegister, execute, Aer - -def q_full_adder( - inp_1: int = 1, inp_2: int = 1, cin: int = 1 -) -> qiskit.result.counts.Counts: +def quantum_full_adder( + input_1: int = 1, input_2: int = 1, carry_in: int = 1 + ) -> qiskit.result.counts.Counts: """ # >>> q_full_adder(inp_1, inp_2, cin) # the inputs can be 0/1 for qubits in define # values, or can be in a superposition of both # states with hadamard gate using the input value 2. - # result for default values: {11: 1000} + # result for default values: {11: 1000} qr_0: ──■────■──────────────■── │ ┌─┴─┐ ┌─┴─┐ qr_1: ──■──┤ X ├──■────■──┤ X ├ │ └───┘ │ ┌─┴─┐└───┘ qr_2: ──┼─────────■──┤ X ├───── - ┌─┴─┐ ┌─┴─┐└───┘ + ┌─┴─┐ ┌─┴─┐└───┘ qr_3: ┤ X ├─────┤ X ├────────── - └───┘ └───┘ + └───┘ └───┘ cr: 2/═════════════════════════ Args: - inp_1: input 1 for the circuit. - inp_2: input 2 for the circuit. - cin: carry in for the circuit. + input_1: input 1 for the circuit. + input_2: input 2 for the circuit. + carry_in: carry in for the circuit. Returns: qiskit.result.counts.Counts: sum result counts. + >>> quantum_full_adder(1,1,1) + {'11': 1000} + >>> quantum_full_adder(0,0,1) + {'01': 1000} + >>> quantum_full_adder(1,0,1) + {'10': 1000} """ + # build registers - qr = QuantumRegister(4, "qr") - cr = ClassicalRegister(2, "cr") + qr = QuantumRegister(4, 'qr') + cr = ClassicalRegister(2, 'cr') # list the entries - entry = [inp_1, inp_2, cin] + entry = [input_1, input_2, carry_in] - quantum_circuit = QuantumCircuit(qr, cr) + quantum_circuit = QuantumCircuit(qr,cr) - for i in range(0, 3): + for i in range(0,3): if entry[i] == 2: - quantum_circuit.h(i) # for hadamard entries + quantum_circuit.h(i) #for hadamard entries elif entry[i] == 1: - quantum_circuit.x(i) # for 1 entries + quantum_circuit.x(i) #for 1 entries else: - quantum_circuit.i(i) # for 0 entries + if(entry[i] != 0): + print("Your entri {} is not valid, was change to "\ + "identity gate.".format(entry[i])) + quantum_circuit.i(i) #for 0 entries + else: + quantum_circuit.i(i) #for 0 entries # build the circuit - quantum_circuit.ccx(0, 1, 3) # ccx = toffoli gate - quantum_circuit.cx(0, 1) - quantum_circuit.ccx(1, 2, 3) - quantum_circuit.cx(1, 2) - quantum_circuit.cx(0, 1) + quantum_circuit.ccx(0,1,3) # ccx = toffoli gate + quantum_circuit.cx(0,1) + quantum_circuit.ccx(1,2,3) + quantum_circuit.cx(1,2) + quantum_circuit.cx(0,1) - quantum_circuit.measure([2, 3], cr) # measure the last two qbits + quantum_circuit.measure([2,3],cr) # measure the last two qbits - backend = Aer.get_backend("qasm_simulator") + backend = Aer.get_backend('qasm_simulator') job = execute(quantum_circuit, backend, shots=1000) return job.result().get_counts(quantum_circuit) - if __name__ == "__main__": - print(f"Total sum count for state is: {q_full_adder()}") + print(f"Total sum count for state is: {quantum_full_adder(1,1,1)}") From c3204d4780d0e14e6317e3f48cba8481a0379e3f Mon Sep 17 00:00:00 2001 From: "pre-commit-ci[bot]" <66853113+pre-commit-ci[bot]@users.noreply.github.com> Date: Sat, 15 Oct 2022 21:37:35 +0000 Subject: [PATCH 5/7] [pre-commit.ci] auto fixes from pre-commit.com hooks for more information, see https://pre-commit.ci --- quantum/q_full_adder.py | 52 ++++++++++++++++++++++------------------- 1 file changed, 28 insertions(+), 24 deletions(-) diff --git a/quantum/q_full_adder.py b/quantum/q_full_adder.py index 7dbef1b2fc7d..7ffca6921040 100644 --- a/quantum/q_full_adder.py +++ b/quantum/q_full_adder.py @@ -1,5 +1,5 @@ """ -Build the quantum full adder (QFA) for any sum of +Build the quantum full adder (QFA) for any sum of two quantum registers and one carry in. This circuit is designed using the Qiskit framework. This experiment run in IBM Q simulator with 1000 shots. @@ -9,25 +9,26 @@ """ import qiskit -from qiskit import QuantumCircuit, QuantumRegister, ClassicalRegister, execute, Aer +from qiskit import Aer, ClassicalRegister, QuantumCircuit, QuantumRegister, execute + def quantum_full_adder( input_1: int = 1, input_2: int = 1, carry_in: int = 1 - ) -> qiskit.result.counts.Counts: +) -> qiskit.result.counts.Counts: """ # >>> q_full_adder(inp_1, inp_2, cin) # the inputs can be 0/1 for qubits in define # values, or can be in a superposition of both # states with hadamard gate using the input value 2. - # result for default values: {11: 1000} + # result for default values: {11: 1000} qr_0: ──■────■──────────────■── │ ┌─┴─┐ ┌─┴─┐ qr_1: ──■──┤ X ├──■────■──┤ X ├ │ └───┘ │ ┌─┴─┐└───┘ qr_2: ──┼─────────■──┤ X ├───── - ┌─┴─┐ ┌─┴─┐└───┘ + ┌─┴─┐ ┌─┴─┐└───┘ qr_3: ┤ X ├─────┤ X ├────────── - └───┘ └───┘ + └───┘ └───┘ cr: 2/═════════════════════════ Args: input_1: input 1 for the circuit. @@ -44,39 +45,42 @@ def quantum_full_adder( """ # build registers - qr = QuantumRegister(4, 'qr') - cr = ClassicalRegister(2, 'cr') + qr = QuantumRegister(4, "qr") + cr = ClassicalRegister(2, "cr") # list the entries entry = [input_1, input_2, carry_in] - quantum_circuit = QuantumCircuit(qr,cr) + quantum_circuit = QuantumCircuit(qr, cr) - for i in range(0,3): + for i in range(0, 3): if entry[i] == 2: - quantum_circuit.h(i) #for hadamard entries + quantum_circuit.h(i) # for hadamard entries elif entry[i] == 1: - quantum_circuit.x(i) #for 1 entries + quantum_circuit.x(i) # for 1 entries else: - if(entry[i] != 0): - print("Your entri {} is not valid, was change to "\ - "identity gate.".format(entry[i])) - quantum_circuit.i(i) #for 0 entries + if entry[i] != 0: + print( + "Your entri {} is not valid, was change to " + "identity gate.".format(entry[i]) + ) + quantum_circuit.i(i) # for 0 entries else: - quantum_circuit.i(i) #for 0 entries + quantum_circuit.i(i) # for 0 entries # build the circuit - quantum_circuit.ccx(0,1,3) # ccx = toffoli gate - quantum_circuit.cx(0,1) - quantum_circuit.ccx(1,2,3) - quantum_circuit.cx(1,2) - quantum_circuit.cx(0,1) + quantum_circuit.ccx(0, 1, 3) # ccx = toffoli gate + quantum_circuit.cx(0, 1) + quantum_circuit.ccx(1, 2, 3) + quantum_circuit.cx(1, 2) + quantum_circuit.cx(0, 1) - quantum_circuit.measure([2,3],cr) # measure the last two qbits + quantum_circuit.measure([2, 3], cr) # measure the last two qbits - backend = Aer.get_backend('qasm_simulator') + backend = Aer.get_backend("qasm_simulator") job = execute(quantum_circuit, backend, shots=1000) return job.result().get_counts(quantum_circuit) + if __name__ == "__main__": print(f"Total sum count for state is: {quantum_full_adder(1,1,1)}") From 0b715a595545c94249e7895c8efe6f5e58a955e0 Mon Sep 17 00:00:00 2001 From: Kevin Joven <59969678+KevinJoven11@users.noreply.github.com> Date: Sat, 15 Oct 2022 21:15:10 -0400 Subject: [PATCH 6/7] doctest for negative numbers, float, etc. --- quantum/q_full_adder.py | 82 ++++++++++++++++++++++++++--------------- 1 file changed, 52 insertions(+), 30 deletions(-) diff --git a/quantum/q_full_adder.py b/quantum/q_full_adder.py index 7ffca6921040..a9e1216dd3b8 100644 --- a/quantum/q_full_adder.py +++ b/quantum/q_full_adder.py @@ -1,5 +1,5 @@ """ -Build the quantum full adder (QFA) for any sum of +Build the quantum full adder (QFA) for any sum of two quantum registers and one carry in. This circuit is designed using the Qiskit framework. This experiment run in IBM Q simulator with 1000 shots. @@ -9,26 +9,26 @@ """ import qiskit -from qiskit import Aer, ClassicalRegister, QuantumCircuit, QuantumRegister, execute - +from qiskit import QuantumCircuit, QuantumRegister, ClassicalRegister, execute, Aer +import math def quantum_full_adder( input_1: int = 1, input_2: int = 1, carry_in: int = 1 -) -> qiskit.result.counts.Counts: + ) -> qiskit.result.counts.Counts: """ # >>> q_full_adder(inp_1, inp_2, cin) # the inputs can be 0/1 for qubits in define # values, or can be in a superposition of both # states with hadamard gate using the input value 2. - # result for default values: {11: 1000} + # result for default values: {11: 1000} qr_0: ──■────■──────────────■── │ ┌─┴─┐ ┌─┴─┐ qr_1: ──■──┤ X ├──■────■──┤ X ├ │ └───┘ │ ┌─┴─┐└───┘ qr_2: ──┼─────────■──┤ X ├───── - ┌─┴─┐ ┌─┴─┐└───┘ + ┌─┴─┐ ┌─┴─┐└───┘ qr_3: ┤ X ├─────┤ X ├────────── - └───┘ └───┘ + └───┘ └───┘ cr: 2/═════════════════════════ Args: input_1: input 1 for the circuit. @@ -42,45 +42,67 @@ def quantum_full_adder( {'01': 1000} >>> quantum_full_adder(1,0,1) {'10': 1000} + >>> quantum_full_adder(1,-4,1) + Traceback (most recent call last): + ... + ValueError: inputs must be positive. + >>> quantum_full_adder('q',0,1) + Traceback (most recent call last): + ... + TypeError: inputs must be integers. + >>> quantum_full_adder(0.5,0,1) + Traceback (most recent call last): + ... + ValueError: inputs must be exact integers. + >>> quantum_full_adder(0,1,3) + Traceback (most recent call last): + ... + ValueError: inputs must be less or equal to 2. """ + if(type(input_1) == str) or (type(input_2) == str) or \ + (type(carry_in) == str): + raise TypeError("inputs must be integers.") + + if(input_1 < 0) or (input_2 < 0) or (carry_in < 0): + raise ValueError("inputs must be positive.") + + if (math.floor(input_1) != input_1) or \ + (math.floor(input_2) != input_2) or \ + (math.floor(carry_in) != carry_in): + raise ValueError("inputs must be exact integers.") + + if (input_1 > 2) or (input_2 > 2) or (carry_in > 2): + raise ValueError("inputs must be less or equal to 2.") # build registers - qr = QuantumRegister(4, "qr") - cr = ClassicalRegister(2, "cr") + qr = QuantumRegister(4, 'qr') + cr = ClassicalRegister(2, 'cr') # list the entries entry = [input_1, input_2, carry_in] - quantum_circuit = QuantumCircuit(qr, cr) + quantum_circuit = QuantumCircuit(qr,cr) - for i in range(0, 3): + for i in range(0,3): if entry[i] == 2: - quantum_circuit.h(i) # for hadamard entries + quantum_circuit.h(i) #for hadamard entries elif entry[i] == 1: - quantum_circuit.x(i) # for 1 entries - else: - if entry[i] != 0: - print( - "Your entri {} is not valid, was change to " - "identity gate.".format(entry[i]) - ) - quantum_circuit.i(i) # for 0 entries - else: - quantum_circuit.i(i) # for 0 entries + quantum_circuit.x(i) #for 1 entries + elif entry[i] == 0: + quantum_circuit.i(i) #for 0 entries # build the circuit - quantum_circuit.ccx(0, 1, 3) # ccx = toffoli gate - quantum_circuit.cx(0, 1) - quantum_circuit.ccx(1, 2, 3) - quantum_circuit.cx(1, 2) - quantum_circuit.cx(0, 1) + quantum_circuit.ccx(0,1,3) # ccx = toffoli gate + quantum_circuit.cx(0,1) + quantum_circuit.ccx(1,2,3) + quantum_circuit.cx(1,2) + quantum_circuit.cx(0,1) - quantum_circuit.measure([2, 3], cr) # measure the last two qbits + quantum_circuit.measure([2,3],cr) # measure the last two qbits - backend = Aer.get_backend("qasm_simulator") + backend = Aer.get_backend('qasm_simulator') job = execute(quantum_circuit, backend, shots=1000) return job.result().get_counts(quantum_circuit) - if __name__ == "__main__": print(f"Total sum count for state is: {quantum_full_adder(1,1,1)}") From ab40bc93dfc93d4481edc1fea6e6bf67f49643dd Mon Sep 17 00:00:00 2001 From: "pre-commit-ci[bot]" <66853113+pre-commit-ci[bot]@users.noreply.github.com> Date: Sun, 16 Oct 2022 01:16:06 +0000 Subject: [PATCH 7/7] [pre-commit.ci] auto fixes from pre-commit.com hooks for more information, see https://pre-commit.ci --- quantum/q_full_adder.py | 58 ++++++++++++++++++++++------------------- 1 file changed, 31 insertions(+), 27 deletions(-) diff --git a/quantum/q_full_adder.py b/quantum/q_full_adder.py index a9e1216dd3b8..597efb8342e1 100644 --- a/quantum/q_full_adder.py +++ b/quantum/q_full_adder.py @@ -1,5 +1,5 @@ """ -Build the quantum full adder (QFA) for any sum of +Build the quantum full adder (QFA) for any sum of two quantum registers and one carry in. This circuit is designed using the Qiskit framework. This experiment run in IBM Q simulator with 1000 shots. @@ -8,27 +8,29 @@ https://www.quantum-inspire.com/kbase/full-adder/ """ -import qiskit -from qiskit import QuantumCircuit, QuantumRegister, ClassicalRegister, execute, Aer import math +import qiskit +from qiskit import Aer, ClassicalRegister, QuantumCircuit, QuantumRegister, execute + + def quantum_full_adder( input_1: int = 1, input_2: int = 1, carry_in: int = 1 - ) -> qiskit.result.counts.Counts: +) -> qiskit.result.counts.Counts: """ # >>> q_full_adder(inp_1, inp_2, cin) # the inputs can be 0/1 for qubits in define # values, or can be in a superposition of both # states with hadamard gate using the input value 2. - # result for default values: {11: 1000} + # result for default values: {11: 1000} qr_0: ──■────■──────────────■── │ ┌─┴─┐ ┌─┴─┐ qr_1: ──■──┤ X ├──■────■──┤ X ├ │ └───┘ │ ┌─┴─┐└───┘ qr_2: ──┼─────────■──┤ X ├───── - ┌─┴─┐ ┌─┴─┐└───┘ + ┌─┴─┐ ┌─┴─┐└───┘ qr_3: ┤ X ├─────┤ X ├────────── - └───┘ └───┘ + └───┘ └───┘ cr: 2/═════════════════════════ Args: input_1: input 1 for the circuit. @@ -59,50 +61,52 @@ def quantum_full_adder( ... ValueError: inputs must be less or equal to 2. """ - if(type(input_1) == str) or (type(input_2) == str) or \ - (type(carry_in) == str): + if (type(input_1) == str) or (type(input_2) == str) or (type(carry_in) == str): raise TypeError("inputs must be integers.") - if(input_1 < 0) or (input_2 < 0) or (carry_in < 0): + if (input_1 < 0) or (input_2 < 0) or (carry_in < 0): raise ValueError("inputs must be positive.") - if (math.floor(input_1) != input_1) or \ - (math.floor(input_2) != input_2) or \ - (math.floor(carry_in) != carry_in): + if ( + (math.floor(input_1) != input_1) + or (math.floor(input_2) != input_2) + or (math.floor(carry_in) != carry_in) + ): raise ValueError("inputs must be exact integers.") if (input_1 > 2) or (input_2 > 2) or (carry_in > 2): raise ValueError("inputs must be less or equal to 2.") # build registers - qr = QuantumRegister(4, 'qr') - cr = ClassicalRegister(2, 'cr') + qr = QuantumRegister(4, "qr") + cr = ClassicalRegister(2, "cr") # list the entries entry = [input_1, input_2, carry_in] - quantum_circuit = QuantumCircuit(qr,cr) + quantum_circuit = QuantumCircuit(qr, cr) - for i in range(0,3): + for i in range(0, 3): if entry[i] == 2: - quantum_circuit.h(i) #for hadamard entries + quantum_circuit.h(i) # for hadamard entries elif entry[i] == 1: - quantum_circuit.x(i) #for 1 entries + quantum_circuit.x(i) # for 1 entries elif entry[i] == 0: - quantum_circuit.i(i) #for 0 entries + quantum_circuit.i(i) # for 0 entries # build the circuit - quantum_circuit.ccx(0,1,3) # ccx = toffoli gate - quantum_circuit.cx(0,1) - quantum_circuit.ccx(1,2,3) - quantum_circuit.cx(1,2) - quantum_circuit.cx(0,1) + quantum_circuit.ccx(0, 1, 3) # ccx = toffoli gate + quantum_circuit.cx(0, 1) + quantum_circuit.ccx(1, 2, 3) + quantum_circuit.cx(1, 2) + quantum_circuit.cx(0, 1) - quantum_circuit.measure([2,3],cr) # measure the last two qbits + quantum_circuit.measure([2, 3], cr) # measure the last two qbits - backend = Aer.get_backend('qasm_simulator') + backend = Aer.get_backend("qasm_simulator") job = execute(quantum_circuit, backend, shots=1000) return job.result().get_counts(quantum_circuit) + if __name__ == "__main__": print(f"Total sum count for state is: {quantum_full_adder(1,1,1)}")