def test_gates_class():
init_state = qutip.rand_ket(8, dims=[[2, 2, 2], [1, 1, 1]])
circuit1 = QubitCircuit(3)
circuit1.add_gate("X", 1)
circuit1.add_gate("Y", 1)
circuit1.add_gate("Z", 2)
circuit1.add_gate("RX", 0, arg_value=np.pi / 4)
circuit1.add_gate("RY", 0, arg_value=np.pi / 4)
circuit1.add_gate("RZ", 1, arg_value=np.pi / 4)
circuit1.add_gate("H", 0)
circuit1.add_gate("SQRTNOT", 0)
circuit1.add_gate("S", 2)
circuit1.add_gate("T", 1)
circuit1.add_gate("QASMU", 0, arg_value=(np.pi / 4, np.pi / 4, np.pi / 4))
circuit1.add_gate("CNOT", controls=0, targets=1)
circuit1.add_gate("CPHASE", controls=0, targets=1, arg_value=np.pi / 4)
circuit1.add_gate("SWAP", [0, 1])
circuit1.add_gate("ISWAP", [2, 1])
circuit1.add_gate("CZ", controls=0, targets=2)
circuit1.add_gate("SQRTSWAP", [2, 0])
circuit1.add_gate("SQRTISWAP", [0, 1])
circuit1.add_gate("SWAPALPHA", [1, 2], arg_value=np.pi / 4)
circuit1.add_gate("MS", [1, 0], arg_value=np.pi / 4)
circuit1.add_gate("TOFFOLI", [2, 0, 1])
circuit1.add_gate("FREDKIN", [0, 1, 2])
circuit1.add_gate("BERKELEY", [1, 0])
result1 = circuit1.run(init_state)
circuit2 = QubitCircuit(3)
circuit2.add_gate(X(1))
circuit2.add_gate(Y(1))
circuit2.add_gate(Z(2))
circuit2.add_gate(RX(0, np.pi / 4))
circuit2.add_gate(RY(0, np.pi / 4))
circuit2.add_gate(RZ(1, np.pi / 4))
circuit2.add_gate(H(0))
circuit2.add_gate(SQRTNOT(0))
circuit2.add_gate(S(2))
circuit2.add_gate(T(1))
circuit2.add_gate(QASMU(0, (np.pi / 4, np.pi / 4, np.pi / 4)))
circuit2.add_gate(CNOT(0, 1))
circuit2.add_gate(CPHASE(0, 1, np.pi / 4))
circuit2.add_gate(SWAP([0, 1]))
circuit2.add_gate(ISWAP([2, 1]))
circuit2.add_gate(CZ(0, 2))
circuit2.add_gate(SQRTSWAP([2, 0]))
circuit2.add_gate(SQRTISWAP([0, 1]))
circuit2.add_gate(SWAPALPHA([1, 2], np.pi / 4))
circuit2.add_gate(MS([1, 0], np.pi / 4))
circuit2.add_gate(TOFFOLI([2, 0, 1]))
circuit2.add_gate(FREDKIN([0, 1, 2]))
circuit2.add_gate(BERKELEY([1, 0]))
result2 = circuit2.run(init_state)
assert pytest.approx(qutip.fidelity(result1, result2), 1.0e-6) == 1
def test_N_level_system(self):
"""
Test for circuit with N-level system.
"""
mat3 = qp.rand_unitary_haar(3)
def controlled_mat3(arg_value):
"""
A qubit control an operator acting on a 3 level system
"""
control_value = arg_value
dim = mat3.dims[0][0]
return (tensor(fock_dm(2, control_value), mat3) +
tensor(fock_dm(2, 1 - control_value), identity(dim)))
qc = QubitCircuit(2, dims=[3, 2])
qc.user_gates = {"CTRLMAT3": controlled_mat3}
qc.add_gate("CTRLMAT3", targets=[1, 0], arg_value=1)
props = qc.propagators()
final_fid = qp.average_gate_fidelity(mat3, ptrace(props[0], 0) - 1)
assert pytest.approx(final_fid, 1.0e-6) == 1
init_state = basis([3, 2], [0, 1])
result = qc.run(init_state)
final_fid = qp.fidelity(result, props[0] * init_state)
assert pytest.approx(final_fid, 1.0e-6) == 1.
def test_with_model(self):
model = SpinChainModel(3, setup="linear")
processor = OptPulseProcessor(3, model=model)
qc = QubitCircuit(3)
qc.add_gate("CNOT", 1, 0)
qc.add_gate("X", 2)
processor.load_circuit(qc,
merge_gates=True,
num_tslots=10,
evo_time=2.0)
init_state = qutip.rand_ket(8, dims=[[2, 2, 2], [1, 1, 1]])
num_result = processor.run_state(init_state=init_state).states[-1]
ideal_result = qc.run(init_state)
assert (pytest.approx(qutip.fidelity(num_result, ideal_result),
1.0e-5) == 1.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("X", targets=2)
qc.add_gate("SNOT", targets=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(
to implement a gate containing the control pulses.
"""
# gate.arg_value is the pulse phase
tlist = self.params["duration"]
coeff = self.params["pulse_amplitude"]
coeff /= 2 * np.pi
return self.generate_pulse(gate, tlist, coeff, phase=gate.arg_value)
# Define a circuit and run the simulation
num_qubits = 1
circuit = QubitCircuit(1)
circuit.add_gate("RX", targets=0, arg_value=np.pi / 2)
circuit.add_gate("Z", targets=0)
result1 = circuit.run(basis(2, 0))
myprocessor = ModelProcessor(model=MyModel(num_qubits))
myprocessor.native_gates = ["RX", "RY"]
mycompiler = MyCompiler(num_qubits, {"pulse_amplitude": 0.02})
myprocessor.load_circuit(circuit, compiler=mycompiler)
result2 = myprocessor.run_state(basis(2, 0)).states[-1]
assert (abs(fidelity(result1, result2) - 1) < 1.e-5)
fig, ax = myprocessor.plot_pulses(figsize=(LINEWIDTH * 0.7,
LINEWIDTH / 2 * 0.7),
dpi=200,
use_control_latex=False)
ax[-1].set_xlabel("$t$")
