def testNoise(self):
"""
Test for Processor with noise
"""
# setup and fidelity without noise
init_state = qubit_states(2, [0, 0, 0, 0])
tlist = np.array([0., np.pi / 2.])
a = destroy(2)
proc = Processor(N=2)
proc.add_control(sigmax(), targets=1, label="sx")
proc.set_all_coeffs({"sx": np.array([1.])})
proc.set_all_tlist(tlist)
result = proc.run_state(init_state=init_state)
assert_allclose(fidelity(result.states[-1],
qubit_states(2, [0, 1, 0, 0])),
1,
rtol=1.e-7)
# decoherence noise
dec_noise = DecoherenceNoise([0.25 * a], targets=1)
proc.add_noise(dec_noise)
result = proc.run_state(init_state=init_state)
assert_allclose(fidelity(result.states[-1],
qubit_states(2, [0, 1, 0, 0])),
0.981852,
rtol=1.e-3)
# white random noise
proc.model._noise = []
white_noise = RandomNoise(0.2, np.random.normal, loc=0.1, scale=0.1)
proc.add_noise(white_noise)
result = proc.run_state(init_state=init_state)
def test_multi_qubits(self):
"""
Test for multi-qubits system.
"""
N = 3
H_d = tensor([sigmaz()] * 3)
H_c = []
# test empty ctrls
num_tslots = 30
evo_time = 10
test = OptPulseProcessor(N)
test.add_drift(H_d, [0, 1, 2])
test.add_control(tensor([sigmax(), sigmax()]), cyclic_permutation=True)
# test periodically adding ctrls
sx = sigmax()
iden = identity(2)
# print(test.ctrls)
# print(Qobj(tensor([sx, iden, sx])))
assert_(Qobj(tensor([sx, iden, sx])) in test.ctrls)
assert_(Qobj(tensor([iden, sx, sx])) in test.ctrls)
assert_(Qobj(tensor([sx, sx, iden])) in test.ctrls)
test.add_control(sigmax(), cyclic_permutation=True)
test.add_control(sigmay(), cyclic_permutation=True)
# test pulse genration for cnot gate, with kwargs
qc = [tensor([identity(2), cnot()])]
test.load_circuit(qc,
num_tslots=num_tslots,
evo_time=evo_time,
min_fid_err=1.0e-6)
rho0 = qubit_states(3, [1, 1, 1])
rho1 = qubit_states(3, [1, 1, 0])
result = test.run_state(rho0, options=Options(store_states=True))
assert_(fidelity(result.states[-1], rho1) > 1 - 1.0e-6)
def test_simple_hadamard(self):
"""
Test for optimizing a simple hadamard gate
"""
N = 1
H_d = sigmaz()
H_c = sigmax()
qc = QubitCircuit(N)
qc.add_gate("SNOT", 0)
# test load_circuit, with verbose info
num_tslots = 10
evo_time = 10
test = OptPulseProcessor(N, drift=H_d)
test.add_control(H_c, targets=0)
tlist, coeffs = test.load_circuit(qc,
num_tslots=num_tslots,
evo_time=evo_time,
verbose=True)
# test run_state
rho0 = qubit_states(1, [0])
plus = (qubit_states(1, [0]) + qubit_states(1, [1])).unit()
result = test.run_state(rho0)
assert_allclose(fidelity(result.states[-1], plus), 1, rtol=1.0e-6)
# test add/remove ctrl
test.add_control(sigmay())
test.remove_pulse(0)
assert_(len(test.pulses) == 1,
msg="Method of remove_pulse could be wrong.")
assert_allclose(test.drift.drift_hamiltonians[0].qobj, H_d)
assert_(sigmay() in test.ctrls,
msg="Method of remove_pulse could be wrong.")
def test_simple_hadamard(self):
"""
Test for optimizing a simple hadamard gate
"""
N = 1
H_d = sigmaz()
H_c = sigmax()
qc = QubitCircuit(N)
qc.add_gate("SNOT", 0)
# test load_circuit, with verbose info
num_tslots = 10
evo_time = 10
test = OptPulseProcessor(N, drift=H_d)
test.add_control(H_c, targets=0)
tlist, coeffs = test.load_circuit(qc,
num_tslots=num_tslots,
evo_time=evo_time,
verbose=True)
# test run_state
rho0 = qubit_states(1, [0])
plus = (qubit_states(1, [0]) + qubit_states(1, [1])).unit()
result = test.run_state(rho0)
assert_allclose(fidelity(result.states[-1], plus), 1, rtol=1.0e-6)
def testChooseSolver(self):
# setup and fidelity without noise
init_state = qubit_states(2, [0, 0, 0, 0])
tlist = np.array([0., np.pi/2.])
a = destroy(2)
proc = Processor(N=2)
proc.add_control(sigmax(), targets=1)
proc.pulses[0].tlist = tlist
proc.pulses[0].coeff = np.array([1])
result = proc.run_state(init_state=init_state, solver="mcsolve")
assert_allclose(
fidelity(result.states[-1], qubit_states(2, [0, 1, 0, 0])),
1, rtol=1.e-7)
def testQubitStates(self):
"""
Tests the qubit_states function.
"""
psi0_a = basis(2, 0)
psi0_b = qubit_states()
assert_(psi0_a == psi0_b)
psi1_a = basis(2, 1)
psi1_b = qubit_states(states=[1])
assert_(psi1_a == psi1_b)
psi01_a = tensor(psi0_a, psi1_a)
psi01_b = qubit_states(N=2, states=[0, 1])
assert_(psi01_a == psi01_b)
def testChooseSolver(self):
# setup and fidelity without noise
init_state = qubit_states(2, [0, 0, 0, 0])
tlist = np.linspace(0., np.pi / 2., 10)
a = destroy(2)
proc = Processor(N=2, t2=100)
proc.add_control(sigmax(), targets=1, label="sx")
proc.set_all_coeffs({"sx": np.array([1.] * len(tlist))})
proc.set_all_tlist(tlist)
observerable = tensor([qutip.qeye(2), qutip.sigmax()])
result1 = proc.run_state(init_state=init_state,
solver="mcsolve",
e_ops=observerable)
assert result1.solver == "mcsolve"
