From ba5499f26087075193ffd04f3152d46561e0d589 Mon Sep 17 00:00:00 2001 From: Kevin Joven <59969678+KevinJoven11@users.noreply.github.com> Date: Wed, 5 Oct 2022 00:58:06 -0400 Subject: [PATCH 1/8] create quantum_fourier_transform This is part of the #Hacktoberfest. I build the quantum fourier transform for N qubits. (n = 3 in the example) Best, Kevin --- quantum/q_fourier_transform.py | 63 ++++++++++++++++++++++++++++++++++ 1 file changed, 63 insertions(+) create mode 100644 quantum/q_fourier_transform.py diff --git a/quantum/q_fourier_transform.py b/quantum/q_fourier_transform.py new file mode 100644 index 000000000000..e3395d575be2 --- /dev/null +++ b/quantum/q_fourier_transform.py @@ -0,0 +1,63 @@ +""" +Build the quantum fourier transform (qft) for a desire +number of quantum bits using Qiskit framework. This +experiment run in IBM Q simulator with 10000 shots. +This circuit can be use as a building block to design +the Shor's algorithm in quantum computing. As well as, +quantum phase estimation among others. +. +References: +https://en.wikipedia.org/wiki/Quantum_Fourier_transform +https://qiskit.org/textbook/ch-algorithms/quantum-fourier-transform.html +""" + +import qiskit +from qiskit import QuantumCircuit, QuantumRegister, ClassicalRegister, execute, Aer +import numpy as np + +def qft(n: int = 3) -> qiskit.result.counts.Counts: + """ + # >>> qft(qbits_number) + # ideally "shots/2**qbits" counts for each state. + # For the default case (n=3) the average is 1250 for + # each quantum state. + ┌───┐ + qr_0: ──────■──────────────────────■───────┤ H ├─X─ + │ ┌───┐ │P(π/2) └───┘ │ + qr_1: ──────┼────────■───────┤ H ├─■─────────────┼─ + ┌───┐ │P(π/4) │P(π/2) └───┘ │ + qr_2: ┤ H ├─■────────■───────────────────────────X─ + └───┘ + cr: 3/═════════════════════════════════════════════ + Args: + n : number of qubits + Returns: + qiskit.result.counts.Counts: Counts for each state. + """ + qr = QuantumRegister(n, 'qr') + cr = ClassicalRegister(n, 'cr') + + quantum_circuit = QuantumCircuit(qr, cr) + + counter = n + # Add the hadamard gates and the CROT gates. + for i in range(counter): + + quantum_circuit.h(n-i-1) + counter = counter-1 + for j in range(counter): + quantum_circuit.cp(np.pi/2**(counter-j), j, counter) + + for k in range(n//2): + quantum_circuit.swap(k, n-k-1) + + # measure all the qubits + quantum_circuit.measure(qr,cr) + # simulate with 10000 shots + backend = Aer.get_backend('qasm_simulator') + job = execute(quantum_circuit,backend, shots = 10000) + + return job.result().get_counts(quantum_circuit) + +if __name__ == "__main__": + print(f"Total count for qft state is: {qft(3)}") From 0b6170b2cea07ea8d5979e3159074fa17e627b0f Mon Sep 17 00:00:00 2001 From: "pre-commit-ci[bot]" <66853113+pre-commit-ci[bot]@users.noreply.github.com> Date: Wed, 5 Oct 2022 05:00:23 +0000 Subject: [PATCH 2/8] [pre-commit.ci] auto fixes from pre-commit.com hooks for more information, see https://pre-commit.ci --- quantum/q_fourier_transform.py | 34 ++++++++++++++++++---------------- 1 file changed, 18 insertions(+), 16 deletions(-) diff --git a/quantum/q_fourier_transform.py b/quantum/q_fourier_transform.py index e3395d575be2..7b2c27b60584 100644 --- a/quantum/q_fourier_transform.py +++ b/quantum/q_fourier_transform.py @@ -11,9 +11,10 @@ https://qiskit.org/textbook/ch-algorithms/quantum-fourier-transform.html """ -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 qft(n: int = 3) -> qiskit.result.counts.Counts: """ @@ -21,21 +22,21 @@ def qft(n: int = 3) -> qiskit.result.counts.Counts: # ideally "shots/2**qbits" counts for each state. # For the default case (n=3) the average is 1250 for # each quantum state. - ┌───┐ + ┌───┐ qr_0: ──────■──────────────────────■───────┤ H ├─X─ - │ ┌───┐ │P(π/2) └───┘ │ + │ ┌───┐ │P(π/2) └───┘ │ qr_1: ──────┼────────■───────┤ H ├─■─────────────┼─ - ┌───┐ │P(π/4) │P(π/2) └───┘ │ + ┌───┐ │P(π/4) │P(π/2) └───┘ │ qr_2: ┤ H ├─■────────■───────────────────────────X─ - └───┘ + └───┘ cr: 3/═════════════════════════════════════════════ Args: n : number of qubits Returns: qiskit.result.counts.Counts: Counts for each state. """ - qr = QuantumRegister(n, 'qr') - cr = ClassicalRegister(n, 'cr') + qr = QuantumRegister(n, "qr") + cr = ClassicalRegister(n, "cr") quantum_circuit = QuantumCircuit(qr, cr) @@ -43,21 +44,22 @@ def qft(n: int = 3) -> qiskit.result.counts.Counts: # Add the hadamard gates and the CROT gates. for i in range(counter): - quantum_circuit.h(n-i-1) - counter = counter-1 + quantum_circuit.h(n - i - 1) + counter = counter - 1 for j in range(counter): - quantum_circuit.cp(np.pi/2**(counter-j), j, counter) + quantum_circuit.cp(np.pi / 2 ** (counter - j), j, counter) - for k in range(n//2): - quantum_circuit.swap(k, n-k-1) + for k in range(n // 2): + quantum_circuit.swap(k, n - k - 1) # measure all the qubits - quantum_circuit.measure(qr,cr) + quantum_circuit.measure(qr, cr) # simulate with 10000 shots - backend = Aer.get_backend('qasm_simulator') - job = execute(quantum_circuit,backend, shots = 10000) + backend = Aer.get_backend("qasm_simulator") + job = execute(quantum_circuit, backend, shots=10000) return job.result().get_counts(quantum_circuit) + if __name__ == "__main__": print(f"Total count for qft state is: {qft(3)}") From d8098c8a19dccd63fc839d80bf0909ed4ecb959f Mon Sep 17 00:00:00 2001 From: Kevin Joven <59969678+KevinJoven11@users.noreply.github.com> Date: Sat, 15 Oct 2022 12:16:58 -0400 Subject: [PATCH 3/8] Update q_fourier_transform.py --- quantum/q_fourier_transform.py | 51 +++++++++++++++++----------------- 1 file changed, 25 insertions(+), 26 deletions(-) diff --git a/quantum/q_fourier_transform.py b/quantum/q_fourier_transform.py index 7b2c27b60584..ea93d702baef 100644 --- a/quantum/q_fourier_transform.py +++ b/quantum/q_fourier_transform.py @@ -11,55 +11,54 @@ https://qiskit.org/textbook/ch-algorithms/quantum-fourier-transform.html """ -import numpy as np import qiskit -from qiskit import Aer, ClassicalRegister, QuantumCircuit, QuantumRegister, execute +from qiskit import QuantumCircuit, QuantumRegister, ClassicalRegister, execute, Aer +import numpy as np -def qft(n: int = 3) -> qiskit.result.counts.Counts: +def quantum_fourier_transform(number_of_qubits: int = 3) -> qiskit.result.counts.Counts: """ - # >>> qft(qbits_number) - # ideally "shots/2**qbits" counts for each state. - # For the default case (n=3) the average is 1250 for - # each quantum state. - ┌───┐ + # >>> quantum_fourier_transform(2) + # {'00': 2500, '01': 2500, '11': 2500, '10': 2500} + # quantum circuit for number_of_qubits = 3: + ┌───┐ qr_0: ──────■──────────────────────■───────┤ H ├─X─ - │ ┌───┐ │P(π/2) └───┘ │ + │ ┌───┐ │P(π/2) └───┘ │ qr_1: ──────┼────────■───────┤ H ├─■─────────────┼─ - ┌───┐ │P(π/4) │P(π/2) └───┘ │ + ┌───┐ │P(π/4) │P(π/2) └───┘ │ qr_2: ┤ H ├─■────────■───────────────────────────X─ - └───┘ + └───┘ cr: 3/═════════════════════════════════════════════ Args: n : number of qubits Returns: - qiskit.result.counts.Counts: Counts for each state. + qiskit.result.counts.Counts: distribute counts. """ - qr = QuantumRegister(n, "qr") - cr = ClassicalRegister(n, "cr") + qr = QuantumRegister(number_of_qubits, 'qr') + cr = ClassicalRegister(number_of_qubits, 'cr') quantum_circuit = QuantumCircuit(qr, cr) - counter = n - # Add the hadamard gates and the CROT gates. + counter = number_of_qubits + for i in range(counter): - quantum_circuit.h(n - i - 1) - counter = counter - 1 + quantum_circuit.h(number_of_qubits-i-1) + counter -= 1 for j in range(counter): - quantum_circuit.cp(np.pi / 2 ** (counter - j), j, counter) + quantum_circuit.cp(np.pi/2**(counter-j), j, counter) - for k in range(n // 2): - quantum_circuit.swap(k, n - k - 1) + for k in range(number_of_qubits//2): + quantum_circuit.swap(k, number_of_qubits-k-1) # measure all the qubits - quantum_circuit.measure(qr, cr) + quantum_circuit.measure(qr,cr) # simulate with 10000 shots - backend = Aer.get_backend("qasm_simulator") - job = execute(quantum_circuit, backend, shots=10000) + backend = Aer.get_backend('qasm_simulator') + job = execute(quantum_circuit,backend, shots = 10000) return job.result().get_counts(quantum_circuit) - if __name__ == "__main__": - print(f"Total count for qft state is: {qft(3)}") + print(f"Total count for quantum fourier transform state is: \ + {quantum_fourier_transform(3)}") From 1da72704263179b424313300ce426fc0ebf3a030 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 16:18:11 +0000 Subject: [PATCH 4/8] [pre-commit.ci] auto fixes from pre-commit.com hooks for more information, see https://pre-commit.ci --- quantum/q_fourier_transform.py | 37 ++++++++++++++++++---------------- 1 file changed, 20 insertions(+), 17 deletions(-) diff --git a/quantum/q_fourier_transform.py b/quantum/q_fourier_transform.py index ea93d702baef..865fa1b699e9 100644 --- a/quantum/q_fourier_transform.py +++ b/quantum/q_fourier_transform.py @@ -11,9 +11,9 @@ https://qiskit.org/textbook/ch-algorithms/quantum-fourier-transform.html """ -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 quantum_fourier_transform(number_of_qubits: int = 3) -> qiskit.result.counts.Counts: @@ -21,21 +21,21 @@ def quantum_fourier_transform(number_of_qubits: int = 3) -> qiskit.result.counts # >>> quantum_fourier_transform(2) # {'00': 2500, '01': 2500, '11': 2500, '10': 2500} # quantum circuit for number_of_qubits = 3: - ┌───┐ + ┌───┐ qr_0: ──────■──────────────────────■───────┤ H ├─X─ - │ ┌───┐ │P(π/2) └───┘ │ + │ ┌───┐ │P(π/2) └───┘ │ qr_1: ──────┼────────■───────┤ H ├─■─────────────┼─ - ┌───┐ │P(π/4) │P(π/2) └───┘ │ + ┌───┐ │P(π/4) │P(π/2) └───┘ │ qr_2: ┤ H ├─■────────■───────────────────────────X─ - └───┘ + └───┘ cr: 3/═════════════════════════════════════════════ Args: n : number of qubits Returns: qiskit.result.counts.Counts: distribute counts. """ - qr = QuantumRegister(number_of_qubits, 'qr') - cr = ClassicalRegister(number_of_qubits, 'cr') + qr = QuantumRegister(number_of_qubits, "qr") + cr = ClassicalRegister(number_of_qubits, "cr") quantum_circuit = QuantumCircuit(qr, cr) @@ -43,22 +43,25 @@ def quantum_fourier_transform(number_of_qubits: int = 3) -> qiskit.result.counts for i in range(counter): - quantum_circuit.h(number_of_qubits-i-1) + quantum_circuit.h(number_of_qubits - i - 1) counter -= 1 for j in range(counter): - quantum_circuit.cp(np.pi/2**(counter-j), j, counter) + quantum_circuit.cp(np.pi / 2 ** (counter - j), j, counter) - for k in range(number_of_qubits//2): - quantum_circuit.swap(k, number_of_qubits-k-1) + for k in range(number_of_qubits // 2): + quantum_circuit.swap(k, number_of_qubits - k - 1) # measure all the qubits - quantum_circuit.measure(qr,cr) + quantum_circuit.measure(qr, cr) # simulate with 10000 shots - backend = Aer.get_backend('qasm_simulator') - job = execute(quantum_circuit,backend, shots = 10000) + backend = Aer.get_backend("qasm_simulator") + job = execute(quantum_circuit, backend, shots=10000) return job.result().get_counts(quantum_circuit) + if __name__ == "__main__": - print(f"Total count for quantum fourier transform state is: \ - {quantum_fourier_transform(3)}") + print( + f"Total count for quantum fourier transform state is: \ + {quantum_fourier_transform(3)}" + ) From ba2fe160532aab5a46f27e407058bbed8d6d24af Mon Sep 17 00:00:00 2001 From: Kevin Joven <59969678+KevinJoven11@users.noreply.github.com> Date: Sat, 15 Oct 2022 12:59:27 -0400 Subject: [PATCH 5/8] Add the doctest! --- quantum/q_fourier_transform.py | 65 +++++++++++++++++++++++----------- 1 file changed, 44 insertions(+), 21 deletions(-) diff --git a/quantum/q_fourier_transform.py b/quantum/q_fourier_transform.py index 865fa1b699e9..fcab013ad7a9 100644 --- a/quantum/q_fourier_transform.py +++ b/quantum/q_fourier_transform.py @@ -11,31 +11,57 @@ https://qiskit.org/textbook/ch-algorithms/quantum-fourier-transform.html """ -import numpy as np import qiskit -from qiskit import Aer, ClassicalRegister, QuantumCircuit, QuantumRegister, execute - +from qiskit import QuantumCircuit, QuantumRegister, ClassicalRegister, execute, Aer +import numpy as np +import math def quantum_fourier_transform(number_of_qubits: int = 3) -> qiskit.result.counts.Counts: """ # >>> quantum_fourier_transform(2) # {'00': 2500, '01': 2500, '11': 2500, '10': 2500} # quantum circuit for number_of_qubits = 3: - ┌───┐ + ┌───┐ qr_0: ──────■──────────────────────■───────┤ H ├─X─ - │ ┌───┐ │P(π/2) └───┘ │ + │ ┌───┐ │P(π/2) └───┘ │ qr_1: ──────┼────────■───────┤ H ├─■─────────────┼─ - ┌───┐ │P(π/4) │P(π/2) └───┘ │ + ┌───┐ │P(π/4) │P(π/2) └───┘ │ qr_2: ┤ H ├─■────────■───────────────────────────X─ - └───┘ + └───┘ cr: 3/═════════════════════════════════════════════ Args: n : number of qubits Returns: qiskit.result.counts.Counts: distribute counts. + + >>> quantum_fourier_transform(-1) + Traceback (most recent call last): + ... + ValueError: number of qubits must be > 0. + >>> quantum_fourier_transform('a') + Traceback (most recent call last): + ... + TypeError: number of qubits must be a integer. + >>> quantum_fourier_transform(100) + Traceback (most recent call last): + ... + ValueError: number of qubits too large to simulate(>10). + >>> quantum_fourier_transform(0.5) + Traceback (most recent call last): + ... + ValueError: number of qubits must be exact integer. """ - qr = QuantumRegister(number_of_qubits, "qr") - cr = ClassicalRegister(number_of_qubits, "cr") + if type(number_of_qubits) == str: + raise TypeError("number of qubits must be a integer.") + if not number_of_qubits>0: + raise ValueError("number of qubits must be > 0.") + if math.floor(number_of_qubits) != number_of_qubits: + raise ValueError("number of qubits must be exact integer.") + if number_of_qubits > 10: + raise ValueError("number of qubits too large to simulate(>10).") + + qr = QuantumRegister(number_of_qubits, 'qr') + cr = ClassicalRegister(number_of_qubits, 'cr') quantum_circuit = QuantumCircuit(qr, cr) @@ -43,25 +69,22 @@ def quantum_fourier_transform(number_of_qubits: int = 3) -> qiskit.result.counts for i in range(counter): - quantum_circuit.h(number_of_qubits - i - 1) + quantum_circuit.h(number_of_qubits-i-1) counter -= 1 for j in range(counter): - quantum_circuit.cp(np.pi / 2 ** (counter - j), j, counter) + quantum_circuit.cp(np.pi/2**(counter-j), j, counter) - for k in range(number_of_qubits // 2): - quantum_circuit.swap(k, number_of_qubits - k - 1) + for k in range(number_of_qubits//2): + quantum_circuit.swap(k, number_of_qubits-k-1) # measure all the qubits - quantum_circuit.measure(qr, cr) + quantum_circuit.measure(qr,cr) # simulate with 10000 shots - backend = Aer.get_backend("qasm_simulator") - job = execute(quantum_circuit, backend, shots=10000) + backend = Aer.get_backend('qasm_simulator') + job = execute(quantum_circuit,backend, shots = 10000) return job.result().get_counts(quantum_circuit) - if __name__ == "__main__": - print( - f"Total count for quantum fourier transform state is: \ - {quantum_fourier_transform(3)}" - ) + print(f"Total count for quantum fourier transform state is: \ + {quantum_fourier_transform(3)}") From b9ae10705557873950d8cdd9a174ad2694c15dee 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 17:00:24 +0000 Subject: [PATCH 6/8] [pre-commit.ci] auto fixes from pre-commit.com hooks for more information, see https://pre-commit.ci --- quantum/q_fourier_transform.py | 43 +++++++++++++++++++--------------- 1 file changed, 24 insertions(+), 19 deletions(-) diff --git a/quantum/q_fourier_transform.py b/quantum/q_fourier_transform.py index fcab013ad7a9..ecc921788fdf 100644 --- a/quantum/q_fourier_transform.py +++ b/quantum/q_fourier_transform.py @@ -11,23 +11,25 @@ https://qiskit.org/textbook/ch-algorithms/quantum-fourier-transform.html """ -import qiskit -from qiskit import QuantumCircuit, QuantumRegister, ClassicalRegister, execute, Aer -import numpy as np import math +import numpy as np +import qiskit +from qiskit import Aer, ClassicalRegister, QuantumCircuit, QuantumRegister, execute + + def quantum_fourier_transform(number_of_qubits: int = 3) -> qiskit.result.counts.Counts: """ # >>> quantum_fourier_transform(2) # {'00': 2500, '01': 2500, '11': 2500, '10': 2500} # quantum circuit for number_of_qubits = 3: - ┌───┐ + ┌───┐ qr_0: ──────■──────────────────────■───────┤ H ├─X─ - │ ┌───┐ │P(π/2) └───┘ │ + │ ┌───┐ │P(π/2) └───┘ │ qr_1: ──────┼────────■───────┤ H ├─■─────────────┼─ - ┌───┐ │P(π/4) │P(π/2) └───┘ │ + ┌───┐ │P(π/4) │P(π/2) └───┘ │ qr_2: ┤ H ├─■────────■───────────────────────────X─ - └───┘ + └───┘ cr: 3/═════════════════════════════════════════════ Args: n : number of qubits @@ -53,15 +55,15 @@ def quantum_fourier_transform(number_of_qubits: int = 3) -> qiskit.result.counts """ if type(number_of_qubits) == str: raise TypeError("number of qubits must be a integer.") - if not number_of_qubits>0: + if not number_of_qubits > 0: raise ValueError("number of qubits must be > 0.") if math.floor(number_of_qubits) != number_of_qubits: raise ValueError("number of qubits must be exact integer.") if number_of_qubits > 10: raise ValueError("number of qubits too large to simulate(>10).") - qr = QuantumRegister(number_of_qubits, 'qr') - cr = ClassicalRegister(number_of_qubits, 'cr') + qr = QuantumRegister(number_of_qubits, "qr") + cr = ClassicalRegister(number_of_qubits, "cr") quantum_circuit = QuantumCircuit(qr, cr) @@ -69,22 +71,25 @@ def quantum_fourier_transform(number_of_qubits: int = 3) -> qiskit.result.counts for i in range(counter): - quantum_circuit.h(number_of_qubits-i-1) + quantum_circuit.h(number_of_qubits - i - 1) counter -= 1 for j in range(counter): - quantum_circuit.cp(np.pi/2**(counter-j), j, counter) + quantum_circuit.cp(np.pi / 2 ** (counter - j), j, counter) - for k in range(number_of_qubits//2): - quantum_circuit.swap(k, number_of_qubits-k-1) + for k in range(number_of_qubits // 2): + quantum_circuit.swap(k, number_of_qubits - k - 1) # measure all the qubits - quantum_circuit.measure(qr,cr) + quantum_circuit.measure(qr, cr) # simulate with 10000 shots - backend = Aer.get_backend('qasm_simulator') - job = execute(quantum_circuit,backend, shots = 10000) + backend = Aer.get_backend("qasm_simulator") + job = execute(quantum_circuit, backend, shots=10000) return job.result().get_counts(quantum_circuit) + if __name__ == "__main__": - print(f"Total count for quantum fourier transform state is: \ - {quantum_fourier_transform(3)}") + print( + f"Total count for quantum fourier transform state is: \ + {quantum_fourier_transform(3)}" + ) From 03921162767987364d8f6590588a79d47d939ac2 Mon Sep 17 00:00:00 2001 From: Kevin Joven <59969678+KevinJoven11@users.noreply.github.com> Date: Sat, 15 Oct 2022 13:58:04 -0400 Subject: [PATCH 7/8] Update q_fourier_transform.py --- quantum/q_fourier_transform.py | 2 ++ 1 file changed, 2 insertions(+) diff --git a/quantum/q_fourier_transform.py b/quantum/q_fourier_transform.py index ecc921788fdf..7397c5c6c22e 100644 --- a/quantum/q_fourier_transform.py +++ b/quantum/q_fourier_transform.py @@ -52,6 +52,8 @@ def quantum_fourier_transform(number_of_qubits: int = 3) -> qiskit.result.counts Traceback (most recent call last): ... ValueError: number of qubits must be exact integer. + >>> quantum_fourier_transform(2) + {'00': 2500, '01': 2500, '10': 2500, '11': 2500} """ if type(number_of_qubits) == str: raise TypeError("number of qubits must be a integer.") From 6bd53c2a7e8a7e7e9964b789a7b0729a921620ed Mon Sep 17 00:00:00 2001 From: Christian Clauss Date: Sat, 15 Oct 2022 20:06:25 +0200 Subject: [PATCH 8/8] Pass first then fail --- quantum/q_fourier_transform.py | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/quantum/q_fourier_transform.py b/quantum/q_fourier_transform.py index 7397c5c6c22e..d138dfb452ee 100644 --- a/quantum/q_fourier_transform.py +++ b/quantum/q_fourier_transform.py @@ -36,6 +36,8 @@ def quantum_fourier_transform(number_of_qubits: int = 3) -> qiskit.result.counts Returns: qiskit.result.counts.Counts: distribute counts. + >>> quantum_fourier_transform(2) + {'00': 2500, '01': 2500, '10': 2500, '11': 2500} >>> quantum_fourier_transform(-1) Traceback (most recent call last): ... @@ -52,8 +54,6 @@ def quantum_fourier_transform(number_of_qubits: int = 3) -> qiskit.result.counts Traceback (most recent call last): ... ValueError: number of qubits must be exact integer. - >>> quantum_fourier_transform(2) - {'00': 2500, '01': 2500, '10': 2500, '11': 2500} """ if type(number_of_qubits) == str: raise TypeError("number of qubits must be a integer.")