diff --git a/.vscode/settings.json b/.vscode/settings.json index ef16fa1aa..e44c2eb91 100644 --- a/.vscode/settings.json +++ b/.vscode/settings.json @@ -1,5 +1,9 @@ { "githubPullRequests.ignoredPullRequestBranches": [ "master" - ] + ], + "[python]": { + "editor.defaultFormatter": "ms-python.black-formatter" + }, + "python.formatting.provider": "none" } diff --git a/quantum/pauli_gates.py b/quantum/pauli_gates.py new file mode 100644 index 000000000..bb9d357df --- /dev/null +++ b/quantum/pauli_gates.py @@ -0,0 +1,197 @@ +""" +Quantum Logic Gates which are implemented mathematically +and can be used as functions to build complex calculations +and implement different operations. The input taken is a real value +and imaginary value of the number and the result is output after computation. + +References : +https://en.wikipedia.org/wiki/Quantum_logic_gate + +Book : Mathematics Of Quantum Computing An Introduction by Wolfgang Scherer + +Glossary ; +input_realvalue : the magnitude of the real part of the input complex number. +input_imaginaryvalue : the magnitude of the imaginary part of the input complex number. +In cases which require 2 inputs the input is named with a suffix of 1 and 2 +(Eg. input_realvalue_1) + +alpha : angle of rotation as represented by the block sphere. +iota : The exponential complex of alpha value. +nx_value : value of vector in X axis as represented by Hilbert space. +nx_value : value of vector in Y axis as represented by Hilbert space. +nx_value : value of vector in Z axis as represented by Hilbert space. + +* The nx,ny and nz values can also be considered as values of vectors along +the respective axes on the bloch sphere. + +Usage : +>>>paulix_gate(2,3) +[3 2] + +>>>pauliy_gate(5,8) +[0.+8.j 0.-5.j] + +>>>pauliz_gate(4,1) +[ 4 -1] + +>>>identity_gate(7,2) +9 + +>>>phasefactor_of_input(4,7,45) +[1.39737084e+20+0.j 2.44539897e+20+0.j] + +>>>phaseshift_of_input(3,9,30) +[3.00000000e+00+0.j 9.61782712e+13+0.j] + +>>>hadamard_gate(5,9) +[ 9.89949494 -2.82842712] +[1.+0.j 0.+0.j 0.+0.j 7.+0.j] + +>>>controlled_not_gate_in_0ket(1,7,4,8) +[7 1 4 8] + +>>>controlled_not_gate(6,3,7,5) +[6 3 5 7] + +>>>inverted_controlled_not_gate(8,4,9,6) +[8 6 9 4] + +>>>controlled_phase_multiplication(3,2,5,1,10) +[3.00000000e+00+0.j 2.00000000e+00+0.j 1.10132329e+05+0.j + 2.20264658e+04+0.j] + +>>>swap_gate(5,1,3,7) +[5 3 1 7] + +>>>spin_of_input(6,3,45,1,8,3) +[-16.93201614+10.23066476j -50.61991392 -1.46152354j] + +""" + +import cmath +import math + +import numpy as np + + +def paulix_gate(input_realvalue,input_imaginaryvalue): + paulix_matrix = np.array([[0,1],[1,0]]) + complex_input = np.array([input_realvalue,input_imaginaryvalue]) + result = np.dot(paulix_matrix, complex_input) + return(result) + +def pauliy_gate(input_realvalue,input_imaginaryvalue): + i = complex(0,1) + pauliy_matrix = [[0,i],[-1*i,0]] + complex_input = np.array([input_realvalue,input_imaginaryvalue]) + result = np.dot(pauliy_matrix, complex_input) + return(result) + +def pauliz_gate(input_realvalue,input_imaginaryvalue): + pauliz_matrix = np.array([[1,0],[0,-1]]) + complex_input = np.array([input_realvalue,input_imaginaryvalue]) + result = np.dot(pauliz_matrix, complex_input) + return(result) + +def identity_gate(input_realvalue,input_imaginaryvalue) : + identiy_matrix = np.diag([[1,0],[0,1]]) + complex_input = np.array([input_realvalue,input_imaginaryvalue]) + result = np.dot(identiy_matrix, complex_input) + return(result) + +def phasefactor_of_input(input_realvalue,input_imaginaryvalue,alpha): + iota = cmath.exp(alpha) + phasefactor = [[iota,0],[0,iota]] + complex_input = np.array([input_realvalue,input_imaginaryvalue]) + result = np.dot(phasefactor,complex_input) + return result + +def phaseshift_of_input(input_realvalue,input_imaginaryvalue,alpha): + iota = cmath.exp(alpha) + phase = [[1,0],[0,iota]] + complex_input = np.array([input_realvalue,input_imaginaryvalue]) + result = np.dot(phase,complex_input) + return result + +def hadamard_gate(input_realvalue,input_imaginaryvalue): + root_of_2 = 1.0 / math.sqrt(2) + hadamard_gate_matrix = np.array([[root_of_2, root_of_2], + [root_of_2, -1 * root_of_2]]) + complex_input = np.array([input_realvalue,input_imaginaryvalue]) + result = np.dot(hadamard_gate_matrix,complex_input) + return result + +def controlled_not_gate_in_0ket(input_realvalue_1,input_imaginaryvalue_1, + input_realvalue_2,input_imaginaryvalue_2): + controlled_not_gate_0ket_matrix = np.array([[0,1,0,0], + [1,0,0,0], + [0,0,1,0], + [0,0,0,1]]) + complex_input = np.array([input_realvalue_1,input_imaginaryvalue_1, + input_realvalue_2,input_imaginaryvalue_2]) + print(complex_input) + result = np.dot(controlled_not_gate_0ket_matrix,complex_input) + return result + +def controlled_not_gate(input_realvalue_1,input_imaginaryvalue_1, + input_realvalue_2,input_imaginaryvalue_2): + controlled_not_gate_matrix = np.array([[1,0,0,0], + [0,1,0,0], + [0,0,0,1], + [0,0,1,0]]) + complex_input = np.array([input_realvalue_1,input_imaginaryvalue_1, + input_realvalue_2,input_imaginaryvalue_2]) + result = np.dot(controlled_not_gate_matrix,complex_input) + return result + +def inverted_controlled_not_gate(input_realvalue_1,input_imaginaryvalue_1, + input_realvalue_2,input_imaginaryvalue_2): + inverted_controlled_not_gate_matrix = np.array([[1,0,0,0], + [0,0,0,1], + [0,0,1,0], + [0,1,0,0]]) + complex_input = np.array([input_realvalue_1,input_imaginaryvalue_1, + input_realvalue_2,input_imaginaryvalue_2]) + result = np.dot(inverted_controlled_not_gate_matrix,complex_input) + return result + +def controlled_phase_multiplication(input_realvalue_1,input_imaginaryvalue_1, + input_realvalue_2,input_imaginaryvalue_2,alpha): + iota = cmath.exp(alpha) + controlled_phase_multiplication_matrix = np.array([[1,0,0,0], + [0,1,0,0], + [0,0,iota,0], + [0,0,0,iota]]) + complex_input = np.array([input_realvalue_1,input_imaginaryvalue_1, + input_realvalue_2,input_imaginaryvalue_2]) + result = np.dot(controlled_phase_multiplication_matrix,complex_input) + return result + +def swap_gate(input_realvalue_1,input_imaginaryvalue_1, + input_realvalue_2,input_imaginaryvalue_2): + swap_gate_matrix = np.array([[1,0,0,0], + [0,0,1,0], + [0,1,0,0], + [0,0,0,1]]) + complex_input = np.array([input_realvalue_1,input_imaginaryvalue_1, + input_realvalue_2,input_imaginaryvalue_2]) + result = np.dot(swap_gate_matrix,complex_input) + return result + +def spin_of_input(input_realvalue,input_imaginaryvalue, + alpha_value,nx_value,ny_value,nz_value): + i = complex(0,1) + spin_matrix = [[(math.cos(alpha_value/2.0)) - + (i * math.sin(alpha_value/2.0)*nz_value), + (-1 * i * math.sin(alpha_value/2.0)*(nx_value + i * ny_value))], + [-1 * i * (math.sin(alpha_value/2.0) * nx_value - i * ny_value), + math.cos(alpha_value/2.0) + + (i * math.sin(alpha_value/2.0) * nz_value)]] + complex_input = np.array([input_realvalue,input_imaginaryvalue]) + result = np.dot(spin_matrix,complex_input) + return result + +if __name__ == "__main__": + import doctest + + doctest.testmod()