mirror of
https://github.com/TheAlgorithms/Python.git
synced 2025-02-26 02:48:40 +00:00
198 lines
7.3 KiB
Python
198 lines
7.3 KiB
Python
"""
|
|
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()
|