def test_clifford_gate_act_on_large_case():
n, num_ops = 50, 1000 # because we don't need unitary, it is fast.
gate_candidate = [
cirq.X, cirq.Y, cirq.Z, cirq.H, cirq.S, cirq.CNOT, cirq.CZ
]
for seed in range(10):
prng = np.random.RandomState(seed)
t1 = cirq.CliffordTableau(num_qubits=n)
t2 = cirq.CliffordTableau(num_qubits=n)
qubits = cirq.LineQubit.range(n)
args1 = cirq.ActOnCliffordTableauArgs(tableau=t1,
qubits=qubits,
prng=prng,
log_of_measurement_results={})
args2 = cirq.ActOnCliffordTableauArgs(tableau=t2,
qubits=qubits,
prng=prng,
log_of_measurement_results={})
ops = []
for _ in range(num_ops):
g = prng.randint(len(gate_candidate))
indices = (prng.randint(n), ) if g < 5 else prng.choice(
n, 2, replace=False)
cirq.act_on(gate_candidate[g],
args1,
qubits=[qubits[i] for i in indices],
allow_decompose=False)
ops.append(gate_candidate[g].on(*[qubits[i] for i in indices]))
compiled_gate = cirq.CliffordGate.from_op_list(ops, qubits)
cirq.act_on(compiled_gate, args2, qubits)
assert args1.tableau == args2.tableau
def test_clifford_decompose_two_qubits():
"""Two random instance for two qubits decomposition."""
qubits = cirq.LineQubit.range(2)
args = cirq.ActOnCliffordTableauArgs(
tableau=cirq.CliffordTableau(num_qubits=2),
qubits=qubits,
prng=np.random.RandomState(),
log_of_measurement_results={},
)
cirq.act_on(cirq.H, args, qubits=[qubits[0]], allow_decompose=False)
cirq.act_on(cirq.CNOT,
args,
qubits=[qubits[0], qubits[1]],
allow_decompose=False)
expect_circ = cirq.Circuit(cirq.H(qubits[0]),
cirq.CNOT(qubits[0], qubits[1]))
ops = cirq.decompose_clifford_tableau_to_operations(qubits, args.tableau)
circ = cirq.Circuit(ops)
assert_allclose_up_to_global_phase(cirq.unitary(expect_circ),
cirq.unitary(circ),
atol=1e-7)
qubits = cirq.LineQubit.range(2)
args = cirq.ActOnCliffordTableauArgs(
tableau=cirq.CliffordTableau(num_qubits=2),
qubits=qubits,
prng=np.random.RandomState(),
log_of_measurement_results={},
)
cirq.act_on(cirq.H, args, qubits=[qubits[0]], allow_decompose=False)
cirq.act_on(cirq.CNOT,
args,
qubits=[qubits[0], qubits[1]],
allow_decompose=False)
cirq.act_on(cirq.H, args, qubits=[qubits[0]], allow_decompose=False)
cirq.act_on(cirq.S, args, qubits=[qubits[0]], allow_decompose=False)
cirq.act_on(cirq.X, args, qubits=[qubits[1]], allow_decompose=False)
expect_circ = cirq.Circuit(
cirq.H(qubits[0]),
cirq.CNOT(qubits[0], qubits[1]),
cirq.H(qubits[0]),
cirq.S(qubits[0]),
cirq.X(qubits[1]),
)
ops = cirq.decompose_clifford_tableau_to_operations(qubits, args.tableau)
circ = cirq.Circuit(ops)
assert_allclose_up_to_global_phase(cirq.unitary(expect_circ),
cirq.unitary(circ),
atol=1e-7)
def test_x_act_on_tableau():
with pytest.raises(TypeError, match="Failed to act"):
cirq.act_on(cirq.X, object())
original_tableau = cirq.CliffordTableau(num_qubits=5, initial_state=31)
flipped_tableau = cirq.CliffordTableau(num_qubits=5, initial_state=23)
args = cirq.ActOnCliffordTableauArgs(
tableau=original_tableau.copy(),
axes=[1],
prng=np.random.RandomState(),
log_of_measurement_results={},
)
cirq.act_on(cirq.X**0.5, args, allow_decompose=False)
cirq.act_on(cirq.X**0.5, args, allow_decompose=False)
assert args.log_of_measurement_results == {}
assert args.tableau == flipped_tableau
cirq.act_on(cirq.X, args, allow_decompose=False)
assert args.log_of_measurement_results == {}
assert args.tableau == original_tableau
cirq.act_on(cirq.X**3.5, args, allow_decompose=False)
cirq.act_on(cirq.X**3.5, args, allow_decompose=False)
assert args.log_of_measurement_results == {}
assert args.tableau == flipped_tableau
cirq.act_on(cirq.X**2, args, allow_decompose=False)
assert args.log_of_measurement_results == {}
assert args.tableau == flipped_tableau
foo = sympy.Symbol('foo')
with pytest.raises(TypeError, match="Failed to act action on state"):
cirq.act_on(cirq.X**foo, args)
def test_act_on_tableau(phase):
original_tableau = cirq.CliffordTableau(0)
args = cirq.ActOnCliffordTableauArgs(original_tableau.copy(),
np.random.RandomState(), {})
cirq.act_on(cirq.global_phase_operation(phase),
args,
allow_decompose=False)
assert args.tableau == original_tableau
def test_gate_act_on_tableau(phase):
original_tableau = cirq.CliffordTableau(0)
args = cirq.ActOnCliffordTableauArgs(original_tableau.copy(),
np.random.RandomState(), {})
cirq.act_on(cirq.GlobalPhaseGate(phase),
args,
qubits=(),
allow_decompose=False)
assert args.tableau == original_tableau
def test_clifford_decompose_by_reconstruction():
"""Validate the decomposition of random Clifford Tableau by reconstruction.
This approach can validate large number of qubits compared with the unitary one.
"""
n, num_ops = 100, 500
gate_candidate = [
cirq.X, cirq.Y, cirq.Z, cirq.H, cirq.S, cirq.CNOT, cirq.CZ
]
for seed in range(10):
prng = np.random.RandomState(seed)
t = cirq.CliffordTableau(num_qubits=n)
qubits = cirq.LineQubit.range(n)
expect_circ = cirq.Circuit()
args = cirq.ActOnCliffordTableauArgs(tableau=t,
qubits=qubits,
prng=prng,
log_of_measurement_results={})
for _ in range(num_ops):
g = prng.randint(len(gate_candidate))
indices = (prng.randint(n), ) if g < 5 else prng.choice(
n, 2, replace=False)
cirq.act_on(gate_candidate[g],
args,
qubits=[qubits[i] for i in indices],
allow_decompose=False)
expect_circ.append(
gate_candidate[g].on(*[qubits[i] for i in indices]))
ops = cirq.decompose_clifford_tableau_to_operations(
qubits, args.tableau)
reconstruct_t = cirq.CliffordTableau(num_qubits=n)
reconstruct_args = cirq.ActOnCliffordTableauArgs(
tableau=reconstruct_t,
qubits=qubits,
prng=prng,
log_of_measurement_results={})
for op in ops:
cirq.act_on(op.gate,
reconstruct_args,
qubits=op.qubits,
allow_decompose=False)
assert t == reconstruct_t
def test_cz_act_on_equivalent_to_h_cx_h_tableau():
args1 = cirq.ActOnCliffordTableauArgs(
tableau=cirq.CliffordTableau(num_qubits=2),
qubits=cirq.LineQubit.range(2),
prng=np.random.RandomState(),
log_of_measurement_results={},
)
args2 = cirq.ActOnCliffordTableauArgs(
tableau=cirq.CliffordTableau(num_qubits=2),
qubits=cirq.LineQubit.range(2),
prng=np.random.RandomState(),
log_of_measurement_results={},
)
cirq.act_on(cirq.S,
args=args1,
qubits=[cirq.LineQubit(1)],
allow_decompose=False)
cirq.act_on(cirq.S,
args=args2,
qubits=[cirq.LineQubit(1)],
allow_decompose=False)
# Args1 uses H*CNOT*H
cirq.act_on(cirq.H,
args=args1,
qubits=[cirq.LineQubit(1)],
allow_decompose=False)
cirq.act_on(cirq.CNOT,
args=args1,
qubits=cirq.LineQubit.range(2),
allow_decompose=False)
cirq.act_on(cirq.H,
args=args1,
qubits=[cirq.LineQubit(1)],
allow_decompose=False)
# Args2 uses CZ
cirq.act_on(cirq.CZ,
args=args2,
qubits=cirq.LineQubit.range(2),
allow_decompose=False)
assert args1.tableau == args2.tableau
def test_unitary_fallback():
class UnitaryXGate(cirq.Gate):
def _num_qubits_(self) -> int:
return 1
def _unitary_(self):
return np.array([[0, 1], [1, 0]])
class UnitaryYGate(cirq.Gate):
def _qid_shape_(self) -> Tuple[int, ...]:
return (2, )
def _unitary_(self):
return np.array([[0, -1j], [1j, 0]])
original_tableau = cirq.CliffordTableau(num_qubits=3)
args = cirq.ActOnCliffordTableauArgs(
tableau=original_tableau.copy(),
qubits=cirq.LineQubit.range(3),
prng=np.random.RandomState(),
log_of_measurement_results={},
)
cirq.act_on(UnitaryXGate(), args, [cirq.LineQubit(1)])
assert args.tableau == cirq.CliffordTableau(num_qubits=3, initial_state=2)
args = cirq.ActOnCliffordTableauArgs(
tableau=original_tableau.copy(),
qubits=cirq.LineQubit.range(3),
prng=np.random.RandomState(),
log_of_measurement_results={},
)
cirq.act_on(UnitaryYGate(), args, [cirq.LineQubit(1)])
expected_args = cirq.ActOnCliffordTableauArgs(
tableau=original_tableau.copy(),
qubits=cirq.LineQubit.range(3),
prng=np.random.RandomState(),
log_of_measurement_results={},
)
cirq.act_on(cirq.Y, expected_args, [cirq.LineQubit(1)])
assert args.tableau == expected_args.tableau
def test_z_h_act_on_tableau():
with pytest.raises(TypeError, match="Failed to act"):
cirq.act_on(cirq.Z, DummyActOnArgs(), qubits=())
with pytest.raises(TypeError, match="Failed to act"):
cirq.act_on(cirq.H, DummyActOnArgs(), qubits=())
original_tableau = cirq.CliffordTableau(num_qubits=5, initial_state=31)
flipped_tableau = cirq.CliffordTableau(num_qubits=5, initial_state=23)
args = cirq.ActOnCliffordTableauArgs(
tableau=original_tableau.copy(),
qubits=cirq.LineQubit.range(5),
prng=np.random.RandomState(),
log_of_measurement_results={},
)
cirq.act_on(cirq.H, args, [cirq.LineQubit(1)], allow_decompose=False)
cirq.act_on(cirq.Z ** 0.5, args, [cirq.LineQubit(1)], allow_decompose=False)
cirq.act_on(cirq.Z ** 0.5, args, [cirq.LineQubit(1)], allow_decompose=False)
cirq.act_on(cirq.H, args, [cirq.LineQubit(1)], allow_decompose=False)
assert args.log_of_measurement_results == {}
assert args.tableau == flipped_tableau
cirq.act_on(cirq.H, args, [cirq.LineQubit(1)], allow_decompose=False)
cirq.act_on(cirq.Z, args, [cirq.LineQubit(1)], allow_decompose=False)
cirq.act_on(cirq.H, args, [cirq.LineQubit(1)], allow_decompose=False)
assert args.log_of_measurement_results == {}
assert args.tableau == original_tableau
cirq.act_on(cirq.H, args, [cirq.LineQubit(1)], allow_decompose=False)
cirq.act_on(cirq.Z ** 3.5, args, [cirq.LineQubit(1)], allow_decompose=False)
cirq.act_on(cirq.Z ** 3.5, args, [cirq.LineQubit(1)], allow_decompose=False)
cirq.act_on(cirq.H, args, [cirq.LineQubit(1)], allow_decompose=False)
assert args.log_of_measurement_results == {}
assert args.tableau == flipped_tableau
cirq.act_on(cirq.Z ** 2, args, [cirq.LineQubit(1)], allow_decompose=False)
assert args.log_of_measurement_results == {}
assert args.tableau == flipped_tableau
cirq.act_on(cirq.H ** 2, args, [cirq.LineQubit(1)], allow_decompose=False)
assert args.log_of_measurement_results == {}
assert args.tableau == flipped_tableau
foo = sympy.Symbol('foo')
with pytest.raises(TypeError, match="Failed to act action on state"):
cirq.act_on(cirq.Z ** foo, args, [cirq.LineQubit(1)])
with pytest.raises(TypeError, match="Failed to act action on state"):
cirq.act_on(cirq.H ** foo, args, [cirq.LineQubit(1)])
with pytest.raises(TypeError, match="Failed to act action on state"):
cirq.act_on(cirq.H ** 1.5, args, [cirq.LineQubit(1)])
def test_unitary_fallback():
class UnitaryXGate(cirq.Gate):
def num_qubits(self) -> int:
return 1
def _unitary_(self):
return np.array([[0, 1], [1, 0]])
class UnitaryYGate(cirq.Gate):
def num_qubits(self) -> int:
return 1
def _unitary_(self):
return np.array([[0, -1j], [1j, 0]])
original_tableau = cirq.CliffordTableau(num_qubits=3)
args = cirq.ActOnCliffordTableauArgs(tableau=original_tableau.copy(),
axes=[1],
prng=np.random.RandomState(),
log_of_measurement_results={})
cirq.act_on(UnitaryXGate(), args)
assert args.tableau == cirq.CliffordTableau(num_qubits=3, initial_state=2)
args = cirq.ActOnCliffordTableauArgs(tableau=original_tableau.copy(),
axes=[1],
prng=np.random.RandomState(),
log_of_measurement_results={})
cirq.act_on(UnitaryYGate(), args)
expected_args = cirq.ActOnCliffordTableauArgs(
tableau=original_tableau.copy(),
axes=[1],
prng=np.random.RandomState(),
log_of_measurement_results={})
cirq.act_on(cirq.Y, expected_args)
assert args.tableau == expected_args.tableau
def test_cannot_act():
class NoDetails:
pass
args = cirq.ActOnCliffordTableauArgs(
tableau=cirq.CliffordTableau(num_qubits=3),
axes=[1],
prng=np.random.RandomState(),
log_of_measurement_results={})
with pytest.raises(TypeError, match="Failed to act"):
cirq.act_on(NoDetails(), args)
def test_act_on_clifford_tableau():
a, b = [cirq.LineQubit(3), cirq.LineQubit(1)]
m = cirq.measure(a, b, key='out', invert_mask=(True, ))
# The below assertion does not fail since it ignores non-unitary operations
cirq.testing.assert_all_implemented_act_on_effects_match_unitary(m)
args = cirq.ActOnCliffordTableauArgs(
tableau=cirq.CliffordTableau(num_qubits=5, initial_state=0),
qubits=cirq.LineQubit.range(5),
prng=np.random.RandomState(),
log_of_measurement_results={},
)
cirq.act_on(m, args)
assert args.log_of_measurement_results == {'out': [1, 0]}
args = cirq.ActOnCliffordTableauArgs(
tableau=cirq.CliffordTableau(num_qubits=5, initial_state=8),
qubits=cirq.LineQubit.range(5),
prng=np.random.RandomState(),
log_of_measurement_results={},
)
cirq.act_on(m, args)
assert args.log_of_measurement_results == {'out': [1, 1]}
args = cirq.ActOnCliffordTableauArgs(
tableau=cirq.CliffordTableau(num_qubits=5, initial_state=10),
qubits=cirq.LineQubit.range(5),
prng=np.random.RandomState(),
log_of_measurement_results={},
)
cirq.act_on(m, args)
datastore = cast(cirq.ClassicalDataDictionaryStore, args.classical_data)
out = cirq.MeasurementKey('out')
assert args.log_of_measurement_results == {'out': [0, 1]}
assert datastore.records[out] == [(0, 1)]
cirq.act_on(m, args)
assert args.log_of_measurement_results == {'out': [0, 1]}
assert datastore.records[out] == [(0, 1), (0, 1)]
def test_act_on_clifford_tableau():
a, b = cirq.LineQubit.range(2)
m = cirq.measure(a, b, key='out', invert_mask=(True, ))
# The below assertion does not fail since it ignores non-unitary operations
cirq.testing.assert_all_implemented_act_on_effects_match_unitary(m)
with pytest.raises(TypeError, match="Failed to act"):
cirq.act_on(m, object())
args = cirq.ActOnCliffordTableauArgs(
tableau=cirq.CliffordTableau(num_qubits=5, initial_state=0),
axes=[3, 1],
prng=np.random.RandomState(),
log_of_measurement_results={},
)
cirq.act_on(m, args)
assert args.log_of_measurement_results == {'out': [1, 0]}
args = cirq.ActOnCliffordTableauArgs(
tableau=cirq.CliffordTableau(num_qubits=5, initial_state=8),
axes=[3, 1],
prng=np.random.RandomState(),
log_of_measurement_results={},
)
cirq.act_on(m, args)
assert args.log_of_measurement_results == {'out': [1, 1]}
args = cirq.ActOnCliffordTableauArgs(
tableau=cirq.CliffordTableau(num_qubits=5, initial_state=10),
axes=[3, 1],
prng=np.random.RandomState(),
log_of_measurement_results={},
)
cirq.act_on(m, args)
assert args.log_of_measurement_results == {'out': [0, 1]}
with pytest.raises(ValueError, match="already logged to key"):
cirq.act_on(m, args)
def test_copy():
args = cirq.ActOnCliffordTableauArgs(
tableau=cirq.CliffordTableau(num_qubits=3),
axes=[1],
prng=np.random.RandomState(),
log_of_measurement_results={},
)
args1 = args.copy()
assert isinstance(args1, cirq.ActOnCliffordTableauArgs)
assert args is not args1
assert args.tableau is not args1.tableau
assert args.tableau == args1.tableau
assert args.axes == args1.axes
assert args.prng is args1.prng
assert args.log_of_measurement_results is not args1.log_of_measurement_results
assert args.log_of_measurement_results == args.log_of_measurement_results
def test_cz_act_on_tableau():
with pytest.raises(TypeError, match="Failed to act"):
cirq.act_on(cirq.CZ, DummyActOnArgs(), qubits=())
original_tableau = cirq.CliffordTableau(num_qubits=5, initial_state=31)
args = cirq.ActOnCliffordTableauArgs(
tableau=original_tableau.copy(),
qubits=cirq.LineQubit.range(5),
prng=np.random.RandomState(),
log_of_measurement_results={},
)
cirq.act_on(cirq.CZ, args, cirq.LineQubit.range(2), allow_decompose=False)
assert args.log_of_measurement_results == {}
assert args.tableau.stabilizers() == [
cirq.DensePauliString('ZIIII', coefficient=-1),
cirq.DensePauliString('IZIII', coefficient=-1),
cirq.DensePauliString('IIZII', coefficient=-1),
cirq.DensePauliString('IIIZI', coefficient=-1),
cirq.DensePauliString('IIIIZ', coefficient=-1),
]
assert args.tableau.destabilizers() == [
cirq.DensePauliString('XZIII', coefficient=1),
cirq.DensePauliString('ZXIII', coefficient=1),
cirq.DensePauliString('IIXII', coefficient=1),
cirq.DensePauliString('IIIXI', coefficient=1),
cirq.DensePauliString('IIIIX', coefficient=1),
]
cirq.act_on(cirq.CZ, args, cirq.LineQubit.range(2), allow_decompose=False)
assert args.log_of_measurement_results == {}
assert args.tableau == original_tableau
cirq.act_on(cirq.CZ**4,
args,
cirq.LineQubit.range(2),
allow_decompose=False)
assert args.log_of_measurement_results == {}
assert args.tableau == original_tableau
foo = sympy.Symbol('foo')
with pytest.raises(TypeError, match="Failed to act action on state"):
cirq.act_on(cirq.CZ**foo, args, cirq.LineQubit.range(2))
with pytest.raises(TypeError, match="Failed to act action on state"):
cirq.act_on(cirq.CZ**1.5, args, cirq.LineQubit.range(2))
def test_cannot_act():
class NoDetails:
pass
class NoDetailsSingleQubitGate(cirq.SingleQubitGate):
pass
args = cirq.ActOnCliffordTableauArgs(
tableau=cirq.CliffordTableau(num_qubits=3),
qubits=cirq.LineQubit.range(3),
prng=np.random.RandomState(),
log_of_measurement_results={},
)
with pytest.raises(TypeError, match="no _num_qubits_ or _qid_shape_"):
cirq.act_on(NoDetails(), args, [cirq.LineQubit(1)])
with pytest.raises(TypeError, match="Failed to act"):
cirq.act_on(NoDetailsSingleQubitGate(), args, [cirq.LineQubit(1)])
def test_cx_act_on():
with pytest.raises(TypeError, match="Failed to act"):
cirq.act_on(cirq.Y, object())
original_tableau = cirq.CliffordTableau(num_qubits=5, initial_state=31)
args = cirq.ActOnCliffordTableauArgs(
tableau=original_tableau.copy(),
axes=[0, 1],
prng=np.random.RandomState(),
log_of_measurement_results={},
)
cirq.act_on(cirq.CX, args, allow_decompose=False)
assert args.log_of_measurement_results == {}
assert (args.tableau.stabilizers() == [
cirq.DensePauliString('ZIIII', coefficient=-1),
cirq.DensePauliString('ZZIII', coefficient=-1),
cirq.DensePauliString('IIZII', coefficient=-1),
cirq.DensePauliString('IIIZI', coefficient=-1),
cirq.DensePauliString('IIIIZ', coefficient=-1)
])
assert (args.tableau.destabilizers() == [
cirq.DensePauliString('XXIII', coefficient=1),
cirq.DensePauliString('IXIII', coefficient=1),
cirq.DensePauliString('IIXII', coefficient=1),
cirq.DensePauliString('IIIXI', coefficient=1),
cirq.DensePauliString('IIIIX', coefficient=1)
])
cirq.act_on(cirq.CX, args, allow_decompose=False)
assert args.log_of_measurement_results == {}
assert args.tableau == original_tableau
cirq.act_on(cirq.CX**4, args, allow_decompose=False)
assert args.log_of_measurement_results == {}
assert args.tableau == original_tableau
foo = sympy.Symbol('foo')
with pytest.raises(TypeError, match="Failed to act action on state"):
cirq.act_on(cirq.CX**foo, args)
with pytest.raises(TypeError, match="Failed to act action on state"):
cirq.act_on(cirq.CX**1.5, args)
def test_clifford_decompose_by_unitary():
"""Validate the decomposition of random Clifford Tableau by unitary matrix.
Due to the exponential growth in dimension, it cannot validate very large number of qubits.
"""
n, num_ops = 5, 20
gate_candidate = [
cirq.X, cirq.Y, cirq.Z, cirq.H, cirq.S, cirq.CNOT, cirq.CZ
]
for seed in range(100):
prng = np.random.RandomState(seed)
t = cirq.CliffordTableau(num_qubits=n)
qubits = cirq.LineQubit.range(n)
expect_circ = cirq.Circuit()
args = cirq.ActOnCliffordTableauArgs(tableau=t,
qubits=qubits,
prng=prng,
log_of_measurement_results={})
for _ in range(num_ops):
g = prng.randint(len(gate_candidate))
indices = (prng.randint(n), ) if g < 5 else prng.choice(
n, 2, replace=False)
cirq.act_on(gate_candidate[g],
args,
qubits=[qubits[i] for i in indices],
allow_decompose=False)
expect_circ.append(
gate_candidate[g].on(*[qubits[i] for i in indices]))
ops = cirq.decompose_clifford_tableau_to_operations(
qubits, args.tableau)
circ = cirq.Circuit(ops)
circ.append(cirq.I.on_each(qubits))
expect_circ.append(cirq.I.on_each(qubits))
assert_allclose_up_to_global_phase(cirq.unitary(expect_circ),
cirq.unitary(circ),
atol=1e-7)
def test_clifford_gate_act_on_small_case():
# Note this is also covered by the `from_op_list` one, etc.
qubits = cirq.LineQubit.range(5)
args = cirq.ActOnCliffordTableauArgs(
tableau=cirq.CliffordTableau(num_qubits=5),
qubits=qubits,
prng=np.random.RandomState(),
log_of_measurement_results={},
)
expected_args = cirq.ActOnCliffordTableauArgs(
tableau=cirq.CliffordTableau(num_qubits=5),
qubits=qubits,
prng=np.random.RandomState(),
log_of_measurement_results={},
)
cirq.act_on(cirq.H,
expected_args,
qubits=[qubits[0]],
allow_decompose=False)
cirq.act_on(cirq.CliffordGate.H,
args,
qubits=[qubits[0]],
allow_decompose=False)
assert args.tableau == expected_args.tableau
cirq.act_on(cirq.CNOT,
expected_args,
qubits=[qubits[0], qubits[1]],
allow_decompose=False)
cirq.act_on(cirq.CliffordGate.CNOT,
args,
qubits=[qubits[0], qubits[1]],
allow_decompose=False)
assert args.tableau == expected_args.tableau
cirq.act_on(cirq.H,
expected_args,
qubits=[qubits[0]],
allow_decompose=False)
cirq.act_on(cirq.CliffordGate.H,
args,
qubits=[qubits[0]],
allow_decompose=False)
assert args.tableau == expected_args.tableau
cirq.act_on(cirq.S,
expected_args,
qubits=[qubits[0]],
allow_decompose=False)
cirq.act_on(cirq.CliffordGate.S,
args,
qubits=[qubits[0]],
allow_decompose=False)
assert args.tableau == expected_args.tableau
cirq.act_on(cirq.X,
expected_args,
qubits=[qubits[2]],
allow_decompose=False)
cirq.act_on(cirq.CliffordGate.X,
args,
qubits=[qubits[2]],
allow_decompose=False)
assert args.tableau == expected_args.tableau
def test_axes_deprecation():
state = cirq.CliffordTableau(num_qubits=3)
rng = np.random.RandomState()
qids = tuple(cirq.LineQubit.range(3))
log = {}
# No kwargs
with cirq.testing.assert_deprecated("axes", deadline="v0.13"):
args = cirq.ActOnCliffordTableauArgs(state, (1, ), rng, log,
qids) # type: ignore
with cirq.testing.assert_deprecated("axes", deadline="v0.13"):
assert args.axes == (1, )
assert args.prng is rng
assert args.tableau is state
assert args.log_of_measurement_results is log
assert args.qubits is qids
# kwargs no axes
with cirq.testing.assert_deprecated("axes", deadline="v0.13"):
args = cirq.ActOnCliffordTableauArgs(
state,
(1, ), # type: ignore
qubits=qids,
prng=rng,
log_of_measurement_results=log,
)
with cirq.testing.assert_deprecated("axes", deadline="v0.13"):
assert args.axes == (1, )
assert args.prng is rng
assert args.tableau is state
assert args.log_of_measurement_results is log
assert args.qubits is qids
# kwargs incl axes
with cirq.testing.assert_deprecated("axes", deadline="v0.13"):
args = cirq.ActOnCliffordTableauArgs(
state,
axes=(1, ),
qubits=qids,
prng=rng,
log_of_measurement_results=log,
)
with cirq.testing.assert_deprecated("axes", deadline="v0.13"):
assert args.axes == (1, )
assert args.prng is rng
assert args.tableau is state
assert args.log_of_measurement_results is log
assert args.qubits is qids
# All kwargs
with cirq.testing.assert_deprecated("axes", deadline="v0.13"):
args = cirq.ActOnCliffordTableauArgs(
tableau=state,
axes=(1, ),
qubits=qids,
prng=rng,
log_of_measurement_results=log,
)
with cirq.testing.assert_deprecated("axes", deadline="v0.13"):
assert args.axes == (1, )
assert args.prng is rng
assert args.tableau is state
assert args.log_of_measurement_results is log
assert args.qubits is qids
