def test_dephase(): q0, q1 = cirq.LineQubit.range(2) circuit = cirq.Circuit( cirq.CircuitOperation( cirq.FrozenCircuit( cirq.CX(q1, q0), cirq.measure(q0, key='a'), cirq.CX(q0, q1), cirq.measure(q1, key='b'), ))) assert_equivalent_to_dephased(circuit) dephased = cirq.dephase_measurements(circuit) cirq.testing.assert_same_circuits( dephased, cirq.Circuit( cirq.CircuitOperation( cirq.FrozenCircuit( cirq.CX(q1, q0), cirq.KrausChannel.from_channel(cirq.phase_damp(1), key='a')(q0), cirq.CX(q0, q1), cirq.KrausChannel.from_channel(cirq.phase_damp(1), key='b')(q1), ))), )
def test_phase_damping_channel_eq(): et = cirq.testing.EqualsTester() c = cirq.phase_damp(0.0) et.make_equality_group(lambda: c) et.add_equality_group(cirq.phase_damp(0.1)) et.add_equality_group(cirq.phase_damp(0.4)) et.add_equality_group(cirq.phase_damp(0.6)) et.add_equality_group(cirq.phase_damp(0.8))
def test_phase_damping_channel(): d = cirq.phase_damp(0.3) np.testing.assert_almost_equal( cirq.channel(d), (np.array([[1.0, 0.], [0., np.sqrt(1 - 0.3)]]), np.array([[0., 0.], [0., np.sqrt(0.3)]]))) assert cirq.has_channel(d) assert not cirq.has_mixture(d)
def test_dephase_nocompile_context(): q0, q1 = cirq.LineQubit.range(2) circuit = cirq.Circuit( cirq.CircuitOperation( cirq.FrozenCircuit( cirq.CX(q1, q0), cirq.measure(q0, key='a').with_tags('nocompile'), cirq.CX(q0, q1), cirq.measure(q1, key='b'), ))) dephased = cirq.dephase_measurements( circuit, context=cirq.TransformerContext(tags_to_ignore=('nocompile', ))) cirq.testing.assert_same_circuits( dephased, cirq.Circuit( cirq.CircuitOperation( cirq.FrozenCircuit( cirq.CX(q1, q0), cirq.measure(q0, key='a').with_tags('nocompile'), cirq.CX(q0, q1), cirq.KrausChannel.from_channel(cirq.phase_damp(1), key='b')(q1), ))), )
def test_run_non_unitary_circuit_non_unitary_state(): class DensityCountingSimulator(CountingSimulator): def _can_be_in_run_prefix(self, val): return not cirq.is_measurement(val) sim = DensityCountingSimulator() r = sim.run(cirq.Circuit(cirq.phase_damp(1).on(q0), cirq.measure(q0)), repetitions=2) assert np.allclose(r.measurements['q(0)'], [[1], [1]])
def test_phase_damping_channel_text_diagram(): pd = cirq.phase_damp(0.1000009) assert cirq.circuit_diagram_info( pd, args=round_to_6_prec) == cirq.CircuitDiagramInfo( wire_symbols=('PD(0.100001)', )) assert cirq.circuit_diagram_info( pd, args=round_to_2_prec) == cirq.CircuitDiagramInfo( wire_symbols=('PD(0.1)', ))
def test_tensor_density_matrix_noise_1(): q = cirq.LineQubit.range(2) c = cirq.Circuit( cirq.YPowGate(exponent=0.25).on(q[0]), cirq.amplitude_damp(1e-2).on(q[0]), cirq.phase_damp(1e-3).on(q[0])) rho1 = cirq.final_density_matrix(c, qubit_order=q, dtype=np.complex128) rho2 = ccq.tensor_density_matrix(c, q) np.testing.assert_allclose(rho1, rho2, atol=1e-15)
def test_phase_damping_channel(): d = cirq.phase_damp(0.3) np.testing.assert_almost_equal( cirq.kraus(d), ( np.array([[1.0, 0.0], [0.0, np.sqrt(1 - 0.3)]]), np.array([[0.0, 0.0], [0.0, np.sqrt(0.3)]]), ), ) cirq.testing.assert_consistent_channel(d) assert not cirq.has_mixture(d)
def test_mapped_circuit_keeps_keys_under_parent_path(): q = cirq.LineQubit(0) op1 = cirq.CircuitOperation( cirq.FrozenCircuit( cirq.measure(q, key='A'), cirq.measure_single_paulistring(cirq.X(q), key='B'), cirq.MixedUnitaryChannel.from_mixture(cirq.bit_flip(0.5), key='C').on(q), cirq.KrausChannel.from_channel(cirq.phase_damp(0.5), key='D').on(q), ) ) op2 = op1.with_key_path(('X',)) assert cirq.measurement_key_names(op2.mapped_circuit()) == {'X:A', 'X:B', 'X:C', 'X:D'}
def test_phase_damping_channel_eq(): a = cirq.phase_damp(0.0099999) b = cirq.phase_damp(0.01) c = cirq.phase_damp(0.0) assert cirq.approx_eq(a, b, atol=1e-2) et = cirq.testing.EqualsTester() et.make_equality_group(lambda: c) et.add_equality_group(cirq.phase_damp(0.1)) et.add_equality_group(cirq.phase_damp(0.4)) et.add_equality_group(cirq.phase_damp(0.6)) et.add_equality_group(cirq.phase_damp(0.8))
def _get_noise_proto_pairs(): q0 = cirq.GridQubit(0, 0) pairs = [ # Depolarization. (cirq.Circuit(cirq.depolarize(p=0.3)(q0)), _build_op_proto("DP", ['p'], [0.3], ['0_0'])), # Asymmetric depolarization. (cirq.Circuit( cirq.asymmetric_depolarize(p_x=0.1, p_y=0.2, p_z=0.3)(q0)), _build_op_proto("ADP", ['p_x', 'p_y', 'p_z'], [0.1, 0.2, 0.3], ['0_0'])), # Generalized Amplitude damp. (cirq.Circuit(cirq.generalized_amplitude_damp(p=0.1, gamma=0.2)(q0)), _build_op_proto("GAD", ['p', 'gamma'], [0.1, 0.2], ['0_0'])), # Amplitude damp. (cirq.Circuit(cirq.amplitude_damp(gamma=0.1)(q0)), _build_op_proto("AD", ['gamma'], [0.1], ['0_0'])), # Reset. (cirq.Circuit(cirq.reset(q0)), _build_op_proto("RST", [], [], ['0_0'])), # Phase damp. (cirq.Circuit(cirq.phase_damp(gamma=0.1)(q0)), _build_op_proto("PD", ['gamma'], [0.1], ['0_0'])), # Phase flip. (cirq.Circuit(cirq.phase_flip(p=0.1)(q0)), _build_op_proto("PF", ['p'], [0.1], ['0_0'])), # Bit flip. (cirq.Circuit(cirq.bit_flip(p=0.1)(q0)), _build_op_proto("BF", ['p'], [0.1], ['0_0'])) ] return pairs
def test_choi_for_completely_dephasing_channel(): """Checks cirq.operation_to_choi on the completely dephasing channel.""" assert np.all(cirq.operation_to_choi(cirq.phase_damp(1)) == np.diag([1, 0, 0, 1]))
def test_phase_damping_channel_invalid_probability(): with pytest.raises(ValueError, match='was less than 0'): cirq.phase_damp(-0.1) with pytest.raises(ValueError, match='was greater than 1'): cirq.phase_damp(1.1)
def test_run_no_reuse_buffer_warning(): # coverage: ignore class MockCountingActOnArgs(CountingActOnArgs): def copy(self) -> 'MockCountingActOnArgs': # type: ignore return super().copy() # type: ignore # coverage: ignore class MockCountingStepResult(cirq.StepResultBase[MockCountingActOnArgs, MockCountingActOnArgs]): def sample( self, qubits: List[cirq.Qid], repetitions: int = 1, seed: cirq.RANDOM_STATE_OR_SEED_LIKE = None, ) -> np.ndarray: measurements: List[List[int]] = [] for _ in range(repetitions): measurements.append( self._merged_sim_state._perform_measurement(qubits)) return np.array(measurements, dtype=int) def _simulator_state(self) -> MockCountingActOnArgs: return self._merged_sim_state class MockCountingTrialResult( cirq.SimulationTrialResultBase[MockCountingActOnArgs, MockCountingActOnArgs]): pass # coverage: ignore class MockCountingSimulator(cirq.SimulatorBase[MockCountingStepResult, MockCountingTrialResult, MockCountingActOnArgs, MockCountingActOnArgs, ]): def _create_partial_act_on_args( self, initial_state: Any, qubits: Sequence['cirq.Qid'], logs: Dict[str, Any], ) -> MockCountingActOnArgs: return MockCountingActOnArgs(qubits=qubits, state=initial_state, logs=logs) def _create_simulator_trial_result( self, params: cirq.ParamResolver, measurements: Dict[str, np.ndarray], final_step_result: MockCountingStepResult, ) -> MockCountingTrialResult: return MockCountingTrialResult(params, measurements, final_step_result=final_step_result) def _create_step_result( self, sim_state: cirq.OperationTarget[MockCountingActOnArgs], ) -> MockCountingStepResult: return MockCountingStepResult(sim_state) sim = MockCountingSimulator() with cirq.testing.assert_deprecated('deep_copy_buffers', deadline='0.15'): sim.run(cirq.Circuit(cirq.phase_damp(1).on(q0), cirq.measure(q0)))
def test_phase_damping_channel_str(): assert str(cirq.phase_damp(0.3)) == 'phase_damp(gamma=0.3)'
def test_run_non_unitary_circuit(): sim = CountingSimulator() r = sim.run(cirq.Circuit(cirq.phase_damp(1).on(q0), cirq.measure(q0)), repetitions=2) assert np.allclose(r.measurements['q(0)'], [[1], [1]])
def _base_iterator(self, circuit: circuits.Circuit, qubit_order: ops.QubitOrderOrList, initial_state: Union[int, np.ndarray], perform_measurements: bool = True) -> Iterator: qubits = ops.QubitOrder.as_qubit_order(qubit_order).order_for( circuit.all_qubits()) qid_shape = protocols.qid_shape(qubits) qubit_map = {q: i for i, q in enumerate(qubits)} initial_matrix = density_matrix_utils.to_valid_density_matrix( initial_state, len(qid_shape), qid_shape=qid_shape, dtype=self._dtype) if len(circuit) == 0: yield DensityMatrixStepResult(initial_matrix, {}, qubit_map, self._dtype) return state = _StateAndBuffers(len(qid_shape), initial_matrix.reshape(qid_shape * 2)) def on_stuck(bad_op: ops.Operation): return TypeError( "Can't simulate operations that don't implement " "SupportsUnitary, SupportsConsistentApplyUnitary, " "SupportsMixture, SupportsChannel or is a measurement: {!r}". format(bad_op)) def keep(potential_op: ops.Operation) -> bool: return (protocols.has_channel(potential_op) or isinstance(potential_op.gate, ops.MeasurementGate)) noisy_moments = self.noise.noisy_moments(circuit, sorted(circuit.all_qubits())) for moment in noisy_moments: measurements = collections.defaultdict( list) # type: Dict[str, List[int]] channel_ops_and_measurements = protocols.decompose( moment, keep=keep, on_stuck_raise=on_stuck) for op in channel_ops_and_measurements: indices = [qubit_map[qubit] for qubit in op.qubits] # TODO: support more general measurements. if isinstance(op.gate, ops.MeasurementGate): meas = op.gate if perform_measurements: if self._ignore_measurement_results: for i, q in enumerate(op.qubits): self._apply_op_channel( cirq.phase_damp(1).on(q), state, [indices[i]]) else: invert_mask = meas.full_invert_mask() # Measure updates inline. bits, _ = ( density_matrix_utils.measure_density_matrix( state.tensor, indices, qid_shape=qid_shape, out=state.tensor, seed=self._prng)) corrected = [ bit ^ (bit < 2 and mask) for bit, mask in zip(bits, invert_mask) ] key = protocols.measurement_key(meas) measurements[key].extend(corrected) else: # TODO: Use apply_channel similar to apply_unitary. self._apply_op_channel(op, state, indices) yield DensityMatrixStepResult(density_matrix=state.tensor, measurements=measurements, qubit_map=qubit_map, dtype=self._dtype)
def test_choi_to_kraus_atol(): """Verifies that insignificant Kraus operators are omitted.""" choi = cirq.kraus_to_choi(cirq.kraus(cirq.phase_damp(1e-6))) assert len(cirq.choi_to_kraus(choi, atol=1e-2)) == 1 assert len(cirq.choi_to_kraus(choi, atol=1e-4)) == 2
def test_phase_damping_channel_text_diagram(): assert (cirq.circuit_diagram_info( cirq.phase_damp(0.3)) == cirq.CircuitDiagramInfo( wire_symbols=('PD(0.3)', )))
def test_superoperator_to_kraus_atol(): """Verifies that insignificant Kraus operators are omitted.""" superop = cirq.kraus_to_superoperator(cirq.kraus(cirq.phase_damp(1e-6))) assert len(cirq.superoperator_to_kraus(superop, atol=1e-2)) == 1 assert len(cirq.superoperator_to_kraus(superop, atol=1e-4)) == 2