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)
