def test_measurement_with_bits_flipped(num_qubits, mask, bits, flipped):
gate = cirq.MeasurementGate(num_qubits,
key='a',
invert_mask=mask,
qid_shape=(3, ) * num_qubits)
gate1 = gate.with_bits_flipped(*bits)
assert gate1.key == gate.key
assert gate1.num_qubits() == gate.num_qubits()
assert gate1.invert_mask == flipped
assert cirq.qid_shape(gate1) == cirq.qid_shape(gate)
# Flipping bits again restores the mask (but may have extended it).
gate2 = gate1.with_bits_flipped(*bits)
assert gate2.full_invert_mask() == gate.full_invert_mask()
def test_density_matrix_simulator_state_qid_shape():
q0, q1 = cirq.LineQubit.range(2)
assert cirq.qid_shape(
cirq.DensityMatrixSimulatorState(density_matrix=np.ones((4, 4)) / 4,
qubit_map={
q0: 0,
q1: 1
})) == (2, 2)
q0, q1 = cirq.LineQid.for_qid_shape((3, 4))
assert cirq.qid_shape(
cirq.DensityMatrixSimulatorState(density_matrix=np.ones((12, 12)) / 12,
qubit_map={
q0: 0,
q1: 1
})) == (3, 4)
def test_gate_shape_protocol():
"""This test is only needed while the `_num_qubits_` and `_qid_shape_`
methods are implemented as alternatives. This can be removed once the
deprecated `num_qubits` method is removed."""
class NotImplementedGate1(cirq.Gate):
def _num_qubits_(self):
return NotImplemented
def _qid_shape_(self):
return NotImplemented
class NotImplementedGate2(cirq.Gate):
def _num_qubits_(self):
return NotImplemented
class NotImplementedGate3(cirq.Gate):
def _qid_shape_(self):
return NotImplemented
class ShapeGate(cirq.Gate):
def _num_qubits_(self):
return NotImplemented
def _qid_shape_(self):
return (1, 2, 3)
class QubitGate(cirq.Gate):
def _num_qubits_(self):
return 2
def _qid_shape_(self):
return NotImplemented
with pytest.raises(TypeError, match='returned NotImplemented'):
cirq.qid_shape(NotImplementedGate1())
with pytest.raises(TypeError, match='returned NotImplemented'):
cirq.num_qubits(NotImplementedGate1())
with pytest.raises(TypeError, match='returned NotImplemented'):
_ = NotImplementedGate1().num_qubits() # Deprecated
with pytest.raises(TypeError, match='returned NotImplemented'):
cirq.qid_shape(NotImplementedGate2())
with pytest.raises(TypeError, match='returned NotImplemented'):
cirq.num_qubits(NotImplementedGate2())
with pytest.raises(TypeError, match='returned NotImplemented'):
_ = NotImplementedGate2().num_qubits() # Deprecated
with pytest.raises(TypeError, match='returned NotImplemented'):
cirq.qid_shape(NotImplementedGate3())
with pytest.raises(TypeError, match='returned NotImplemented'):
cirq.num_qubits(NotImplementedGate3())
with pytest.raises(TypeError, match='returned NotImplemented'):
_ = NotImplementedGate3().num_qubits() # Deprecated
assert cirq.qid_shape(ShapeGate()) == (1, 2, 3)
assert cirq.num_qubits(ShapeGate()) == 3
assert ShapeGate().num_qubits() == 3 # Deprecated
assert cirq.qid_shape(QubitGate()) == (2, 2)
assert cirq.num_qubits(QubitGate()) == 2
assert QubitGate().num_qubits() == 2 # Deprecated
def test_init(observable, key):
g = cirq.PauliMeasurementGate(observable, key)
assert g.num_qubits() == len(observable)
assert g.key == 'a'
assert g.mkey == cirq.MeasurementKey('a')
assert g._observable == cirq.DensePauliString(observable)
assert cirq.qid_shape(g) == (2,) * len(observable)
def test_measure_init(num_qubits):
assert cirq.MeasurementGate(num_qubits).num_qubits() == num_qubits
assert cirq.MeasurementGate(num_qubits, key='a').key == 'a'
assert cirq.MeasurementGate(num_qubits,
invert_mask=(True,)).invert_mask == (True,)
assert cirq.qid_shape(cirq.MeasurementGate(num_qubits)) == (2,) * num_qubits
assert cirq.qid_shape(cirq.MeasurementGate(3, qid_shape=(1, 2,
3))) == (1, 2, 3)
assert cirq.qid_shape(cirq.MeasurementGate(qid_shape=(1, 2, 3))) == (1, 2,
3)
with pytest.raises(ValueError, match='len.* >'):
cirq.MeasurementGate(5, invert_mask=(True,) * 6)
with pytest.raises(ValueError, match='len.* !='):
cirq.MeasurementGate(5, qid_shape=(1, 2))
with pytest.raises(ValueError, match='Specify either'):
cirq.MeasurementGate()
def test_controlled_operation_init():
class G(cirq.testing.SingleQubitGate):
def _has_mixture_(self):
return True
g = G()
cb = cirq.NamedQubit('ctr')
q = cirq.NamedQubit('q')
v = cirq.GateOperation(g, (q,))
c = cirq.ControlledOperation([cb], v)
assert c.sub_operation == v
assert c.controls == (cb,)
assert c.qubits == (cb, q)
assert c == c.with_qubits(cb, q)
assert c.control_values == ((1,),)
assert cirq.qid_shape(c) == (2, 2)
c = cirq.ControlledOperation([cb], v, control_values=[0])
assert c.sub_operation == v
assert c.controls == (cb,)
assert c.qubits == (cb, q)
assert c == c.with_qubits(cb, q)
assert c.control_values == ((0,),)
assert cirq.qid_shape(c) == (2, 2)
c = cirq.ControlledOperation([cb.with_dimension(3)], v)
assert c.sub_operation == v
assert c.controls == (cb.with_dimension(3),)
assert c.qubits == (cb.with_dimension(3), q)
assert c == c.with_qubits(cb.with_dimension(3), q)
assert c.control_values == ((1,),)
assert cirq.qid_shape(c) == (3, 2)
with pytest.raises(ValueError, match=r'len\(control_values\) != len\(controls\)'):
_ = cirq.ControlledOperation([cb], v, control_values=[1, 1])
with pytest.raises(ValueError, match='Control values .*outside of range'):
_ = cirq.ControlledOperation([cb], v, control_values=[2])
with pytest.raises(ValueError, match='Control values .*outside of range'):
_ = cirq.ControlledOperation([cb], v, control_values=[(1, -1)])
with pytest.raises(ValueError, match=re.escape("Duplicate control qubits ['ctr'].")):
_ = cirq.ControlledOperation([cb, cirq.LineQubit(0), cb], cirq.X(q))
with pytest.raises(ValueError, match=re.escape("Sub-op and controls share qubits ['ctr']")):
_ = cirq.ControlledOperation([cb, cirq.LineQubit(0)], cirq.CX(cb, q))
with pytest.raises(ValueError, match='Cannot control measurement'):
_ = cirq.ControlledOperation([cb], cirq.measure(q))
with pytest.raises(ValueError, match='Cannot control channel'):
_ = cirq.ControlledOperation([cb], cirq.PhaseDampingChannel(1)(q))
def test_qid_shape():
class ShapeObj:
def _qid_shape_(self):
return (1, 2, 3)
class NumObj:
def _num_qubits_(self):
return 2
class NotImplShape:
def _qid_shape_(self):
return NotImplemented
class NotImplNum:
def _num_qubits_(self):
return NotImplemented
class NotImplBoth:
def _num_qubits_(self):
return NotImplemented
def _qid_shape_(self):
return NotImplemented
class NoProtocol:
pass
assert cirq.qid_shape(ShapeObj()) == (1, 2, 3)
assert cirq.num_qubits(ShapeObj()) == 3
assert cirq.qid_shape(NumObj()) == (2, 2)
assert cirq.num_qubits(NumObj()) == 2
with pytest.raises(TypeError, match='_qid_shape_.*NotImplemented'):
cirq.qid_shape(NotImplShape())
with pytest.raises(TypeError, match='_qid_shape_.*NotImplemented'):
cirq.num_qubits(NotImplShape())
with pytest.raises(TypeError, match='_num_qubits_.*NotImplemented'):
cirq.qid_shape(NotImplNum())
with pytest.raises(TypeError, match='_num_qubits_.*NotImplemented'):
cirq.num_qubits(NotImplNum())
with pytest.raises(TypeError, match='_qid_shape_.*NotImplemented'):
cirq.qid_shape(NotImplBoth())
with pytest.raises(TypeError, match='_num_qubits_.*NotImplemented'):
cirq.num_qubits(NotImplBoth())
with pytest.raises(TypeError):
cirq.qid_shape(NoProtocol())
with pytest.raises(TypeError):
cirq.num_qubits(NoProtocol())
def assert_channel_sums_to_identity(val):
m = cirq.kraus(val)
s = sum(np.conj(e.T) @ e for e in m)
np.testing.assert_allclose(s,
np.eye(
np.prod(cirq.qid_shape(val),
dtype=np.int64)),
atol=1e-8)
def __init__(self, sub_gate, dimension, sub_levels=None):
self.sub_gate = sub_gate
self.dimension = dimension
if sub_levels is None:
sub_levels = range(cirq.qid_shape(sub_gate)[0])
assert len(
set(sub_levels)) == len(sub_levels), 'Duplicate levels given'
self.sub_levels = list(sub_levels)
def test_gate_operation_num_qubits():
class NumQubitsGate(cirq.Gate):
def _num_qubits_(self):
return 4
op = NumQubitsGate().on(*cirq.LineQubit.range(4))
assert cirq.qid_shape(op) == (2, 2, 2, 2)
assert cirq.num_qubits(op) == 4
def test_gate_operation_qid_shape():
class ShapeGate(cirq.Gate):
def _qid_shape_(self):
return (1, 2, 3, 4)
op = ShapeGate().on(*cirq.LineQid.for_qid_shape((1, 2, 3, 4)))
assert cirq.qid_shape(op) == (1, 2, 3, 4)
assert cirq.num_qubits(op) == 4
def _base_iterator(self, circuit, qubit_order, initial_state,
perform_measurements=True):
qubits = cirq.QubitOrder.as_qubit_order(qubit_order).order_for(
circuit.all_qubits())
num_qubits = len(qubits)
qid_shape = cirq.qid_shape(qubits)
qubit_map = {q: i for i, q in enumerate(qubits)}
if isinstance(initial_state, int):
state_val = initial_state
else:
state_val = cirq.big_endian_digits_to_int(initial_state,
base=qid_shape)
state = _State.from_basis_state(state_val,
qid_shape,
path_limit=self.path_limit,
tolerance=self.tolerance)
if len(circuit) == 0:
yield FeynmanPathSimulatorStep(state, {}, qubit_map)
def on_stuck(bad_op):
return TypeError(
"Can't simulate unknown operations that don't specify a"
"unitary or a decomposition. {!r}".format(bad_op))
def keep(potential_op):
return (cirq.has_unitary(potential_op) or
cirq.has_mixture(potential_op) or
cirq.is_measurement(potential_op) or
cirq.op_gate_isinstance(potential_op, cirq.ResetChannel))
def simulate_op(op, temp_state):
indices = [qubit_map[q] for q in op.qubits]
if cirq.op_gate_isinstance(op, cirq.ResetChannel):
self._simulate_reset(op, cirq.ResetChannel)
elif cirq.is_measurement(op):
if perform_measurements:
self._simulate_measurement(
op, temp_state, indices, measurements)
elif cirq.has_mixture(op):
self._simulate_mixture(op, temp_state, indices)
else:
if cirq.num_qubits(op) <= 3:
self._simulate_unitary(op, temp_state, indices)
else:
decomp_ops = cirq.decompose_once(op, default=None)
if decomp_ops is None:
self._simulate_unitary(op, temp_state, indices)
else:
for sub_op in cirq.flatten_op_tree(decomp_ops):
simulate_op(sub_op, temp_state)
for moment in circuit:
measurements = defaultdict(list)
known_ops = cirq.decompose(moment, keep=keep,
on_stuck_raise=on_stuck)
for op in known_ops:
simulate_op(op, state)
yield FeynmanPathSimulatorStep(state, measurements, qubit_map)
def test_operation_shape():
class FixedQids(cirq.Operation):
def with_qubits(self, *new_qids):
raise NotImplementedError # coverage: ignore
class QubitOp(FixedQids):
@property
def qubits(self):
return cirq.LineQubit.range(2)
class NumQubitOp(FixedQids):
@property
def qubits(self):
return cirq.LineQubit.range(3)
def _num_qubits_(self):
return 3
class ShapeOp(FixedQids):
@property
def qubits(self):
return cirq.LineQubit.range(4)
def _qid_shape_(self):
return (1, 2, 3, 4)
qubit_op = QubitOp()
assert len(qubit_op.qubits) == 2
assert cirq.qid_shape(qubit_op) == (2, 2)
assert cirq.num_qubits(qubit_op) == 2
num_qubit_op = NumQubitOp()
assert len(num_qubit_op.qubits) == 3
assert cirq.qid_shape(num_qubit_op) == (2, 2, 2)
assert cirq.num_qubits(num_qubit_op) == 3
shape_op = ShapeOp()
assert len(shape_op.qubits) == 4
assert cirq.qid_shape(shape_op) == (1, 2, 3, 4)
assert cirq.num_qubits(shape_op) == 4
def test_reset_channel():
r = cirq.reset(cirq.LineQubit(0))
np.testing.assert_almost_equal(
cirq.channel(r),
(np.array([[1., 0.], [0., 0]]), np.array([[0., 1.], [0., 0.]])))
assert cirq.has_channel(r)
assert not cirq.has_mixture(r)
assert cirq.qid_shape(r) == (2, )
r = cirq.reset(cirq.LineQid(0, dimension=3))
np.testing.assert_almost_equal(
cirq.channel(r),
(np.array([[1, 0, 0], [0, 0, 0], [0, 0, 0]]),
np.array([[0, 1, 0], [0, 0, 0], [0, 0, 0]]),
np.array([[0, 0, 1], [0, 0, 0], [0, 0, 0]]))) # yapf: disable
assert cirq.has_channel(r)
assert not cirq.has_mixture(r)
assert cirq.qid_shape(r) == (3, )
def test_state_vector_trial_result_qid_shape():
final_simulator_state = cirq.StateVectorSimulationState(
qubits=[cirq.NamedQubit('a')], initial_state=np.array([0, 1]))
trial_result = cirq.StateVectorTrialResult(
params=cirq.ParamResolver({'s': 1}),
measurements={'m': np.array([[1]])},
final_simulator_state=final_simulator_state,
)
assert cirq.qid_shape(trial_result) == (2, )
final_simulator_state = cirq.StateVectorSimulationState(
qubits=cirq.LineQid.for_qid_shape((3, 2)),
initial_state=np.array([0, 0, 0, 0, 1, 0]))
trial_result = cirq.StateVectorTrialResult(
params=cirq.ParamResolver({'s': 1}),
measurements={'m': np.array([[2, 0]])},
final_simulator_state=final_simulator_state,
)
assert cirq.qid_shape(trial_result) == (3, 2)
def test_simulate_moment_steps(dtype):
q0, q1 = cirq.LineQubit.range(2)
circuit = cirq.Circuit(cirq.H(q0), cirq.H(q1), cirq.H(q0), cirq.H(q1))
simulator = cirq.DensityMatrixSimulator(dtype=dtype)
for i, step in enumerate(simulator.simulate_moment_steps(circuit)):
assert cirq.qid_shape(step) == (2, 2)
if i == 0:
np.testing.assert_almost_equal(step.density_matrix(), np.ones((4, 4)) / 4)
else:
np.testing.assert_almost_equal(step.density_matrix(), np.diag([1, 0, 0, 0]))
def test_default_qudit_inverse():
class TestGate(cirq.Gate):
def _qid_shape_(self):
return (1, 2, 3)
def _decompose_(self, qubits):
return (cirq.X ** 0.1).on(qubits[1])
assert cirq.qid_shape(cirq.inverse(TestGate(), None)) == (1, 2, 3)
cirq.testing.assert_has_consistent_qid_shape(cirq.inverse(TestGate()))
def _unitary_(self):
sub_shape = cirq.qid_shape(self.sub_gate)
assert sub_shape[0] == len(
self.sub_levels), ('Wrong number of levels given')
sub_u = cirq.unitary(self.sub_gate).reshape(sub_shape * 2)
u = cirq.eye_tensor((self.dimension, ), dtype=sub_u.dtype)
temp = u[self.sub_levels, :, ...].copy()
temp[:, self.sub_levels, ...] = sub_u
u[self.sub_levels, :, ...] = temp
return u
def test_single_qubit_init():
m = np.array([[1, 1j], [1j, 1]]) * np.sqrt(0.5)
x2 = cirq.MatrixGate(m)
assert cirq.has_unitary(x2)
assert np.alltrue(cirq.unitary(x2) == m)
assert cirq.qid_shape(x2) == (2, )
x2 = cirq.MatrixGate(PLUS_ONE, qid_shape=(3, ))
assert cirq.has_unitary(x2)
assert np.alltrue(cirq.unitary(x2) == PLUS_ONE)
assert cirq.qid_shape(x2) == (3, )
with pytest.raises(ValueError, match='Not a .*unitary matrix'):
cirq.MatrixGate(np.zeros((2, 2)))
with pytest.raises(ValueError, match='must be a square 2d numpy array'):
cirq.MatrixGate(cirq.eye_tensor((2, 2), dtype=float))
with pytest.raises(ValueError, match='must be a square 2d numpy array'):
cirq.MatrixGate(np.ones((3, 4)))
with pytest.raises(ValueError, match='must be a square 2d numpy array'):
cirq.MatrixGate(np.ones((2, 2, 2)))
def test_measure_init_num_qubit_agnostic():
assert cirq.qid_shape(cirq.MeasurementGate(3, 'a',
qid_shape=(1, 2, 3))) == (1, 2,
3)
assert cirq.qid_shape(cirq.MeasurementGate(key='a',
qid_shape=(1, 2, 3))) == (1, 2,
3)
with pytest.raises(ValueError, match='len.* >'):
cirq.MeasurementGate(5, 'a', invert_mask=(True, ) * 6)
with pytest.raises(ValueError, match='len.* !='):
cirq.MeasurementGate(5, 'a', qid_shape=(1, 2))
with pytest.raises(ValueError, match='valid string'):
cirq.MeasurementGate(2, qid_shape=(1, 2), key=None)
with pytest.raises(ValueError,
match='Confusion matrices have index out of bounds'):
cirq.MeasurementGate(1,
'a',
confusion_map={(1, ): np.array([[0, 1], [1, 0]])})
with pytest.raises(ValueError, match='Specify either'):
cirq.MeasurementGate()
def __init__(self, gate, new_qid_shape):
sub_qid_shape = cirq.qid_shape(gate)
if len(new_qid_shape) != len(sub_qid_shape):
raise ValueError(
f'Cannot extend gate <{gate}> to qid shape with a different '
f'length: <{new_qid_shape}>.')
if any(d1 > d2 for d1, d2 in zip(sub_qid_shape, new_qid_shape)):
raise ValueError(
f'Cannot extend gate <{gate}> to smaller qid shape: '
f'<{new_qid_shape}>.')
self.gate = gate
self.new_qid_shape = new_qid_shape
def test_density_matrix_trial_result_qid_shape():
q0, q1 = cirq.LineQubit.range(2)
assert cirq.qid_shape(
cirq.DensityMatrixTrialResult(
params=cirq.ParamResolver({}),
measurements={},
final_simulator_state=cirq.DensityMatrixSimulatorState(
density_matrix=np.ones((4, 4)) / 4, qubit_map={
q0: 0,
q1: 1
}))) == (2, 2)
q0, q1 = cirq.LineQid.for_qid_shape((3, 4))
assert cirq.qid_shape(
cirq.DensityMatrixTrialResult(
params=cirq.ParamResolver({}),
measurements={},
final_simulator_state=cirq.DensityMatrixSimulatorState(
density_matrix=np.ones((12, 12)) / 12, qubit_map={
q0: 0,
q1: 1
}))) == (3, 4)
def test_state_vector_trial_result_qid_shape():
final_simulator_state = cirq.StateVectorSimulatorState(
qubit_map={cirq.NamedQubit('a'): 0}, state_vector=np.array([0, 1]))
trial_result = cirq.StateVectorTrialResult(
params=cirq.ParamResolver({'s': 1}),
measurements={'m': np.array([[1]])},
final_simulator_state=final_simulator_state)
assert cirq.qid_shape(final_simulator_state) == (2, )
assert cirq.qid_shape(trial_result) == (2, )
q0, q1 = cirq.LineQid.for_qid_shape((2, 3))
final_simulator_state = cirq.StateVectorSimulatorState(
qubit_map={
q0: 1,
q1: 0
}, state_vector=np.array([0, 0, 0, 0, 1, 0]))
trial_result = cirq.StateVectorTrialResult(
params=cirq.ParamResolver({'s': 1}),
measurements={'m': np.array([[2, 0]])},
final_simulator_state=final_simulator_state)
assert cirq.qid_shape(final_simulator_state) == (3, 2)
assert cirq.qid_shape(trial_result) == (3, 2)
def test_act_on_args_pure_state_creation():
sim = cirq.Simulator()
qids = cirq.LineQubit.range(3)
shape = cirq.qid_shape(qids)
args = sim._create_act_on_args(1, qids)
values = list(args.values())
arg = (
values[0]
.kronecker_product(values[1])
.kronecker_product(values[2])
.transpose_to_qubit_order(qids)
)
expected = cirq.to_valid_state_vector(1, len(qids), qid_shape=shape)
np.testing.assert_allclose(arg.target_tensor, expected.reshape(shape))
def test_reset_channel():
r = cirq.reset(cirq.LineQubit(0))
np.testing.assert_almost_equal(
cirq.kraus(r),
(np.array([[1.0, 0.0], [0.0, 0]]), np.array([[0.0, 1.0], [0.0, 0.0]])))
cirq.testing.assert_consistent_channel(r)
assert not cirq.has_mixture(r)
assert cirq.num_qubits(r) == 1
assert cirq.qid_shape(r) == (2, )
r = cirq.reset(cirq.LineQid(0, dimension=3))
np.testing.assert_almost_equal(
cirq.kraus(r),
(
np.array([[1, 0, 0], [0, 0, 0], [0, 0, 0]]),
np.array([[0, 1, 0], [0, 0, 0], [0, 0, 0]]),
np.array([[0, 0, 1], [0, 0, 0], [0, 0, 0]]),
),
) # yapf: disable
cirq.testing.assert_consistent_channel(r)
assert not cirq.has_mixture(r)
assert cirq.qid_shape(r) == (3, )
def test_state_mixin():
class TestClass(cirq.StateVectorMixin):
def state_vector(self) -> np.ndarray:
return np.array([0, 0, 1, 0])
qubits = cirq.LineQubit.range(2)
test = TestClass(qubit_map={qubits[i]: i for i in range(2)})
assert test.dirac_notation() == '|10⟩'
np.testing.assert_almost_equal(test.bloch_vector_of(qubits[0]), np.array([0, 0, -1]))
np.testing.assert_almost_equal(test.density_matrix_of(qubits[0:1]), np.array([[0, 0], [0, 1]]))
assert cirq.qid_shape(TestClass({qubits[i]: 1 - i for i in range(2)})) == (2, 2)
assert cirq.qid_shape(TestClass({cirq.LineQid(i, i + 1): 2 - i for i in range(3)})) == (3, 2, 1)
assert cirq.qid_shape(TestClass(), 'no shape') == 'no shape'
with pytest.raises(ValueError, match='Qubit index out of bounds'):
_ = TestClass({qubits[0]: 1})
with pytest.raises(ValueError, match='Duplicate qubit index'):
_ = TestClass({qubits[0]: 0, qubits[1]: 0})
with pytest.raises(ValueError, match='Duplicate qubit index'):
_ = TestClass({qubits[0]: 1, qubits[1]: 1})
with pytest.raises(ValueError, match='Duplicate qubit index'):
_ = TestClass({qubits[0]: -1, qubits[1]: 1})
def test_controlled_operation_init():
cb = cirq.NamedQubit('ctr')
q = cirq.NamedQubit('q')
g = cirq.SingleQubitGate()
v = cirq.GateOperation(g, (q, ))
c = cirq.ControlledOperation([cb], v)
assert c.sub_operation == v
assert c.controls == (cb, )
assert c.qubits == (cb, q)
assert c == c.with_qubits(cb, q)
assert c.control_values == ((1, ), )
assert cirq.qid_shape(c) == (2, 2)
c = cirq.ControlledOperation([cb], v, control_values=[0])
assert c.sub_operation == v
assert c.controls == (cb, )
assert c.qubits == (cb, q)
assert c == c.with_qubits(cb, q)
assert c.control_values == ((0, ), )
assert cirq.qid_shape(c) == (2, 2)
c = cirq.ControlledOperation([cb.with_dimension(3)], v)
assert c.sub_operation == v
assert c.controls == (cb.with_dimension(3), )
assert c.qubits == (cb.with_dimension(3), q)
assert c == c.with_qubits(cb.with_dimension(3), q)
assert c.control_values == ((1, ), )
assert cirq.qid_shape(c) == (3, 2)
with pytest.raises(ValueError,
match=r'len\(control_values\) != len\(controls\)'):
_ = cirq.ControlledOperation([cb], v, control_values=[1, 1])
with pytest.raises(ValueError, match='Control values .*outside of range'):
_ = cirq.ControlledOperation([cb], v, control_values=[2])
with pytest.raises(ValueError, match='Control values .*outside of range'):
_ = cirq.ControlledOperation([cb], v, control_values=[(1, -1)])
def test_simulate_moment_steps_qudits(dtype):
q0, q1 = cirq.LineQid.for_qid_shape((2, 3))
circuit = cirq.Circuit(
PlusGate(2, 1)(q0),
PlusGate(3, 1)(q1),
cirq.reset(q1),
PlusGate(3, 1)(q1),
)
simulator = cirq.DensityMatrixSimulator(dtype=dtype)
for i, step in enumerate(simulator.simulate_moment_steps(circuit)):
assert cirq.qid_shape(step) == (2, 3)
if i == 0:
np.testing.assert_almost_equal(step.density_matrix(), np.diag([0, 0, 0, 0, 1, 0]))
elif i == 1:
np.testing.assert_almost_equal(step.density_matrix(), np.diag([0, 0, 0, 1, 0, 0]))
else:
np.testing.assert_almost_equal(step.density_matrix(), np.diag([0, 0, 0, 0, 1, 0]))
def test_measure_init(num_qubits):
assert cirq.MeasurementGate(num_qubits, 'a').num_qubits() == num_qubits
assert cirq.MeasurementGate(num_qubits, key='a').key == 'a'
assert cirq.MeasurementGate(num_qubits,
key='a').mkey == cirq.MeasurementKey('a')
assert cirq.MeasurementGate(num_qubits,
key=cirq.MeasurementKey('a')).key == 'a'
assert cirq.MeasurementGate(
num_qubits,
key=cirq.MeasurementKey('a')) == cirq.MeasurementGate(num_qubits,
key='a')
assert cirq.MeasurementGate(num_qubits, 'a',
invert_mask=(True, )).invert_mask == (True, )
assert cirq.qid_shape(cirq.MeasurementGate(num_qubits,
'a')) == (2, ) * num_qubits
cmap = {(0, ): np.array([[0, 1], [1, 0]])}
assert cirq.MeasurementGate(num_qubits, 'a',
confusion_map=cmap).confusion_map == cmap
def _qid_shape_(self) -> Tuple[int, ...]:
return self.control_qid_shape + cirq.qid_shape(self.sub_gate)
