def test_compiler_result_format():
"""
Test if compiler return correctly different kind of compiler result
and if processor can successfully read them.
"""
num_qubits = 1
circuit = QubitCircuit(num_qubits)
circuit.add_gate("RX", targets=[0], arg_value=np.pi / 2)
processor = LinearSpinChain(num_qubits)
compiler = SpinChainCompiler(num_qubits,
params=processor.params,
setup="circular")
tlist, coeffs = compiler.compile(circuit)
assert (isinstance(tlist, dict))
assert ("sx0" in tlist)
assert (isinstance(coeffs, dict))
assert ("sx0" in coeffs)
processor.coeffs = coeffs
processor.set_all_tlist(tlist)
assert_array_equal(processor.pulses[0].coeff, coeffs["sx0"])
assert_array_equal(processor.pulses[0].tlist, tlist["sx0"])
compiler.gate_compiler["RX"] = rx_compiler_without_pulse_dict
tlist, coeffs = compiler.compile(circuit)
assert (isinstance(tlist, dict))
assert (0 in tlist)
assert (isinstance(coeffs, dict))
assert (0 in coeffs)
processor.coeffs = coeffs
processor.set_all_tlist(tlist)
assert_array_equal(processor.pulses[0].coeff, coeffs[0])
assert_array_equal(processor.pulses[0].tlist, tlist[0])
def test_collapse_with_different_tlist(self):
"""
Test if there are errors raised because of wrong tlist handling.
"""
qc = QubitCircuit(1)
qc.add_gate("X", 0)
proc = LinearSpinChain(1)
proc.load_circuit(qc)
tlist = np.linspace(0, 30., 100)
coeff = tlist * 0.1
noise = DecoherenceNoise(sigmam(), targets=0, coeff=coeff, tlist=tlist)
proc.add_noise(noise)
proc.run_state(basis(2, 0))
def test_pulse_shape_scipy(shape):
"""Test different pulse shape functions imported from scipy"""
num_qubits = 1
circuit = QubitCircuit(num_qubits)
circuit.add_gate("X", 0)
processor = LinearSpinChain(num_qubits)
compiler = SpinChainCompiler(num_qubits, processor.params)
compiler.args.update({"shape": shape, "num_samples": 100})
processor.load_circuit(circuit, compiler=compiler)
if shape == "rectangular":
processor.pulse_mode = "discrete"
else:
processor.pulse_mode = "continuous"
init_state = basis(2, 0)
num_result = processor.run_state(init_state).states[-1]
ideal_result = circuit.run(init_state)
ifid = 1 - fidelity(num_result, ideal_result)
assert (pytest.approx(ifid, abs=0.01) == 0)
qc.add_gate("SNOT", targets=1)
qc.add_gate("SNOT", targets=2)
# Oracle function f(x)
qc.add_gate(
"CNOT", controls=0, targets=2)
qc.add_gate(
"CNOT", controls=1, targets=2)
qc.add_gate("SNOT", targets=0)
qc.add_gate("SNOT", targets=1)
init_state = basis([2,2,2], [0,0,0])
final_state = qc.run(init_state)
processor = LinearSpinChain(
num_qubits=3, sx=0.25)
processor.load_circuit(qc)
tlist = np.linspace(0, 20, 300)
result = processor.run_state(
init_state, tlist=tlist)
processor.add_noise(
RelaxationNoise(t2=30))
# Section 4.1 Model
model = SpinChainModel(
num_qubits=3, setup="circular", g=1)
processor = Processor(model=model)
# Deutsch-Josza algorithm
dj_circuit = QubitCircuit(num_qubits)
dj_circuit.add_gate("X", targets=2)
dj_circuit.add_gate("SNOT", targets=0)
dj_circuit.add_gate("SNOT", targets=1)
dj_circuit.add_gate("SNOT", targets=2)
# Oracle function f(x)
dj_circuit.add_gate("CNOT", controls=0, targets=2)
dj_circuit.add_gate("CNOT", controls=1, targets=2)
dj_circuit.add_gate("SNOT", targets=0)
dj_circuit.add_gate("SNOT", targets=1)
# Spin chain model
spinchain_processor = LinearSpinChain(num_qubits=num_qubits, t2=30) # T2 = 30
spinchain_processor.load_circuit(dj_circuit)
initial_state = basis([2, 2, 2], [0, 0, 0]) # 3 qubits in the 000 state
t_record = np.linspace(0, 20, 300)
result1 = spinchain_processor.run_state(initial_state, tlist=t_record)
# Superconducting qubits
scqubits_processor = SCQubits(num_qubits=num_qubits)
scqubits_processor.load_circuit(dj_circuit)
initial_state = basis([3, 3, 3], [0, 0, 0]) # 3-level
result2 = scqubits_processor.run_state(initial_state)
# Optimal control model
setting_args = {
"SNOT": {
"num_tslots": 6,
except:
pass
plt.rcParams.update({"text.usetex": False, "font.size": 10})
import numpy as np
from qutip import basis, fidelity
from qutip_qip.device import LinearSpinChain
from qutip_qip.algorithms import qft_gate_sequence
num_qubits = 10
# The QFT circuit
qc = qft_gate_sequence(num_qubits, swapping=False, to_cnot=True)
# Gate-level simulation
state1 = qc.run(basis([2] * num_qubits, [0] * num_qubits))
# Pulse-level simulation
processor = LinearSpinChain(num_qubits)
processor.load_circuit(qc)
state2 = processor.run_state(basis([2] * num_qubits,
[0] * num_qubits)).states[-1]
assert (abs(1 - fidelity(state1, state2)) < 1.e-4)
def get_control_latex(model):
"""
Get the labels for each Hamiltonian.
It is used in the method method :meth:`.Processor.plot_pulses`.
It is a 2-d nested list, in the plot,
a different color will be used for each sublist.
"""
num_qubits = model.num_qubits
def test_change_parameters_in_processor():
processor = LinearSpinChain(0, sx=0.1)
assert (all(processor.params["sx"] == [0.1]))
def test_spinchain_model(model_class):
model = LinearSpinChain(3, sx=[1.1, 1, 0, 0.8], sz=7.0, t1=10.0)
assert model.get_all_drift() == []
model.get_control_labels()
if isinstance(model, LinearSpinChain):
assert len(model.get_control_labels()) == 3 * 3 - 1
elif isinstance(model, CircularSpinChain):
assert len(model.get_control_labels()) == 3 * 3
model.get_control("g1")
model.get_control("sx0")
assert_array_equal(model.params["sz"], 7.0)
assert_array_equal(model.params["sx"], [1.1, 1, 0, 0.8])
assert model.get_control(0) == model.get_control("sx0")
model.get_control_latex()
assert model.params["t1"] == 10.0