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)