def comparing_n_a_gate_v1_and_n_a_gate_with_ancilla(n_qbits): n = n_qbits controlled_n_a_gate = create_controlled_n_a_gate_v1(n) print('\nc_n_a_gate version 1\n', controlled_n_a_gate) # print(np.array(controlled_n_a_gate, dtype = float)) controlled_n_a_gate_with_ancilla = create_controlled_n_a_gate_with_ancilla( n + 1) print('\nc_n_a_gate with ancilla\n', controlled_n_a_gate_with_ancilla) # print(np.array(controlled_n_a_gate_with_ancilla, dtype = float)) psi = apply_tensor(qubit_one, qubit_one) psi = apply_tensor(psi, qubit_one) print('\npsi inicial') print_psi(psi) psi_temp = apply_gate_to_psi(controlled_n_a_gate, psi) print('\napply controlled_n_a_gate to psi') print_psi(psi_temp) psi_temp = apply_gate_to_psi(controlled_n_a_gate_with_ancilla, apply_tensor(psi, qubit_zero)) print('\napply controlled_n_a_gate_with_ancilla to psi') print_psi(psi_temp)
def create_controlled_n_a_gate_without_ancilla(n_qbits): """ Description: Make a non unitary O gate Required Params: n_qbits: Number of qbits that algorithm will computer Optional Params: None Return Value: A non unitary O gate Example: """ a_row = a**(1 / 2**(n_qbits - 2)) c_n_a_row_gate = np.identity(4, dtype=complex) c_n_a_row_gate[3][3] = a_row identity_tensor = apply_n_tensor_to(n_qbits - 2, i) identity_c_n_a_row_gate = apply_tensor(identity_tensor, c_n_a_row_gate) controlled_n_not_identity_tensor = apply_tensor( create_controlled_n_not(n_qbits - 2), i) controlled_n_a_gate_without_ancilla = apply_gate_to_psi( identity_c_n_a_row_gate, controlled_n_not_identity_tensor) c_n_1_a_row_gate = np.identity(4, dtype=complex) c_n_1_a_row_gate[3][3] = 1 / a_row identity_c_n_1_a_row_gate = apply_tensor(identity_tensor, c_n_1_a_row_gate) controlled_n_a_gate_without_ancilla = apply_gate_to_psi( identity_c_n_1_a_row_gate, controlled_n_a_gate_without_ancilla) controlled_n_a_gate_without_ancilla = apply_gate_to_psi( controlled_n_not_identity_tensor, controlled_n_a_gate_without_ancilla) matrix_size = 2**n_qbits c_n_a_row_2_gate = np.identity(matrix_size, dtype=complex) c_n_a_row_2_gate[matrix_size - 1][matrix_size - 1] = a_row c_n_a_row_2_gate[matrix_size - 3][matrix_size - 3] = a_row controlled_n_a_gate_without_ancilla = apply_gate_to_psi( c_n_a_row_2_gate, controlled_n_a_gate_without_ancilla) # Returning controlled_n_a_gate_with_ancilla return controlled_n_a_gate_without_ancilla
def testing_controlled_n_a_gate_v1(n_qbits): n = n_qbits controlled_n_a_gate = create_controlled_n_a_gate_v1(n) print('\nc_n_a_gate version 1\n', controlled_n_a_gate) # print(np.array(controlled_n_a_gate, dtype = float)) psi = apply_tensor(qubit_one, qubit_one) psi = apply_tensor(psi, qubit_one) print('\npsi inicial') print_psi(psi) psi = apply_gate_to_psi(controlled_n_a_gate, psi) print('\napplying controlled_n_a_gate to psi') print_psi(psi)
def create_d_gate(n_qbits): c_n_a_gate = create_controlled_n_a_gate_v1(n_qbits) # print('\nc_n_a_gate') # print(np.array(c_n_a_gate, dtype = float)) x_tensor = apply_n_tensor_to(n_qbits, x) # print('\nx_tensor') # print(np.array(x_tensor, dtype = float)) i_x_tensor = apply_tensor(apply_n_tensor_to(n_qbits - 1, i), x) # print('\ni_x_tensor') # print(np.array(i_x_tensor, dtype = float)) d_gate = x_tensor d_gate = apply_gate_to_psi(c_n_a_gate, d_gate) d_gate = apply_gate_to_psi(i_x_tensor, d_gate) d_gate = apply_gate_to_psi(c_n_a_gate, d_gate) d_gate = apply_gate_to_psi(x_tensor, d_gate) d_gate = apply_gate_to_psi(c_n_a_gate, d_gate) d_gate = apply_gate_to_psi(i_x_tensor, d_gate) d_gate = apply_gate_to_psi(c_n_a_gate, d_gate) return d_gate
def testing_controlled_n_a_gate_with_ancilla(n_qbits): n = n_qbits controlled_n_a_gate_with_ancilla = create_controlled_n_a_gate_with_ancilla( n + 1) print('\ncontrolled_n_a_gate_with_ancilla\n', controlled_n_a_gate_with_ancilla) # print(np.array(controlled_n_a_gate, dtype = float)) psi = apply_tensor(qubit_one, qubit_one) psi = apply_tensor(psi, qubit_one) print('\npsi inicial') print_psi(psi) psi = apply_gate_to_psi(controlled_n_a_gate_with_ancilla, apply_tensor(psi, qubit_zero)) print('\napplying controlled_n_a_gate_with_ancilla to psi') print_psi(psi)
def create_n_a_gate_v2(): matrix_size = 4 c_n_u_gate = np.identity(matrix_size, dtype=complex) c_n_u_gate[matrix_size - 1][matrix_size - 1] = -1 * a c_n_u_gate[matrix_size - 2][matrix_size - 2] = a c_n_u_gate[matrix_size - 1][matrix_size - 2] = sqrt(1 - (a**2)) c_n_u_gate[matrix_size - 2][matrix_size - 1] = sqrt(1 - (a**2)) n_zero = np.zeros((2, 2), dtype=complex) n_zero[0][0] = 1 i_n_zero_tensor = apply_tensor(np.identity(2, dtype=complex), n_zero) n_a_gate_v2 = apply_gate_to_psi(c_n_u_gate, i_n_zero_tensor) return n_a_gate_v2
def create_controlled_n_a_gate_with_ancilla(n_qbits): """ Description: Make a non unitary O gate Required Params: n_qbits: Number of qbits that algorithm will computer Optional Params: None Return Value: A non unitary O gate Example: """ matrix_size = 2**n_qbits # Creating matrix identity c_n_not_gate = np.identity(matrix_size, dtype=complex) c_n_not_gate[matrix_size - 1][matrix_size - 1] = 0 c_n_not_gate[matrix_size - 2][matrix_size - 2] = 0 c_n_not_gate[matrix_size - 1][matrix_size - 2] = 1 c_n_not_gate[matrix_size - 2][matrix_size - 1] = 1 identity_tensor = np.identity(int(matrix_size / 2), dtype=complex) n_a_gate = create_n_a_gate() identity_n_a_tensor = apply_tensor(identity_tensor, n_a_gate) controlled_n_a_gate_with_ancilla = apply_gate_to_psi( identity_n_a_tensor, c_n_not_gate) controlled_n_a_gate_with_ancilla = apply_gate_to_psi( c_n_not_gate, controlled_n_a_gate_with_ancilla) # Returning controlled_n_a_gate_with_ancilla return controlled_n_a_gate_with_ancilla
# Item to search: |111....11> item_to_search = apply_n_tensor_to(n + 1, qubit_one) ############################################################ ####### Circuit Gates ###################################### ############################################################ item_to_search_projector = np.dot(item_to_search, np.transpose(item_to_search)) print("\nitem_to_search_projector") print(item_to_search_projector) # Creating Identity"s tensors to works qubits tensor_i = np.identity(2**n, dtype=complex) # Creating oracle oracle = apply_tensor(tensor_i, i) print("\noraculo") print(oracle) oracle = oracle - (2 * item_to_search_projector) print("\noraculo") print(oracle) # Creating controled_u_1 controlled_u_1 = apply_tensor(tensor_i, z) # controlled_u_1 = (2 * item_to_search_projector) + controlled_u_1 print("\ncontrolled_u_1") print(controlled_u_1) # Creating Hadamard"s tensors, works and auxiliary qubis
print("\nv operator") print(v) # Creating Hadamard"s tensors, works tensor_h = apply_n_tensor_to(n, h) print("\ntensor_h") print(tensor_h.real) # Creating controled_u_0 # On the article is: # u_s = 2 * items_to_search_projector - I # controlled_u_0 = 2 * items_to_search_projector - tensor_i controlled_u_0 = apply_tensor(tensor_i, i) matrix_size = len(controlled_u_0) for index in range(matrix_size - 2, matrix_size - 2 - (2 * m), -2): controlled_u_0[index + 1][index + 1] = -1 print("\ncontrolled_u_0") print(controlled_u_0.real) # Creating controled_u_1 - invert all sings controlled_u_1 = apply_tensor(tensor_i, z) controlled_u_1 = np.dot(controlled_u_0, controlled_u_1) print("\ncontrolled_u_1")
controlled_0_Us = create_controlled_u_gate(u_s, 0) print("\ncontrolled_0_Us") print(controlled_0_Us.real) # Creating controlled_1_negative_identity (controlled_1_u_1) # On the article, in equation 15, this gate # invert all coefficients of the down sub wave # controlled_1_negative_identity = apply_tensor(tensor_i, z) controlled_1_negative_identity = create_controlled_u_gate(-1 * tensor_i, 1) print("\ncontrolled_1_negative_identity") print(controlled_1_negative_identity.real) # Creating projection_operator zero_projection_operator = np.dot(qubit_zero, np.transpose(qubit_zero)) projection_operator = apply_tensor(tensor_i, zero_projection_operator) print("\nprojection_operator") print(projection_operator.real) ############################################################ ####### Circuit Execution ################################## ############################################################ # psi_0 - Creating tensor product between inputs: |000000> psi = apply_n_tensor_to(n + 1, qubit_zero) print("\npsi_0 - Creating tensor product between inputs: |000000>\n") print_psi(psi) # psi_1 - Applying tensor_h to psi_0 on work qubits psi = apply_gate_to_psi(apply_tensor(tensor_h, i), psi) print("\npsi_1 - Applying tensor_h to psi_0 on work qubits\n") print_psi(psi)
if __name__ == '__main__': # Number of qbits that algorithm will computer n = 6 # Creating Hadamard's tensors tensor_h = apply_n_tensor_to(n, h) # Creating Fredkin's tensors tensor_f = apply_n_tensor_to(int(n / 3), f) # Creating Indentity's tensors tensor_i = apply_n_tensor_to(n - 1, i) # Creating O operator tensor_o_i = apply_tensor(create_o_gate(n), tensor_i) # psi_0 - Creating tensor product between inputs: |000000> psi = apply_n_tensor_to(n, qubit_zero) print('\npsi_0 - Creating tensor product between inputs: |000000>') print_psi(psi) # psi_1 - Applying tensor_h to psi_0 psi = apply_gate_to_psi(tensor_h, psi) print('\npsi_1 - Applying tensor_h to psi_0') print_psi(psi) # psi_2 - Applying tensor_f to psi_1 psi = apply_gate_to_psi(tensor_f, psi) print('\npsi_2 - Applying tensor_f to psi_2') print_psi(psi)
""" <<< MAIN >>> """ if __name__ == '__main__': # Number of qbits that algorithm will computer n = 2 # Creating Hadamard's tensors tensor_h = apply_n_tensor_to(n, h) # Creating Identity's tensors tensor_i = apply_n_tensor_to(n, i) # Creating tensor product between: # Hadamard's tensors and Identity's tensors tensor_h_i = apply_tensor(tensor_h, tensor_i) # Creating Uf gate matrix uf = create_uf_gate(n) # psi_0 - Creating tensor product between inputs: X1 = |0> and X2 = |0> psi = apply_n_tensor_to(2 * n, qubit_zero) # psi_1 - Applying tensor_h_i to psi_0 psi = apply_gate_to_psi(tensor_h_i, psi) # psi_2 - Applying Uf to psi_1 psi = apply_gate_to_psi(uf, psi) # psi_3 - Applying tensor_h_i to psi_2 psi = apply_gate_to_psi(tensor_h_i, psi)