def Probabilistic_system(mat, click, state):
def mul_mat_bool(A, B):
m_a = len(A)
n_a = len(A[0])
m_b = len(B)
n_b = len(B[0])
if n_a == m_b:
ans = [[False for i in range(len(B[0]))] for i in range(len(A))]
for i in range(len(A)):
for j in range(len(B[0])):
for k in range(len(A[0])):
ans[i][j] = ans[i][j] or (A[i][k] and B[k][j])
return ans
start = mat
if type(mat[0][0]) == bool:
for i in range(click):
state_click = mul_mat_bool(start, mat_op.transpuesta(state))
start = mul_mat_bool(start, mat)
ans = state_click[:]
for i in range(len(ans)):
if ans[i][0] == True:
ans[i] = 1
else:
ans[i] = 0
Plot(len(ans), ans)
else:
for i in range(click):
state_click = mul_mat_real(start, mat_op.transpuesta(state))
start = mul_mat_real(start, mat)
Plot(len(mat_op.transpuesta(state_click)),
mat_op.transpuesta(state_click))
return state_click
def Quantum_system(mat, click, state):
start = mat
for i in range(click):
state_click = mat_op.mult_mat(start, mat_op.transpuesta(state))
start = mat_op.mult_mat(start, mat)
state_click = [[round((state_click[i][0].mod())**2, 2)]
for i in range(len(state_click))]
Plot(len(state_click), mat_op.transpuesta(state_click))
return state_click
def test_transpuesta(self):
self.assertEqual(mat_op.transpuesta(self.mat_num_A),
[[1, 1, 1], [2, 2, 2]])
self.assertEqual(
str(mat_op.transpuesta(self.mat_comp_a)),
'[[1 + 2i, 1 + 2i, 1 + 2i], [1 + 2i, 1 + 2i, 1 + 2i]]')
self.assertEqual(mat_op.transpuesta(self.vect_num_D),
[[1], [2], [3], [4]])
self.assertEqual(str(mat_op.transpuesta(self.vect_comp_d)),
'[[1 + 1i], [2 + 2i], [3 + 3i], [4 + 4i]]')
def exp_complex_slit(mat):
A = mat
V = [complex_cart(0, 0) for i in range(len(mat))]
V[0] = complex_cart(1, 0)
V = mat_op.transpuesta(V)
for i in range(2):
C = mat_op.mult_mat(A, V)
A = mat_op.mult_mat(A, mat)
B = mat_op.transpuesta(C[:])
for i in range(len(B)):
B[i] = round(B[i].mod()**2, 2)
Plot(len(B), B)
return mat_op.transpuesta(B)
def Quantum_states(x, ket, ket_a):
ket = mat_op.transpuesta(ket)
if ket_a is None:
ans = []
for i in range(len(ket)):
prob = (round((ket[i].mod()**2), 2)) / (round(
(mat_op.norma_vect(ket)**2), 2))
ans += [prob]
return ans[x]
else:
ket_a = mat_op.transpuesta(ket_a)
ans = mat_op.product_in(ket_a, ket)
norma_ket = mat_op.norma_vect(ket)
norma_ket_a = mat_op.norma_vect(ket_a)
b = norma_ket * norma_ket_a
return complex_cart(ans.a / b, ans.b / b)
def test_mult_mat(self):
self.assertEqual(
str(mat_op.mult_mat(self.mat_comp_b, self.mat_comp_a)),
'[[-6 + 18i, -6 + 18i], [-6 + 18i, -6 + 18i], [-6 + 18i, -6 + 18i]]'
)
self.assertEqual(
str(
mat_op.mult_mat(self.mat_comp_b,
mat_op.transpuesta(self.mat_comp_b))),
'[[0 + 28i, 0 + 28i, 0 + 28i], [0 + 28i, 0 + 28i, 0 + 28i], [0 + 28i, 0 + 28i, 0 + 28i]]'
)
self.assertEqual(
str(
mat_op.mult_mat(self.mat_comp_a,
mat_op.transpuesta(self.mat_comp_a))),
'[[-6 + 8i, -6 + 8i, -6 + 8i], [-6 + 8i, -6 + 8i, -6 + 8i], [-6 + 8i, -6 + 8i, -6 + 8i]]'
)
def Observables(observable, ket):
if mat_op.hermitian(observable):
ans = mat_op.mult_mat(observable, ket)
media = mat_op.product_in(mat_op.transpuesta(ans),
mat_op.transpuesta(ket))
identy = mat_op.mult_esc_mat(media, Identy(len(observable)))
operador = mat_op.sum_mat_com(observable, mat_op.inv_adit_mat(identy))
operador_1 = mat_op.mult_mat(operador, operador)
ket_operador = mat_op.transpuesta(mat_op.mult_mat(operador_1, ket))
var = mat_op.product_in(mat_op.transpuesta(ket), ket_operador)
return var.a
else:
return None
def exp_real_slit(slits, targets):
n = ((slits - 1) * math.ceil(targets / 2)) + 1 + slits + targets
state = [[0 for i in range(n)] for j in range(n)]
for i in range(slits):
state[i + 1][0] = 1 / slits
for j in range(i * (math.ceil(targets / 2)) + slits + 1,
i * (math.ceil(targets / 2)) + slits + targets + 1):
state[j][i + 1] += 1 / targets
state[j][j] = 1
state_2 = mul_mat_real(state, state)
V = [0 for i in range(n)]
V[0] = 1
V = mat_op.transpuesta(V)
prob = mul_mat_real(state_2, V)
B = mat_op.transpuesta(prob)
Plot(n, B)
return prob
def Assembling(particles):
'4.5.2'
ans = mat_op.product_tensor(particles[0][0], particles[1][0])
for i in range(2, len(particles)):
ans = mat_op.product_tensor(ans, particles[i][0])
x = 0
for i in range(len(particles)):
ans_1 = 1
for j in range(i):
ans_1 *= len(particles[j][0])
x += particles[i][1] * ans_1
return Quantum_states(x, mat_op.transpuesta(ans), None)
def Measuring(observable, ket):
observable = [[
complex(observable[i][j].a, observable[i][j].b)
for j in range(len(observable[i]))
] for i in range(len(observable))]
A = np.array(observable)
eigenvalues, eigenvects = np.linalg.eig(A)
c = []
b = []
for i in range(len(eigenvects)):
d = []
b += [complex_cart(eigenvalues[i].real, eigenvalues[i].imag)]
for j in range(len(eigenvects[i])):
z = eigenvects[i][j]
d += [complex_cart(z.real, z.imag)]
c += [d]
if ket is None:
return (b, c)
else:
prob = []
for i in range(len(b)):
prob += [(mat_op.product_in(mat_op.transpuesta(ket),
c[i])).mod()**2]
return (b, c, prob)
def Problem(x):
if x == '4.3.1':
observable = [[complex_cart(0, 0),
complex_cart(1, 0)],
[complex_cart(1, 0),
complex_cart(0, 0)]]
ket = [[complex_cart(1, 0)], [complex_cart(0, 0)]]
ans = Measuring(observable, ket)
return ans[1]
elif x == '4.3.2':
observable = [[complex_cart(0, 0),
complex_cart(1, 0)],
[complex_cart(1, 0),
complex_cart(0, 0)]]
ket = [[complex_cart(1, 0)], [complex_cart(0, 0)]]
ans = Measuring(observable, ket)
value = ans[0][0] * complex_cart(
ans[2][0], 0) + ans[0][1] * complex_cart(ans[2][1], 0)
print(value)
ans_1 = mat_op.mult_mat(observable, ket)
media = mat_op.product_in(mat_op.transpuesta(ans_1),
mat_op.transpuesta(ket))
print(media)
print(
'El valor de la distribucion hallado es igual al que se obtiene en el calculo de la media'
)
return (media)
elif x == '4.4.1':
U_1 = [[complex_cart(0, 0), complex_cart(1, 0)],
[complex_cart(1, 0), complex_cart(0, 0)]]
U_2 = [[
complex_cart(math.sqrt(2 / 4), 0),
complex_cart(math.sqrt(2 / 4), 0)
],
[
complex_cart(math.sqrt(2 / 4), 0),
complex_cart(-math.sqrt(2 / 4), 0)
]]
print(mat_op.unitary(U_1, ), mat_op.unitary(U_2))
print('Las dos matrices son unitarias')
U_3 = mat_op.mult_mat(U_1, U_2)
print(mat_op.unitary(U_3))
print('El producto de las matrices es unitario')
return [mat_op.unitary(U_3)]
elif x == '4.4.2':
U_n = [[
complex_cart(0, 0),
complex_cart(1 / math.sqrt(2), 0),
complex_cart(1 / math.sqrt(2), 0),
complex_cart(0, 0)
],
[
complex_cart(0, 1 / math.sqrt(2)),
complex_cart(0, 0),
complex_cart(0, 0),
complex_cart(1 / math.sqrt(2), 0)
],
[
complex_cart(1 / math.sqrt(2), 0),
complex_cart(0, 0),
complex_cart(0, 0),
complex_cart(0, 1 / math.sqrt(2))
],
[
complex_cart(0, 0),
complex_cart(1 / math.sqrt(2), 0),
complex_cart(-1 / math.sqrt(2), 0),
complex_cart(0, 0)
]]
state = state = mat_op.transpuesta([
complex_cart(1, 0),
complex_cart(0, 0),
complex_cart(0, 0),
complex_cart(0, 0)
])
ans = Dynamics(3, U_n, state)
return ans[3]
elif x == '4.5.2':
return 'hola'
else:
return 'EL ejercicio no fue propuesto'
