Added quantum logic gates

.vscode/settings.json

@@ -1,5 +1,9 @@
 {
     "githubPullRequests.ignoredPullRequestBranches": [
         "master"
-    ]
+    ],
+    "[python]": {
+        "editor.defaultFormatter": "ms-python.black-formatter"
+    },
+    "python.formatting.provider": "none"
 }

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