From 2859d4bf3aa96737a4715c65d4a9051d9c62d24d Mon Sep 17 00:00:00 2001 From: Tianyi Zheng Date: Wed, 19 Oct 2022 16:12:44 -0400 Subject: [PATCH] Remove references to depreciated QasmSimulator (#7417) * Fix typos * Replace depreciated QasmSimulator in Deutsch-Jozsa algorithm * Replace depreciated QasmSimulator in half adder algorithm * Replace depreciated QasmSimulator in not gate algorithm * Replace depreciated QasmSimulator in full adder algorithm * Simplify qiskit import * Make formatting more consistent * Replace depreciated QasmSimulator in quantum entanglement algorithm * Replace depreciated QasmSimulator in ripple adder algorithm * Replace depreciated QasmSimulator in qubit measure algorithm * [pre-commit.ci] auto fixes from pre-commit.com hooks for more information, see https://pre-commit.ci * updating DIRECTORY.md * updating DIRECTORY.md * Remove qiskit import alias for clarity Co-authored-by: pre-commit-ci[bot] <66853113+pre-commit-ci[bot]@users.noreply.github.com> Co-authored-by: github-actions <${GITHUB_ACTOR}@users.noreply.github.com> --- DIRECTORY.md | 4 ++++ quantum/deutsch_jozsa.py | 28 +++++++++++++++------------- quantum/half_adder.py | 14 +++++++------- quantum/not_gate.py | 14 ++++++++------ quantum/q_full_adder.py | 27 +++++++++++++-------------- quantum/quantum_entanglement.py | 6 +++--- quantum/ripple_adder_classic.py | 16 ++++++++-------- quantum/single_qubit_measure.py | 16 +++++++++------- 8 files changed, 67 insertions(+), 58 deletions(-) diff --git a/DIRECTORY.md b/DIRECTORY.md index c1fad8d9d..1fad28798 100644 --- a/DIRECTORY.md +++ b/DIRECTORY.md @@ -27,6 +27,7 @@ * [Hamiltonian Cycle](backtracking/hamiltonian_cycle.py) * [Knight Tour](backtracking/knight_tour.py) * [Minimax](backtracking/minimax.py) + * [Minmax](backtracking/minmax.py) * [N Queens](backtracking/n_queens.py) * [N Queens Math](backtracking/n_queens_math.py) * [Rat In Maze](backtracking/rat_in_maze.py) @@ -157,6 +158,7 @@ * [Binary Tree Mirror](data_structures/binary_tree/binary_tree_mirror.py) * [Binary Tree Node Sum](data_structures/binary_tree/binary_tree_node_sum.py) * [Binary Tree Traversals](data_structures/binary_tree/binary_tree_traversals.py) + * [Diff Views Of Binary Tree](data_structures/binary_tree/diff_views_of_binary_tree.py) * [Fenwick Tree](data_structures/binary_tree/fenwick_tree.py) * [Inorder Tree Traversal 2022](data_structures/binary_tree/inorder_tree_traversal_2022.py) * [Lazy Segment Tree](data_structures/binary_tree/lazy_segment_tree.py) @@ -513,6 +515,7 @@ * [Gamma](maths/gamma.py) * [Gamma Recursive](maths/gamma_recursive.py) * [Gaussian](maths/gaussian.py) + * [Gaussian Error Linear Unit](maths/gaussian_error_linear_unit.py) * [Greatest Common Divisor](maths/greatest_common_divisor.py) * [Greedy Coin Change](maths/greedy_coin_change.py) * [Hamming Numbers](maths/hamming_numbers.py) @@ -601,6 +604,7 @@ * [Inverse Of Matrix](matrix/inverse_of_matrix.py) * [Matrix Class](matrix/matrix_class.py) * [Matrix Operation](matrix/matrix_operation.py) + * [Max Area Of Island](matrix/max_area_of_island.py) * [Nth Fibonacci Using Matrix Exponentiation](matrix/nth_fibonacci_using_matrix_exponentiation.py) * [Rotate Matrix](matrix/rotate_matrix.py) * [Searching In Sorted Matrix](matrix/searching_in_sorted_matrix.py) diff --git a/quantum/deutsch_jozsa.py b/quantum/deutsch_jozsa.py index d7e2d8335..95c3e65b5 100755 --- a/quantum/deutsch_jozsa.py +++ b/quantum/deutsch_jozsa.py @@ -1,6 +1,6 @@ #!/usr/bin/env python3 """ -Deutsch-Josza Algorithm is one of the first examples of a quantum +Deutsch-Jozsa Algorithm is one of the first examples of a quantum algorithm that is exponentially faster than any possible deterministic classical algorithm @@ -22,10 +22,10 @@ References: """ import numpy as np -import qiskit as q +import qiskit -def dj_oracle(case: str, num_qubits: int) -> q.QuantumCircuit: +def dj_oracle(case: str, num_qubits: int) -> qiskit.QuantumCircuit: """ Returns a Quantum Circuit for the Oracle function. The circuit returned can represent balanced or constant function, @@ -33,7 +33,7 @@ def dj_oracle(case: str, num_qubits: int) -> q.QuantumCircuit: """ # This circuit has num_qubits+1 qubits: the size of the input, # plus one output qubit - oracle_qc = q.QuantumCircuit(num_qubits + 1) + oracle_qc = qiskit.QuantumCircuit(num_qubits + 1) # First, let's deal with the case in which oracle is balanced if case == "balanced": @@ -43,7 +43,7 @@ def dj_oracle(case: str, num_qubits: int) -> q.QuantumCircuit: # Next, format 'b' as a binary string of length 'n', padded with zeros: 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 + # corresponds to a qubit, if the digit is 0, we do nothing, if it's 1 # we apply an X-gate to that qubit: for index, bit in enumerate(b_str): if bit == "1": @@ -70,13 +70,15 @@ def dj_oracle(case: str, num_qubits: int) -> q.QuantumCircuit: return oracle_gate -def dj_algorithm(oracle: q.QuantumCircuit, num_qubits: int) -> q.QuantumCircuit: +def dj_algorithm( + oracle: qiskit.QuantumCircuit, num_qubits: int +) -> qiskit.QuantumCircuit: """ - Returns the complete Deustch-Jozsa Quantum Circuit, + Returns the complete Deutsch-Jozsa Quantum Circuit, adding Input & Output registers and Hadamard & Measurement Gates, to the Oracle Circuit passed in arguments """ - dj_circuit = q.QuantumCircuit(num_qubits + 1, num_qubits) + dj_circuit = qiskit.QuantumCircuit(num_qubits + 1, num_qubits) # Set up the output qubit: dj_circuit.x(num_qubits) dj_circuit.h(num_qubits) @@ -95,7 +97,7 @@ def dj_algorithm(oracle: q.QuantumCircuit, num_qubits: int) -> q.QuantumCircuit: return dj_circuit -def deutsch_jozsa(case: str, num_qubits: int) -> q.result.counts.Counts: +def deutsch_jozsa(case: str, num_qubits: int) -> qiskit.result.counts.Counts: """ Main function that builds the circuit using other helper functions, runs the experiment 1000 times & returns the resultant qubit counts @@ -104,14 +106,14 @@ def deutsch_jozsa(case: str, num_qubits: int) -> q.result.counts.Counts: >>> deutsch_jozsa("balanced", 3) {'111': 1000} """ - # Use Aer's qasm_simulator - simulator = q.Aer.get_backend("qasm_simulator") + # Use Aer's simulator + simulator = qiskit.Aer.get_backend("aer_simulator") 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) + # Execute the circuit on the simulator + job = qiskit.execute(dj_circuit, simulator, shots=1000) # Return the histogram data of the results of the experiment. return job.result().get_counts(dj_circuit) diff --git a/quantum/half_adder.py b/quantum/half_adder.py index 4af704e64..21a57ddcf 100755 --- a/quantum/half_adder.py +++ b/quantum/half_adder.py @@ -10,10 +10,10 @@ https://en.wikipedia.org/wiki/Adder_(electronics) https://qiskit.org/textbook/ch-states/atoms-computation.html#4.2-Remembering-how-to-add- """ -import qiskit as q +import qiskit -def half_adder(bit0: int, bit1: int) -> q.result.counts.Counts: +def half_adder(bit0: int, bit1: int) -> qiskit.result.counts.Counts: """ >>> half_adder(0, 0) {'00': 1000} @@ -24,10 +24,10 @@ def half_adder(bit0: int, bit1: int) -> q.result.counts.Counts: >>> half_adder(1, 1) {'10': 1000} """ - # Use Aer's qasm_simulator - simulator = q.Aer.get_backend("qasm_simulator") + # Use Aer's simulator + simulator = qiskit.Aer.get_backend("aer_simulator") - qc_ha = q.QuantumCircuit(4, 2) + qc_ha = qiskit.QuantumCircuit(4, 2) # encode inputs in qubits 0 and 1 if bit0 == 1: qc_ha.x(0) @@ -48,9 +48,9 @@ def half_adder(bit0: int, bit1: int) -> q.result.counts.Counts: qc_ha.measure(3, 1) # extract AND value # Execute the circuit on the qasm simulator - job = q.execute(qc_ha, simulator, shots=1000) + job = qiskit.execute(qc_ha, simulator, shots=1000) - # Return the histogram data of the results of the experiment. + # Return the histogram data of the results of the experiment return job.result().get_counts(qc_ha) diff --git a/quantum/not_gate.py b/quantum/not_gate.py index e68a78009..ee23272d7 100644 --- a/quantum/not_gate.py +++ b/quantum/not_gate.py @@ -6,21 +6,23 @@ times and print the total count of the states finally observed. Qiskit Docs: https://qiskit.org/documentation/getting_started.html """ -import qiskit as q +import qiskit -def single_qubit_measure(qubits: int, classical_bits: int) -> q.result.counts.Counts: +def single_qubit_measure( + qubits: int, classical_bits: int +) -> qiskit.result.counts.Counts: """ >>> single_qubit_measure(2, 2) {'11': 1000} >>> single_qubit_measure(4, 4) {'0011': 1000} """ - # Use Aer's qasm_simulator - simulator = q.Aer.get_backend("qasm_simulator") + # Use Aer's simulator + simulator = qiskit.Aer.get_backend("aer_simulator") # Create a Quantum Circuit acting on the q register - circuit = q.QuantumCircuit(qubits, classical_bits) + circuit = qiskit.QuantumCircuit(qubits, classical_bits) # Apply X (NOT) Gate to Qubits 0 & 1 circuit.x(0) @@ -30,7 +32,7 @@ def single_qubit_measure(qubits: int, classical_bits: int) -> q.result.counts.Co circuit.measure([0, 1], [0, 1]) # Execute the circuit on the qasm simulator - job = q.execute(circuit, simulator, shots=1000) + job = qiskit.execute(circuit, simulator, shots=1000) # Return the histogram data of the results of the experiment. return job.result().get_counts(circuit) diff --git a/quantum/q_full_adder.py b/quantum/q_full_adder.py index 597efb834..c6d03d170 100644 --- a/quantum/q_full_adder.py +++ b/quantum/q_full_adder.py @@ -11,7 +11,6 @@ https://www.quantum-inspire.com/kbase/full-adder/ import math import qiskit -from qiskit import Aer, ClassicalRegister, QuantumCircuit, QuantumRegister, execute def quantum_full_adder( @@ -38,25 +37,25 @@ def quantum_full_adder( carry_in: carry in for the circuit. Returns: qiskit.result.counts.Counts: sum result counts. - >>> quantum_full_adder(1,1,1) + >>> quantum_full_adder(1, 1, 1) {'11': 1000} - >>> quantum_full_adder(0,0,1) + >>> quantum_full_adder(0, 0, 1) {'01': 1000} - >>> quantum_full_adder(1,0,1) + >>> quantum_full_adder(1, 0, 1) {'10': 1000} - >>> quantum_full_adder(1,-4,1) + >>> quantum_full_adder(1, -4, 1) Traceback (most recent call last): ... ValueError: inputs must be positive. - >>> quantum_full_adder('q',0,1) + >>> quantum_full_adder('q', 0, 1) Traceback (most recent call last): ... TypeError: inputs must be integers. - >>> quantum_full_adder(0.5,0,1) + >>> quantum_full_adder(0.5, 0, 1) Traceback (most recent call last): ... ValueError: inputs must be exact integers. - >>> quantum_full_adder(0,1,3) + >>> quantum_full_adder(0, 1, 3) Traceback (most recent call last): ... ValueError: inputs must be less or equal to 2. @@ -78,12 +77,12 @@ def quantum_full_adder( raise ValueError("inputs must be less or equal to 2.") # build registers - qr = QuantumRegister(4, "qr") - cr = ClassicalRegister(2, "cr") + qr = qiskit.QuantumRegister(4, "qr") + cr = qiskit.ClassicalRegister(2, "cr") # list the entries entry = [input_1, input_2, carry_in] - quantum_circuit = QuantumCircuit(qr, cr) + quantum_circuit = qiskit.QuantumCircuit(qr, cr) for i in range(0, 3): if entry[i] == 2: @@ -102,11 +101,11 @@ def quantum_full_adder( quantum_circuit.measure([2, 3], cr) # measure the last two qbits - backend = Aer.get_backend("qasm_simulator") - job = execute(quantum_circuit, backend, shots=1000) + backend = qiskit.Aer.get_backend("aer_simulator") + job = qiskit.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)}") + print(f"Total sum count for state is: {quantum_full_adder(1, 1, 1)}") diff --git a/quantum/quantum_entanglement.py b/quantum/quantum_entanglement.py index 3d8e27713..08fc32e49 100644 --- a/quantum/quantum_entanglement.py +++ b/quantum/quantum_entanglement.py @@ -29,8 +29,8 @@ def quantum_entanglement(qubits: int = 2) -> qiskit.result.counts.Counts: """ classical_bits = qubits - # Using Aer's qasm_simulator - simulator = qiskit.Aer.get_backend("qasm_simulator") + # Using Aer's simulator + simulator = qiskit.Aer.get_backend("aer_simulator") # Creating a Quantum Circuit acting on the q register circuit = qiskit.QuantumCircuit(qubits, classical_bits) @@ -48,7 +48,7 @@ def quantum_entanglement(qubits: int = 2) -> qiskit.result.counts.Counts: # Now measuring any one qubit would affect other qubits to collapse # their super position and have same state as the measured one. - # Executing the circuit on the qasm simulator + # Executing the circuit on the simulator job = qiskit.execute(circuit, simulator, shots=1000) return job.result().get_counts(circuit) diff --git a/quantum/ripple_adder_classic.py b/quantum/ripple_adder_classic.py index 1d3724476..c07757af7 100644 --- a/quantum/ripple_adder_classic.py +++ b/quantum/ripple_adder_classic.py @@ -2,11 +2,11 @@ # https://en.wikipedia.org/wiki/Adder_(electronics)#Full_adder # https://en.wikipedia.org/wiki/Controlled_NOT_gate -from qiskit import Aer, QuantumCircuit, execute +import qiskit from qiskit.providers import Backend -def store_two_classics(val1: int, val2: int) -> tuple[QuantumCircuit, str, str]: +def store_two_classics(val1: int, val2: int) -> tuple[qiskit.QuantumCircuit, str, str]: """ Generates a Quantum Circuit which stores two classical integers Returns the circuit and binary representation of the integers @@ -21,10 +21,10 @@ def store_two_classics(val1: int, val2: int) -> tuple[QuantumCircuit, str, str]: # We need (3 * number of bits in the larger number)+1 qBits # The second parameter is the number of classical registers, to measure the result - circuit = QuantumCircuit((len(x) * 3) + 1, len(x) + 1) + circuit = qiskit.QuantumCircuit((len(x) * 3) + 1, len(x) + 1) # We are essentially "not-ing" the bits that are 1 - # Reversed because its easier to perform ops on more significant bits + # Reversed because it's easier to perform ops on more significant bits for i in range(len(x)): if x[::-1][i] == "1": circuit.x(i) @@ -36,7 +36,7 @@ def store_two_classics(val1: int, val2: int) -> tuple[QuantumCircuit, str, str]: def full_adder( - circuit: QuantumCircuit, + circuit: qiskit.QuantumCircuit, input1_loc: int, input2_loc: int, carry_in: int, @@ -55,14 +55,14 @@ def full_adder( # The default value for **backend** is the result of a function call which is not # normally recommended and causes flake8-bugbear to raise a B008 error. However, -# in this case, this is accptable because `Aer.get_backend()` is called when the +# in this case, this is acceptable because `Aer.get_backend()` is called when the # function is defined and that same backend is then reused for all function calls. def ripple_adder( val1: int, val2: int, - backend: Backend = Aer.get_backend("qasm_simulator"), # noqa: B008 + backend: Backend = qiskit.Aer.get_backend("aer_simulator"), # noqa: B008 ) -> int: """ Quantum Equivalent of a Ripple Adder Circuit @@ -104,7 +104,7 @@ def ripple_adder( for i in range(len(x) + 1): circuit.measure([(len(x) * 2) + i], [i]) - res = execute(circuit, backend, shots=1).result() + res = qiskit.execute(circuit, backend, shots=1).result() # The result is in binary. Convert it back to int return int(list(res.get_counts())[0], 2) diff --git a/quantum/single_qubit_measure.py b/quantum/single_qubit_measure.py index 7f058c217..605bd8043 100755 --- a/quantum/single_qubit_measure.py +++ b/quantum/single_qubit_measure.py @@ -6,25 +6,27 @@ finally prints the total count of the states finally observed. Qiskit Docs: https://qiskit.org/documentation/getting_started.html """ -import qiskit as q +import qiskit -def single_qubit_measure(qubits: int, classical_bits: int) -> q.result.counts.Counts: +def single_qubit_measure( + qubits: int, classical_bits: int +) -> qiskit.result.counts.Counts: """ >>> single_qubit_measure(1, 1) {'0': 1000} """ - # Use Aer's qasm_simulator - simulator = q.Aer.get_backend("qasm_simulator") + # Use Aer's simulator + simulator = qiskit.Aer.get_backend("aer_simulator") # Create a Quantum Circuit acting on the q register - circuit = q.QuantumCircuit(qubits, classical_bits) + circuit = qiskit.QuantumCircuit(qubits, classical_bits) # Map the quantum measurement to the classical bits circuit.measure([0], [0]) - # Execute the circuit on the qasm simulator - job = q.execute(circuit, simulator, shots=1000) + # Execute the circuit on the simulator + job = qiskit.execute(circuit, simulator, shots=1000) # Return the histogram data of the results of the experiment. return job.result().get_counts(circuit)