def test_Transformation8():
"Check Qobj eigs and direct eig solver reverse transformations match"
N = 10
H = rand_herm(N)
# generate a random basis
rand = rand_dm(N, density=1)
evals, rand_basis = rand.eigenstates()
evals2, rand_basis2 = sp_eigs(rand.data, isherm=1)
H1 = H.transform(rand_basis, True)
H2 = H.transform(rand_basis2, True)
assert_((H1 - H2).norm() < 1e-6)
ket = rand_ket(N)
K1 = ket.transform(rand_basis,1)
K2 = ket.transform(rand_basis2,1)
assert_((K1 - K2).norm() < 1e-6)
bra = rand_ket(N).dag()
B1 = bra.transform(rand_basis,1)
B2 = bra.transform(rand_basis2,1)
assert_((B1 - B2).norm() < 1e-6)
def testRandketSeed(self):
"random ket with seed"
seed = 12345
U0 = rand_ket(5, seed=seed)
U1 = rand_ket(5, seed=None)
U2 = rand_ket(5, seed=seed)
assert_(U0 != U1)
assert_(U0 == U2)
def testFloquetUnitary(self):
"""
Floquet: test unitary evolution of time-dependent two-level system
"""
delta = 1.0 * 2 * np.pi
eps0 = 1.0 * 2 * np.pi
A = 0.5 * 2 * np.pi
omega = np.sqrt(delta ** 2 + eps0 ** 2)
T = (2 * np.pi) / omega
tlist = np.linspace(0.0, 2 * T, 101)
psi0 = rand_ket(2)
H0 = - eps0 / 2.0 * sigmaz() - delta / 2.0 * sigmax()
H1 = A / 2.0 * sigmax()
args = {'w': omega}
H = [H0, [H1, lambda t, args: np.sin(args['w'] * t)]]
e_ops = [num(2)]
# solve schrodinger equation with floquet solver
sol = fsesolve(H, psi0, tlist, e_ops, T, args)
# compare with results from standard schrodinger equation
sol_ref = mesolve(H, psi0, tlist, [], e_ops, args)
assert_(max(abs(sol.expect[0] - sol_ref.expect[0])) < 1e-4)
def test_EntropyLinear():
"Linear entropy"
# test_ entropy_vn = 0 for pure state
psi = rand_ket(10)
assert_equal(abs(entropy_linear(psi)) <= 1e-13, True)
# test_ linear entropy always less than or equal to VN entropy
rhos = [rand_dm(6) for k in range(10)]
for k in rhos:
assert_equal(entropy_linear(k) <= entropy_vn(k), True)
def test_Transformation5():
"Consistency between transformations of kets and density matrices"
N = 4
psi0 = rand_ket(N)
# generate a random basis
evals, rand_basis = rand_dm(N, density=1).eigenstates()
rho1 = ket2dm(psi0).transform(rand_basis, True)
rho2 = ket2dm(psi0.transform(rand_basis, True))
assert_((rho1 - rho2).norm() < 1e-6)
def test_EntropyVN():
"von-Neumann entropy"
# verify that entropy_vn gives correct binary entropy
a = np.linspace(0, 1, 20)
for k in range(len(a)):
# a*|0><0|
x = a[k] * ket2dm(basis(2, 0))
# (1-a)*|1><1|
y = (1 - a[k]) * ket2dm(basis(2, 1))
rho = x + y
# Von-Neumann entropy (base 2) of rho
out = entropy_vn(rho, 2)
if k == 0 or k == 19:
assert_equal(out, -0.0)
else:
assert_(abs(-out - a[k] * np.log2(a[k])
- (1. - a[k]) * np.log2((1. - a[k]))) < 1e-12)
# test_ entropy_vn = 0 for pure state
psi = rand_ket(10)
assert_equal(abs(entropy_vn(psi)) <= 1e-13, True)
def random_state(self):
self.state = qt.rand_ket(self.n())
self.refresh()
return self.state
return [qutip.expect(spin_ops["X"], state),\
qutip.expect(spin_ops["Y"], state),\
qutip.expect(spin_ops["Z"], state)]
##################################################################################################################
vpython.scene.width = 500
vpython.scene.height = 500
n_qubits = 2
dt = 0.001
n_points = 50
state = qutip.rand_ket(2**n_qubits)
energy = qutip.rand_herm(2**n_qubits)
unitary = qutip.Qobj(scipy.linalg.expm(-2 * math.pi * im * energy.full() * dt))
qubits = None
qubit_colors = [
vpython.vector(random.random(), random.random(), random.random())
for i in range(n_qubits)
]
vsphere = vpython.sphere(pos=vpython.vector(0,0,0),\
radius=1.0,\
color=vpython.color.blue,\
opacity=0.4)
vspin = vpython.arrow(shaftwidth=0.01, headwidth=0.001, headlength=0.001)
vstars = [vpython.sphere(radius=0.05,\
color=vpython.color.white,\
opacity=0.8,\
tau=1e-8,
progress_bar=True)
return np.max([qt.fidelity(target, s) for s in states])
def random_purity_benchmark(state, **kwargs):
target = root_iSWAP * state.ptrace([1, 2])
sim = Simulation(do_qt_mesolve, state=state, fname='time_dependent.yaml')
states = sim.run_solver(nsteps=2000, steps=10000, tau=1e-7, rhs_reuse=True)
print('Done a state')
return qt.fidelity(target, states[-1].ptrace([1, 2]))
if __name__ == '__main__':
n = thermal_state(5e9, 20e-3, 5)
state = qt.tensor(n, qt.rand_ket(2), qt.rand_ket(2))
sim = Simulation(do_qt_mesolve, state=state, fname='time_dependent.yaml')
ls = get_lind_list(sim.w_c, 1e4, 20e-3, 1, 1e2, sim.dims)
sim.lindblads = ls
res = sim.run_solver(nsteps=1000, steps=10000, tau=1e-7, progress_bar=True)
# bvs, ns = sim.parse_states(res)
b = qt.Bloch()
for i in range(10000):
b.clear()
b.add_states(res[i].ptrace(1))
b.add_states(res[i].ptrace(2))
b.render()
b.save(dirc='temp')
# plt.hist(ns, 50)
# plt.show()
# targets = [[qt.tensor(qt.rand_ket(2), qt.rand_ket(2))] for i in range(100)]
if np.allclose(eigs[i], complex(1)):
stab_states.append(qt.Qobj(vecs[:,i], dims=[[2],[1]]))
basis = [np.matrix('1;0;0;0'), np.matrix('0;1;0;0'),
np.matrix('0;0;1;0'), np.matrix('0;0;0;1')]
A = np.matrix(np.zeros((4, 60), dtype=np.complex_))
for i in range(4):
for j, state in enumerate(stab_states):
A[i, j] = np.sum(basis[i].H * np.matrix(state.full()))
b = np.matrix(np.zeros((4,1), dtype=np.complex_))
norm_0 = np.zeros(500)
truthy = []
print("Benchmarking 500 random states")
for i in range(500):
state = qt.rand_ket(4, dims=[[2,2],[1,1]])
for j in range(4):
b[j] = np.sum(basis[j].H*np.matrix(state.full()))
norm_0[i] = np.count_nonzero(SL0(A,b, 1e-12))
print("Average L0 norm is " + str(np.mean(norm_0)))
norm_0 = np.zeros(len(magic_states))
for i, state in enumerate(magic_states):
for j in range(4):
b[j] = np.sum(basis[j].H*qt.tensor([state,state]).full())
norm_0[i] = np.count_nonzero(SL0(A,b,1e-12))
print("Norm for edge type states is "+str(np.mean(norm_0)))
norm_0 = np.zeros(len(face_states))
for i, state in enumerate(face_states):
for j in range(4):
b[j] = np.sum(basis[j].H*qt.tensor([state,state]).full())
norm_0[i] = np.count_nonzero(SL0(A,b,1e-12))
import operator
import numpy as np
import sympy
import mpmath
import scipy
import qutip
import vpython
import random
def im():
return complex(0, 1)
vpython.scene.height = 600
vpython.scene.width = 800
alice = qutip.rand_ket(2)
bob = qutip.rand_ket(2)
alice_center = vpython.vector(-1,0,0)
valice = vpython.sphere(pos=alice_center,\
radius=1.0,\
color=vpython.color.blue,\
opacity=0.3)
valice_star = vpython.sphere(radius=0.1,\
color=vpython.color.white,\
opacity=0.7, emissive=True)
valice_arrow = vpython.arrow(color=vpython.color.blue,\
shaftwidth=0.06)
bob_center = vpython.vector(1,0,0)
vbob = vpython.sphere(pos=bob_center,\
#F = fp.Fidelity(Ham,G,N,dCS)
#print("The initial Fidelity is: "+str(F))
# Opitimization parameters
delta = 0.001 # : for the derivative
check = 0 # : to check convergence
s = 0 # : intermediate value of the optimization
time = step # : time steps
startTime = datetime.now() # : to check running time
while True :
time += step
rho_0 = qt.rand_ket(N = 8, dims = [[2,2,2], [1,1,1]]) # Initial random state of the system
index = randrange(len(J)) # pick the derivative direction: We do not compute the gradient.
# Rather, each step, we compute
# the derivative with respect to a random direction
JdJ = [x for x in J]
JdJ[index] += delta
HJ = H(J,N) # We compute the Hamiltonian for J
HJdJ = H(JdJ,N) #and for a little perturbation of J: JdJ
grad = (fp.Likelihood3(JdJ, rho_0,G,dCS,HJdJ) - fp.Likelihood3(J, rho_0,G,dCS,HJ))/delta # The gradient of the Likelihood
J[index] = J[index] + grad/sqrt(time) # Updating step
# One could drop the following 4 lines if not interested in the optimization behaviour
HJ = H(J,N)
def testRandket(self):
"random ket"
P = [rand_ket(5) for k in range(5)]
for p in P:
assert_equal(p.type == 'ket', True)
def keyboard(event):
global clock_probs, TIME_projs, state, Z_projs, ZV, ZL, HL, H_projs, SHIFT, display_proj, pointing_to, clock_n, evolving, initial
key = event.key
if key == "c":
choice = np.random.choice(list(range(clock_n)),
p=np.array(clock_probs) /
sum(np.array(clock_probs)))
state = (qt.tensor(qt.identity(spin_n), TIME_projs[choice]) *
state).unit()
print("clock time: %.4f" % (choice))
elif key == "v":
probs = np.array([(state * state.dag() * proj).tr()
for proj in Z_projs]).real
choice = np.random.choice(list(range(len(ZV))), p=probs / sum(probs))
state = (Z_projs[choice] * state).unit()
print("spin Z eigenvalue: %.4f" % (ZL[choice]))
elif key == "b":
probs = np.array([(state * state.dag() * proj).tr()
for proj in H_projs]).real
choice = np.random.choice(list(range(len(H_projs))),
p=probs / sum(probs))
state = (H_projs[choice] * state).unit()
print("energy eigenvalue: %.4f" % (HL[choice]))
elif key == "9":
state = (SHIFT * state).unit()
elif key == "0":
state = (SHIFT.dag() * state).unit()
elif key == "r":
if display_proj == False:
display_proj = True
else:
display_proj = False
elif key == "e":
pointing_to -= 1
if pointing_to < 0:
pointing_to = clock_n - 1
elif key == "t":
pointing_to += 1
if pointing_to >= clock_n:
pointing_to = 0
elif key == "a":
state = qt.tensor(
(-1j * qt.sigmax() * 0.1).expm(), qt.identity(clock_n)) * state
elif key == "d":
state = qt.tensor(
(1j * qt.sigmax() * 0.1).expm(), qt.identity(clock_n)) * state
elif key == "s":
state = qt.tensor(
(-1j * qt.sigmay() * 0.1).expm(), qt.identity(clock_n)) * state
elif key == "w":
state = qt.tensor(
(1j * qt.sigmay() * 0.1).expm(), qt.identity(clock_n)) * state
elif key == "z":
state = qt.tensor(
(-1j * qt.sigmaz() * 0.1).expm(), qt.identity(clock_n)) * state
elif key == "x":
state = qt.tensor(
(1j * qt.sigmaz() * 0.1).expm(), qt.identity(clock_n)) * state
elif key == "q":
if evolving == True:
evolving = False
else:
evolving = True
elif key == "p":
state = initial
elif key == "o":
state_ = qt.rand_ket(state.shape[0])
state_.dims = state.dims
state = state_
elif key == "h":
display_help()
def test_known_cases_pure_states(self, dimension):
left = rand_ket(dimension)
right = rand_ket(dimension)
expected = np.sqrt(2 * (1 - np.abs(left.overlap(right))**2))
assert hellinger_dist(left, right) == pytest.approx(expected, abs=1e-7)
def rand_su2n_state(n):
return su2n_state([qt.rand_ket(2) for i in range(n)])
def qubit_xyz(spin):
return [qt.expect(qt.sigmax(), spin),\
qt.expect(qt.sigmay(), spin),\
qt.expect(qt.sigmaz(), spin)]
################################################################################
spin_n = 2
clock_n = 7
################################################################################
spin_initial = qt.rand_ket(spin_n)
spin_H = qt.rand_herm(spin_n)
dt = (2 * np.pi) / clock_n
spin_U = (-1j * spin_H * dt).expm()
psi_t = lambda t: (-1j * spin_H * t).expm() * spin_initial
spin_history = [psi_t(t * dt) for t in range(clock_n)]
################################################################################
H = sum([-qt.tensor(spin_U, qt.basis(clock_n, t+1)*qt.basis(clock_n, t).dag())\
-qt.tensor(spin_U.dag(), qt.basis(clock_n, t)*qt.basis(clock_n, t+1).dag())\
+qt.tensor(qt.identity(spin_n), qt.basis(clock_n, t)*qt.basis(clock_n, t).dag())\
+qt.tensor(qt.identity(spin_n), qt.basis(clock_n, t+1)*qt.basis(clock_n, t+1).dag())\
+qt.tensor(qt.identity(spin_n) - spin_initial*spin_initial.dag(), qt.basis(clock_n, 0)*qt.basis(clock_n,0).dag())\
for t in range(clock_n-1)])
HL, HV = H.eigenstates()
for o in ["X", "Y", "Z"]])))
for i in range(len(E)):
print("%s : %s" % (annotations[i], e[i]))
#######################################################################################
inverted = True
show_originals = True
n = 4
#pts = [3*np.random.randn(3) for i in range(n)]
pts = [np.array([0, 0, 4 * i - n / 2]) for i in range(n)]
views = make_views(pts)
spinors = [qt.rand_ket(2) for i in range(n)]
state = su2n_state(spinors)
S, E, annotations = su2(n)
P = constellations_matrix(views_constellations(views))
phases = su2n_phases(state)
initial_state = P * state if inverted else P.dag() * state
##################################################################
vp.scene = vp.canvas(background=vp.color.white, width=1000, height=800)
vcolors = [vp.vector(*np.random.rand(3)) for i in range(n)]
pieces = split_su2n_state(state)
if show_originals:
vspheres_ = [vp.sphere(color=vcolors[i], radius=pieces[i].norm(), opacity=0.05,\
res.append(np.count_nonzero(x))
print('SL0 done for target')
return res
FILE_NAME = datetime.datetime.now().strftime('%d%m%Y_%H%M%S')+".txt"
OUT_STRING_1 = "For the {0} state on {1} qubits,"
OUT_STRING_2 = "the SL0 estimate gives a sparsenes of {}"
OUT_STRING_3 = "the brute force search returns a sparseness of {}."
OUT_STRING_4 = "The resulting basis states found were:"
if __name__ == '__main__':
FILE_NAME = 'RandSparse.txt'
# ns = [1,2,3,4]
# strs = ['H', 'F']
# strs = ['Root T', 'Root Root T']
r = qt.rand_ket(2)
r2 = qt.rand_ket(4)
targets = [r, qt.tensor(r,r), r2, qt.tensor(r,r,r)]
ns = [1, 2, 2, 3]
strs = ['Random', '2fold product', '2 qubit random', '3 fold product']
for i, n in enumerate(ns):
# targets = [qt.tensor([H]*n), qt.tensor([F]*n)]
# targets = [qt.tensor([RT]*n), qt.tensor([RRT]*n)]
stabs = stab_states(n)
SL0s = SL0_estimate([targets[i]], stabs, n)
basis, val = brute_force_sparseness(targets[i], stabs)
with open(FILE_NAME, 'a') as f:
out = OUT_STRING_1.format(strs[i], n)+"\n"
out += OUT_STRING_2.format(SL0s[0])
out += OUT_STRING_3.format(val) + "\n"
out += "\n".join(str(b) for b in basis) +"\n"
if self.other != None:
other_according_to_self = self.other.state.transform(self.state)
self.local_other.state = other_according_to_self
xyz = state_xyz(other_according_to_self, self.other.n)
self.local_other.center = [self.vstars[II].pos.x-1*xyz[0], self.vstars[II].pos.y-1*xyz[1], self.vstars[II].pos.z-1*xyz[2]]
#self.local_other.center = [self.vsphere.pos.x+1*xyz[0], self.vsphere.pos.y+1*xyz[1], self.vsphere.pos.z+1*xyz[2]]
self.local_other.update()
def apply(self, operator, inverse=False, dt=0.01):
unitary = qutip.Qobj(scipy.linalg.expm(-2*math.pi*complex(0,1)*operator.full()*dt))
if inverse:
unitary = unitary.dag()
self.state = unitary*self.state*unitary.dag()
n = 2
A = Sphere(n, qutip.rand_ket(n).ptrace(0), [-1.5, 0, 0], vpython.color.red)
B = Sphere(n, qutip.rand_ket(n).ptrace(0), [1.5, 0, 0], vpython.color.blue)
A.set_other(B)
B.set_other(A)
energy = qutip.rand_herm(n)
energy_unitary = qutip.Qobj(scipy.linalg.expm(-2*math.pi*complex(0,1)*energy.full()*0.01))
def keyboard(event):
global A
global B
global n
key = event.key
operator = None
X, Y, Z = qutip.jmat((n-1.)/2.)
class TestHusimiQ:
@pytest.mark.parametrize('xs', ["", 1, None], ids=['str', 'int', 'none'])
def test_failure_if_non_arraylike_coordinates(self, xs):
state = qutip.rand_ket(4)
valid = np.linspace(-1, 1, 5)
with pytest.raises(TypeError) as e:
qutip.qfunc(state, xs, valid)
assert "must be array-like" in e.value.args[0]
with pytest.raises(TypeError) as e:
qutip.qfunc(state, valid, xs)
assert "must be array-like" in e.value.args[0]
with pytest.raises(TypeError) as e:
qutip.QFunc(xs, valid)
assert "must be array-like" in e.value.args[0]
with pytest.raises(TypeError) as e:
qutip.QFunc(valid, xs)
assert "must be array-like" in e.value.args[0]
@pytest.mark.parametrize('ndim', [2, 3])
def test_failure_if_coordinates_not_1d(self, ndim):
state = qutip.rand_ket(4)
valid = np.linspace(-1, 1, 5)
bad = valid.reshape((-1, ) + (1, ) * (ndim - 1))
with pytest.raises(ValueError) as e:
qutip.qfunc(state, bad, valid)
assert "must be 1D" in e.value.args[0]
with pytest.raises(ValueError) as e:
qutip.qfunc(state, valid, bad)
assert "must be 1D" in e.value.args[0]
with pytest.raises(ValueError) as e:
qutip.QFunc(bad, valid)
assert "must be 1D" in e.value.args[0]
with pytest.raises(ValueError) as e:
qutip.QFunc(valid, bad)
assert "must be 1D" in e.value.args[0]
@pytest.mark.parametrize('dm', [True, False], ids=['dm', 'ket'])
def test_failure_if_tensor_hilbert_space(self, dm):
if dm:
state = qutip.rand_dm(4, dims=[[2, 2], [2, 2]])
else:
state = qutip.rand_ket(4, dims=[[2, 2], [1, 1]])
xs = np.linspace(-1, 1, 5)
with pytest.raises(ValueError) as e:
qutip.qfunc(state, xs, xs)
assert "must not have tensor structure" in e.value.args[0]
with pytest.raises(ValueError) as e:
qutip.QFunc(xs, xs)(state)
assert "must not have tensor structure" in e.value.args[0]
def test_QFunc_raises_if_insufficient_memory(self):
xs = np.linspace(-1, 1, 11)
state = qutip.rand_ket(4)
qfunc = qutip.QFunc(xs, xs, memory=0)
with pytest.raises(MemoryError) as e:
qfunc(state)
assert e.value.args[0].startswith("Refusing to precompute")
def test_qfunc_warns_if_insufficient_memory(self):
xs = np.linspace(-1, 1, 11)
state = qutip.rand_dm(4)
with pytest.warns(UserWarning) as e:
qutip.qfunc(state, xs, xs, precompute_memory=0)
assert (e[0].message.args[0].startswith(
"Falling back to iterative algorithm"))
@pytest.mark.parametrize('obj', [
pytest.param(np.eye(2, dtype=np.complex128), id='ndarray'),
pytest.param([[1, 0], [0, 1]], id='list'),
pytest.param(1, id='int'),
])
def test_failure_if_not_a_Qobj(self, obj):
xs = np.linspace(-1, 1, 11)
with pytest.raises(TypeError) as e:
qutip.qfunc(obj, xs, xs)
assert e.value.args[0].startswith("state must be Qobj")
qfunc = qutip.QFunc(xs, xs)
with pytest.raises(TypeError) as e:
qfunc(obj)
assert e.value.args[0].startswith("state must be Qobj")
# Use indirection so that the tests can still be collected if there's a bug
# in the generating QuTiP functions.
@pytest.mark.parametrize('state', [
pytest.param(lambda: qutip.rand_super(2), id='super'),
pytest.param(lambda: qutip.rand_ket(2).dag(), id='bra'),
pytest.param(lambda: 1j * qutip.rand_dm(2), id='non-dm operator'),
pytest.param(lambda: qutip.Qobj([[1, 0], [0, 0]], dims=[[2], [2, 1]]),
id='nonsquare dm'),
pytest.param(lambda: qutip.operator_to_vector(qutip.qeye(2)),
id='operator-ket'),
pytest.param(lambda: qutip.operator_to_vector(qutip.qeye(2)).dag(),
id='operator-bra'),
])
def test_failure_if_not_a_state(self, state):
xs = np.linspace(-1, 1, 11)
state = state()
with pytest.raises(ValueError) as e:
qutip.qfunc(state, xs, xs)
assert (e.value.args[0].startswith(
"state must be a ket or density matrix"))
qfunc = qutip.QFunc(xs, xs)
with pytest.raises(ValueError) as e:
qfunc(state)
assert (e.value.args[0].startswith(
"state must be a ket or density matrix"))
@pytest.mark.parametrize('g', [
pytest.param(np.sqrt(2), id='natural units'),
pytest.param(1, id='arb units'),
])
@pytest.mark.parametrize('n_ys', [5, 101])
@pytest.mark.parametrize('n_xs', [5, 101])
@pytest.mark.parametrize('dm', [True, False], ids=['dm', 'ket'])
@pytest.mark.parametrize('size', [5, 32])
def test_function_and_class_are_equivalent(self, size, dm, n_xs, n_ys, g):
xs = np.linspace(-1, 1, n_xs)
ys = np.linspace(0, 2, n_ys)
state = qutip.rand_dm(size) if dm else qutip.rand_ket(size)
function = qutip.qfunc(state, xs, ys, g)
class_ = qutip.QFunc(xs, ys, g)(state)
np.testing.assert_allclose(function, class_)
@pytest.mark.parametrize('g', [
pytest.param(np.sqrt(2), id='natural units'),
pytest.param(1, id='arb units'),
])
@pytest.mark.parametrize('n_ys', [5, 101])
@pytest.mark.parametrize('n_xs', [5, 101])
@pytest.mark.parametrize('size', [5, 32])
def test_iterate_and_precompute_are_equivalent(self, size, n_xs, n_ys, g):
xs = np.linspace(-1, 1, n_xs)
ys = np.linspace(0, 2, n_ys)
state = qutip.rand_dm(size)
iterate = qutip.qfunc(state, xs, ys, g, precompute_memory=None)
precompute = qutip.qfunc(state, xs, ys, g, precompute_memory=np.inf)
np.testing.assert_allclose(iterate, precompute)
@pytest.mark.parametrize('initial_size', [5, 8])
@pytest.mark.parametrize('dm', [True, False], ids=['dm', 'ket'])
def test_same_class_can_take_many_sizes(self, dm, initial_size):
xs = np.linspace(-1, 1, 11)
ys = np.linspace(0, 2, 11)
shape = np.meshgrid(xs, ys)[0].shape
sizes = initial_size + np.array([0, 1, -1, 4])
qfunc = qutip.QFunc(xs, ys)
for size in sizes:
state = qutip.rand_dm(size) if dm else qutip.rand_ket(size)
out = qfunc(state)
assert isinstance(out, np.ndarray)
assert out.shape == shape
@pytest.mark.parametrize('dm_first', [True, False])
def test_same_class_can_mix_ket_and_dm(self, dm_first):
dms = [True, False, True, False]
if not dm_first:
dms = dms[::-1]
xs = np.linspace(-1, 1, 11)
ys = np.linspace(0, 2, 11)
shape = np.meshgrid(xs, ys)[0].shape
qfunc = qutip.QFunc(xs, ys)
for dm in dms:
state = qutip.rand_dm(4) if dm else qutip.rand_ket(4)
out = qfunc(state)
assert isinstance(out, np.ndarray)
assert out.shape == shape
@pytest.mark.parametrize('n_ys', [5, 101])
@pytest.mark.parametrize('n_xs', [5, 101])
@pytest.mark.parametrize('mix', [0.1, 0.5])
def test_qfunc_is_linear(self, n_xs, n_ys, mix):
xs = np.linspace(-1, 1, n_xs)
ys = np.linspace(-1, 1, n_ys)
qfunc = qutip.QFunc(xs, ys)
left, right = qutip.rand_dm(5), qutip.rand_dm(5)
qleft, qright = qfunc(left), qfunc(right)
qboth = qfunc(mix * left + (1 - mix) * right)
np.testing.assert_allclose(mix * qleft + (1 - mix) * qright, qboth)
@pytest.mark.parametrize('n_ys', [5, 101])
@pytest.mark.parametrize('n_xs', [5, 101])
@pytest.mark.parametrize('size', [5, 32])
def test_ket_and_dm_give_same_result(self, n_xs, n_ys, size):
xs = np.linspace(-1, 1, n_xs)
ys = np.linspace(-1, 1, n_ys)
state = qutip.rand_ket(size)
qfunc = qutip.QFunc(xs, ys)
np.testing.assert_allclose(qfunc(state), qfunc(state.proj()))
@pytest.mark.parametrize('g', [
pytest.param(np.sqrt(2), id='natural units'),
pytest.param(1, id='arb units'),
])
@pytest.mark.parametrize('ys', [
pytest.param(np.linspace(-1, 1, 5), id='(-1,1,5)'),
pytest.param(np.linspace(0, 2, 3), id='(0,2,3)'),
])
@pytest.mark.parametrize('xs', [
pytest.param(np.linspace(-1, 1, 5), id='(-1,1,5)'),
pytest.param(np.linspace(0, 2, 3), id='(0,2,3)'),
])
@pytest.mark.parametrize('size', [3, 5])
def test_against_naive_implementation(self, xs, ys, g, size):
state = qutip.rand_dm(size)
state_np = state.full()
x, y = np.meshgrid(xs, ys)
alphas = 0.5 * g * (x + 1j * y)
naive = np.empty(alphas.shape, dtype=np.float64)
for i, alpha in enumerate(alphas.flat):
coh = qutip.coherent(size, alpha, method='analytic').full()
naive.flat[i] = (coh.conj().T @ state_np @ coh).real
naive *= (0.5 * g)**2 / np.pi
np.testing.assert_allclose(naive, qutip.qfunc(state, xs, ys, g))
np.testing.assert_allclose(naive, qutip.QFunc(xs, ys, g)(state))
new_state = unitary * qubit * unitary.dag()
old_vector = qubit_to_vector(old_state)
new_vector = qubit_to_vector(new_state)
old_angles, r0 = vector_to_angles(old_vector)
new_angles, r1 = vector_to_angles(new_vector)
angle_delta = new_angles[0] - old_angles[0]
vector_delta = new_vector - old_vector
vector_delta = vector_delta.T[0].tolist()
gauge_delta = []
for i in range(4):
if vector_delta[i] != 0:
delta.append([angle_delta / vector_delta[i]])
else:
delta.append([0])
gauge_delta = np.array(delta)
return (new_state*cmath.exp(-im()*angle_delta),\
vector_to_qubit(normalize(qubit_to_vector(photon) + (1./gauge_charge)*gauge_delta)))
qubit = qutip.rand_ket(2).ptrace(0)
photon = qutip.rand_ket(2).ptrace(0)
unitary = (-2 * math.pi * im() * qutip.rand_herm(2) * 0.001).expm()
qubit1, qubit2 = evolve(qubit, photon, unitary, 2)
def test_ket_and_dm_give_same_result(self, n_xs, n_ys, size):
xs = np.linspace(-1, 1, n_xs)
ys = np.linspace(-1, 1, n_ys)
state = qutip.rand_ket(size)
qfunc = qutip.QFunc(xs, ys)
np.testing.assert_allclose(qfunc(state), qfunc(state.proj()))
def testRandket(self):
"random ket"
P = [rand_ket(5) for k in range(5)]
for p in P:
assert_equal(p.type == 'ket', True)
for i in range(len(WHICH_IS)):
j, m = WHICH_IS[i]
if j == 0: # No spin-0 for now
probabilities[i] = 0
probabilities = np.array(probabilities)
probabilities = probabilities / probabilities.sum()
j_probs = []
for i, B in enumerate(boundaries):
if i == len(boundaries) - 1:
j_probs.append(sum(probabilities[B:]))
else:
j_probs.append(sum(probabilities[B:boundaries[i + 1]]))
probs = {"up": j_probs[0], "down": j_probs[1]}
theta = math.acos(2 * probs["up"] -
1) #math.acos(1-2*probs["down"])
return theta
if __name__ == '__main__':
spheres = Spheres()
a = spheres.add_child(qt.rand_ket(10))
b = spheres.add_child(qt.rand_ket(12))
#spheres.state = qt.rand_ket(6*7)
#spheres.state.dims = [[6,7], [1,1]]
#spheres.split_child(a,0.5,0.5)
spheres.penrose_angle(a, b)
Z_ = qt.rz(-np.pi, N=3, target=2)
state_array = state.full()
if result == 1:
state = -1j * X_ * state
amp = [state_array[3], state_array[2]]
return qt.Qobj(amp).unit()
if result == 2:
state = -1j * Z_ * state
amp = [state_array[4], -state_array[5]]
return qt.Qobj(amp).unit()
if result == 3:
state = -1 * Z_ * X_ * state
amp = [state_array[7], -state_array[6]]
return qt.Qobj(amp).unit()
amp = [state_array[0], state_array[1]]
return qt.Qobj(amp).unit()
if __name__=='__main__':
state = qt.rand_ket(N=2)
result = evolute(initialize(state))
teleport_state = teleport(result, measure(result))
print(state.full())
print(teleport_state.full())
def __init__(self):
self.qubit = Qubit(qutip.rand_ket(2).ptrace(0), self)
self.photon = Qubit(qutip.rand_ket(2).ptrace(0), self, emissive=True)
self.charge = 1
self.energy = qutip.identity(2)
xyz = np.array([[x],\
[y],\
[z]])
if w == 1:
return xyz
else:
return (1./(1.-w))*xyz
def normalize(v):
norm = np.linalg.norm(v)
if norm == 0:
return v
return v / norm
dt = 0.01
qubit = qutip.rand_ket(2).ptrace(0)
photon = np.array([[0],[0],[0],[0]], dtype='complex128')
vsphere = vpython.sphere(pos=vpython.vector(0,0,0),\
radius=1,\
opacity=0.4,\
color=vpython.color.blue)
vbase = vpython.sphere(radius=0.1,\
opacity=0.8,\
color=vpython.color.white, emissive=True)
vphoton = vpython.sphere(radius=0.2,\
color=vpython.color.yellow,\
opacity=0.2)
def apply(transformation):
def test_pure_state(self):
assert abs(qutip.entropy_linear(qutip.rand_ket(10))) < 1e-12
n_samples = 10000 # Number of samples for each type
for i in range(n_samples):
# Random States
dm = q.rand_dm(2**n_qubits, density=0.75, pure=True).full()
if n_qubits == 2:
wigner = wf.wigner_2qb_ea(dm, rotation_operator)
elif n_qubits == 3:
wigner = wf.wigner_3qb_ea(dm, rotation_operator)
elif n_qubits == 4:
wigner = wf.wigner_4qb_ea(dm, rotation_operator)
elif n_qubits == 5:
wigner = wf.wigner_5qb_ea(dm, rotation_operator)
wigners.append(wigner.flatten())
# Random Separable States
psi = np.matrix(q.rand_ket(2, density=0.75).full())
for i in range(n_qubits - 1):
psi = np.kron(psi, np.matrix(q.rand_ket(2, density=0.75).full()))
dm = psi * psi.getH()
if n_qubits == 2:
wigner = wf.wigner_2qb_ea(dm, rotation_operator)
elif n_qubits == 3:
wigner = wf.wigner_3qb_ea(dm, rotation_operator)
elif n_qubits == 4:
wigner = wf.wigner_4qb_ea(dm, rotation_operator)
elif n_qubits == 5:
wigner = wf.wigner_5qb_ea(dm, rotation_operator)
wigners.append(wigner.flatten())
# Random Entangled States
dm = np.zeros((2**n_qubits, 2**n_qubits))
dm[0, 0] = 0.5
sim = Simulation(do_qt_mesolve, state=state, fname='2qtest.yaml')
states = sim.run_solver(nsteps=1000, steps=1000, tau=1e-8,
progress_bar=True)
return np.max([qt.fidelity(target, s) for s in states])
def random_purity_benchmark(state, **kwargs):
target = root_iSWAP * state.ptrace([1,2])
sim = Simulation(do_qt_mesolve, state=state, fname='time_dependent.yaml')
states = sim.run_solver(nsteps=2000, steps=10000, tau=1e-7, rhs_reuse=True)
print('Done a state')
return qt.fidelity(target, states[-1].ptrace([1,2]))
if __name__ == '__main__':
n = thermal_state(5e9, 20e-3, 5)
state = qt.tensor(n, qt.rand_ket(2), qt.rand_ket(2))
sim = Simulation(do_qt_mesolve, state=state, fname='time_dependent.yaml')
ls = get_lind_list(sim.w_c, 1e4, 20e-3, 1, 1e2, sim.dims)
sim.lindblads = ls
res = sim.run_solver(nsteps=1000, steps=10000, tau=1e-7, progress_bar=True)
# bvs, ns = sim.parse_states(res)
b = qt.Bloch()
for i in range(10000):
b.clear()
b.add_states(res[i].ptrace(1))
b.add_states(res[i].ptrace(2))
b.render()
b.save(dirc='temp')
# plt.hist(ns, 50)
# plt.show()
# targets = [[qt.tensor(qt.rand_ket(2), qt.rand_ket(2))] for i in range(100)]
def angle_to_qubit(angle):
theta, phi = angle
qubit = [math.cos(theta/2.), math.sin(theta/2.)*cmath.exp(complex(0,1)*phi)]
return qutip.Qobj(np.array(qubit))
def qubit_to_angle(qubit):
dm = qubit.ptrace(0).full()
x = float(2*dm[0][1].real)
y = float(2*dm[1][0].imag)
z = float((dm[0][0] - dm[1][1]).real)
return xyz_to_angle([x, y, z])
if True:
print("\nqubit -> angle test")
qubit = qutip.rand_ket(2)
angle = qubit_to_angle(qubit)
qubit2 = angle_to_qubit(angle)
print("qubit:\n%s" % str(qubit))
print("angle:\n%s" % str(angle))
print("qubit2:\n%s" % str(qubit2))
print(angle_to_xyz(qubit_to_angle(qubit)))
print(angle_to_xyz(qubit_to_angle(qubit2)))
if False:
print("\nangle -> qubit test")
angle = (random.uniform(0, math.pi), random.uniform(0, 2*math.pi))
qubit = angle_to_qubit(angle)
angle2 = qubit_to_angle(qubit)
print("angle:\n%s" % str(angle))
