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
