""" 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()