def test_opt_basis_single_qubit_2d(self):
b = bases.general(2)
b0 = b.subbasis([0])
b1 = b.subbasis([1])
b01 = b.computational_subbasis()
# Identity up to floating point error
rot = lib2.rotate_x(2 * np.pi).compile(bases_in=(b0,))
assert rot.bases_in == (b0,)
assert rot.bases_out == (b0,)
rot = lib2.rotate_x(2 * np.pi).compile(bases_in=(b1,))
assert rot.bases_in == (b1,)
assert rot.bases_out == (b1,)
# RX(pi)
rot = lib2.rotate_x(np.pi).compile(bases_in=(b0,))
assert rot.bases_in == (b0,)
assert rot.bases_out == (b1,)
rot = lib2.rotate_x(np.pi).compile(bases_in=(b1,))
assert rot.bases_in == (b1,)
assert rot.bases_out == (b0,)
# RY(pi/2)
rot = lib2.rotate_y(np.pi / 2).compile(bases_in=(b01,))
assert rot.bases_in[0] == b01
assert rot.bases_out[0].dim_pauli == 3
assert '0' in rot.bases_out[0].labels
assert '1' in rot.bases_out[0].labels
assert 'X10' in rot.bases_out[0].labels
def test_chain_apply(self):
b = (bases.general(2), ) * 3
dm = random_hermitian_matrix(8, seed=93)
pv1 = PauliVector.from_dm(dm, b)
pv2 = PauliVector.from_dm(dm, b)
# Some random gate sequence
op_indices = [(lib2.rotate_x(np.pi / 2), (0, )),
(lib2.rotate_y(0.3333), (1, )), (lib2.cphase(), (0, 2)),
(lib2.cphase(), (1, 2)),
(lib2.rotate_x(-np.pi / 2), (0, ))]
for op, indices in op_indices:
op(pv1, *indices),
circuit = Operation.from_sequence(*(op.at(*ix)
for op, ix in op_indices))
circuit(pv2, 0, 1, 2)
assert np.all(pv1.to_pv() == pv2.to_pv())
def test_chain_apply(self):
b = (bases.general(2), ) * 3
dm = random_density_matrix(8, seed=93)
state1 = State.from_dm(dm, b)
state2 = State.from_dm(dm, b)
# Some random gate sequence
op_indices = [(lib2.rotate_x(np.pi / 2), (0, )),
(lib2.rotate_y(0.3333), (1, )), (lib2.cphase(), (0, 2)),
(lib2.cphase(), (1, 2)),
(lib2.rotate_x(-np.pi / 2), (0, ))]
for op, indices in op_indices:
op(state1, *indices),
circuit = Operation.from_sequence(*(op.at(*ix)
for op, ix in op_indices))
circuit(state2, 0, 1, 2)
assert np.all(state1.to_pv() == state2.to_pv())
def test_chain_apply(self):
b = (bases.general(2),) * 3
dm = random_density_matrix(8, seed=93)
state1 = State.from_dm(dm, b)
state2 = State.from_dm(dm, b)
# Some random gate sequence
op_indices = [(lib2.rotate_x(np.pi/2), (0,)),
(lib2.rotate_y(0.3333), (1,)),
(lib2.cphase(), (0, 2)),
(lib2.cphase(), (1, 2)),
(lib2.rotate_x(-np.pi/2), (0,))]
for op, indices in op_indices:
op(state1, *indices),
circuit = Operation.from_sequence(
*(op.at(*ix) for op, ix in op_indices))
circuit(state2, 0, 1, 2)
assert np.all(state1.to_pv() == state2.to_pv())
def test_ptm(self):
# Some random gate sequence
op_indices = [(lib2.rotate_x(np.pi / 2), (0, )),
(lib2.rotate_y(0.3333), (1, )), (lib2.cphase(), (0, 2)),
(lib2.cphase(), (1, 2)),
(lib2.rotate_x(-np.pi / 2), (0, ))]
circuit = Operation.from_sequence(*(op.at(*ix)
for op, ix in op_indices))
b = (bases.general(2), ) * 3
ptm = circuit.ptm(b, b)
assert isinstance(ptm, np.ndarray)
op_3q = Operation.from_ptm(ptm, b)
dm = random_hermitian_matrix(8, seed=93)
state1 = PauliVector.from_dm(dm, b)
state2 = PauliVector.from_dm(dm, b)
circuit(state1, 0, 1, 2)
op_3q(state2, 0, 1, 2)
assert np.allclose(state1.to_pv(), state2.to_pv())
def test_rotate_x(self):
qubit_basis = (bases.general(2),)
sys_bases = qubit_basis * 3
dm = State(sys_bases)
rotate90 = lib.rotate_x(0.5*np.pi)
rotate180 = lib.rotate_x(np.pi)
rotate360 = lib.rotate_x(2*np.pi)
rotate90(dm, 1)
rotate180(dm, 2)
assert np.allclose(dm.meas_prob(0), (1, 0))
assert np.allclose(dm.meas_prob(1), (0.5, 0.5))
assert np.allclose(dm.meas_prob(2), (0, 1))
rotate180(dm, 1)
assert np.allclose(dm.meas_prob(1), (0.5, 0.5))
rotate90(dm, 1)
assert np.allclose(dm.meas_prob(1), (1, 0))
rotate360(dm, 0)
assert np.allclose(dm.meas_prob(0), (1, 0))
def test_chain_create(self):
op1 = lib2.rotate_x()
op2 = lib2.rotate_y()
op3 = lib2.cnot()
op_qutrit = lib3.rotate_x()
circuit = Operation.from_sequence(op1.at(0), op2.at(0))
assert circuit.num_qubits == 1
assert len(circuit.operations) == 2
circuit = Operation.from_sequence(op1.at(1), op2.at(0))
assert circuit.num_qubits == 2
assert len(circuit.operations) == 2
with pytest.raises(ValueError, match=".* must form an ordered set .*"):
Operation.from_sequence(op1.at(2), op2.at(0))
with pytest.raises(ValueError, match=".* must form an ordered set .*"):
Operation.from_sequence(op1.at(1), op2.at(2))
with pytest.raises(ValueError, match="Hilbert dimensionality of op.*"):
Operation.from_sequence(op1.at(0), op_qutrit.at(0))
circuit3q = Operation.from_sequence(op1.at(0), op2.at(1), op3.at(0, 1),
op1.at(1), op2.at(0), op3.at(0, 2))
assert circuit3q.num_qubits == 3
assert len(circuit3q.operations) == 6
with pytest.raises(ValueError, match="Number of indices is not .*"):
Operation.from_sequence(op1.at(0), op3.at(0))
with pytest.raises(ValueError, match="Number of indices is not .*"):
circuit3q.at(0, 1)
circuit4q = Operation.from_sequence(op3.at(0, 2),
circuit3q.at(1, 2, 3))
assert len(circuit4q.operations) == 7
assert circuit4q.operations[0].indices == (0, 2)
for o1, o2 in zip(circuit4q.operations[1:], circuit3q.operations):
assert np.all(np.array(o1.indices) == np.array(o2.indices) + 1)
circuit4q = Operation.from_sequence(circuit3q.at(2, 0, 3),
op3.at(0, 1), op2.at(1))
assert len(circuit4q.operations) == 8
assert circuit4q.operations[0].indices == (2, )
assert circuit4q.operations[1].indices == (0, )
assert circuit4q.operations[2].indices == (2, 0)
Operation.from_sequence(circuit3q.at(0, 1, 2),
Operation.from_sequence(op1, op2).at(1))
def test_chain_create(self):
op1 = lib2.rotate_x()
op2 = lib2.rotate_y()
op3 = lib2.cnot()
op_qutrit = lib3.rotate_x()
circuit = Operation.from_sequence(op1.at(0), op2.at(0))
assert circuit.num_qubits == 1
assert len(circuit.operations) == 2
circuit = Operation.from_sequence(op1.at(1), op2.at(0))
assert circuit.num_qubits == 2
assert len(circuit.operations) == 2
with pytest.raises(ValueError, match=".* must form an ordered set .*"):
Operation.from_sequence(op1.at(2), op2.at(0))
with pytest.raises(ValueError, match=".* must form an ordered set .*"):
Operation.from_sequence(op1.at(1), op2.at(2))
with pytest.raises(ValueError, match="Hilbert dimensionality of op.*"):
Operation.from_sequence(op1.at(0), op_qutrit.at(0))
circuit3q = Operation.from_sequence(op1.at(0), op2.at(1), op3.at(0, 1),
op1.at(1), op2.at(0), op3.at(0, 2))
assert circuit3q.num_qubits == 3
assert len(circuit3q.operations) == 6
with pytest.raises(ValueError, match="Number of indices is not .*"):
Operation.from_sequence(op1.at(0), op3.at(0))
with pytest.raises(ValueError, match="Number of indices is not .*"):
circuit3q.at(0, 1)
circuit4q = Operation.from_sequence(op3.at(0, 2), circuit3q.at(1, 2, 3))
assert len(circuit4q.operations) == 7
assert circuit4q.operations[0].indices == (0, 2)
for o1, o2 in zip(circuit4q.operations[1:], circuit3q.operations):
assert np.all(np.array(o1.indices) == np.array(o2.indices) + 1)
circuit4q = Operation.from_sequence(
circuit3q.at(2, 0, 3), op3.at(0, 1), op2.at(1))
assert len(circuit4q.operations) == 8
assert circuit4q.operations[0].indices == (2,)
assert circuit4q.operations[1].indices == (0,)
assert circuit4q.operations[2].indices == (2, 0)
def test_compile_single_qubit_2d(self):
b = bases.general(2)
b0 = b.subbasis([0])
b01 = b.computational_subbasis()
op = lib2.rotate_y(np.pi)
assert op.shape == (4, 4)
op_full = op.compile(bases_in=(b,))
assert op_full.shape == (4, 4)
op_cl = op.compile(bases_in=(b01,))
assert op_cl.shape == (2, 2)
op = lib2.rotate_x(np.pi / 3)
assert op.shape == (4, 4)
op_full = op.compile(bases_in=(b,), bases_out=(b01,))
# X component of a state is irrelevant for the output.
assert op_full.shape == (2, 3)
op_cl = op.compile(bases_in=(b0,))
assert op_cl.shape == (3, 1)