def test_sample_sweep():
q = cirq.NamedQubit('q')
c = cirq.Circuit.from_ops(cirq.X(q),
cirq.Y(q)**sympy.Symbol('t'), cirq.measure(q))
# Unitary.
results = cirq.sample_sweep(c, cirq.Linspace('t', 0, 1, 2), repetitions=3)
assert len(results) == 2
assert results[0].histogram(key=q) == collections.Counter({1: 3})
assert results[1].histogram(key=q) == collections.Counter({0: 3})
# Overdamped.
c = cirq.Circuit.from_ops(cirq.X(q),
cirq.amplitude_damp(1).on(q),
cirq.Y(q)**sympy.Symbol('t'), cirq.measure(q))
results = cirq.sample_sweep(c, cirq.Linspace('t', 0, 1, 2), repetitions=3)
assert len(results) == 2
assert results[0].histogram(key=q) == collections.Counter({0: 3})
assert results[1].histogram(key=q) == collections.Counter({1: 3})
# Overdamped everywhere.
c = cirq.Circuit.from_ops(cirq.X(q),
cirq.Y(q)**sympy.Symbol('t'), cirq.measure(q))
results = cirq.sample_sweep(c,
cirq.Linspace('t', 0, 1, 2),
noise=cirq.ConstantQubitNoiseModel(
cirq.amplitude_damp(1)),
repetitions=3)
assert len(results) == 2
assert results[0].histogram(key=q) == collections.Counter({0: 3})
assert results[1].histogram(key=q) == collections.Counter({0: 3})
def test_channel():
class NoDetailsGate(cirq.Gate):
def num_qubits(self) -> int:
return 1
assert not cirq.has_kraus(NoDetailsGate().with_probability(0.5))
assert cirq.kraus(NoDetailsGate().with_probability(0.5), None) is None
assert cirq.kraus(cirq.X.with_probability(sympy.Symbol('x')), None) is None
assert_channel_sums_to_identity(cirq.X.with_probability(0.25))
assert_channel_sums_to_identity(cirq.bit_flip(0.75).with_probability(0.25))
assert_channel_sums_to_identity(cirq.amplitude_damp(0.75).with_probability(0.25))
m = cirq.kraus(cirq.X.with_probability(0.25))
assert len(m) == 2
np.testing.assert_allclose(
m[0],
cirq.unitary(cirq.X) * np.sqrt(0.25),
atol=1e-8,
)
np.testing.assert_allclose(
m[1],
cirq.unitary(cirq.I) * np.sqrt(0.75),
atol=1e-8,
)
m = cirq.kraus(cirq.bit_flip(0.75).with_probability(0.25))
assert len(m) == 3
np.testing.assert_allclose(
m[0],
cirq.unitary(cirq.I) * np.sqrt(0.25) * np.sqrt(0.25),
atol=1e-8,
)
np.testing.assert_allclose(
m[1],
cirq.unitary(cirq.X) * np.sqrt(0.25) * np.sqrt(0.75),
atol=1e-8,
)
np.testing.assert_allclose(
m[2],
cirq.unitary(cirq.I) * np.sqrt(0.75),
atol=1e-8,
)
m = cirq.kraus(cirq.amplitude_damp(0.75).with_probability(0.25))
assert len(m) == 3
np.testing.assert_allclose(
m[0],
np.array([[1, 0], [0, np.sqrt(1 - 0.75)]]) * np.sqrt(0.25),
atol=1e-8,
)
np.testing.assert_allclose(
m[1],
np.array([[0, np.sqrt(0.75)], [0, 0]]) * np.sqrt(0.25),
atol=1e-8,
)
np.testing.assert_allclose(
m[2],
cirq.unitary(cirq.I) * np.sqrt(0.75),
atol=1e-8,
)
def test_amplitude_damping_channel_eq():
et = cirq.testing.EqualsTester()
c = cirq.amplitude_damp(0.0)
et.make_equality_group(lambda: c)
et.add_equality_group(cirq.amplitude_damp(0.1))
et.add_equality_group(cirq.amplitude_damp(0.4))
et.add_equality_group(cirq.amplitude_damp(0.6))
et.add_equality_group(cirq.amplitude_damp(0.8))
def noisy_circuit_demo(amplitude_damp):
"""Demonstrates a noisy circuit simulation.
"""
# q = cirq.NamedQubit('q')
q = cirq.LineQubit(0)
dm_circuit = cirq.Circuit(cirq.X(q), )
dm_result = cirq.DensityMatrixSimulator(noise=cirq.ConstantQubitNoiseModel(
cirq.amplitude_damp(amplitude_damp))).simulate(program=dm_circuit)
kc_circuit = cirq.Circuit(cirq.amplitude_damp(amplitude_damp)(q), )
kc_result = cirq.KnowledgeCompilationSimulator(
kc_circuit, initial_state=1, intermediate=False).simulate(kc_circuit)
print("dm_result.final_density_matrix")
print(dm_result.final_density_matrix)
print("kc_result.final_density_matrix")
print(kc_result.final_density_matrix)
np.testing.assert_almost_equal(dm_result.final_density_matrix,
kc_result.final_density_matrix)
dm_circuit.append(cirq.measure(q, key='after_not_gate'))
kc_circuit.append(cirq.measure(q, key='after_not_gate'))
dm_results = cirq.sample(program=dm_circuit,
noise=cirq.ConstantQubitNoiseModel(
cirq.amplitude_damp(amplitude_damp)),
repetitions=10000)
kc_simulator = cirq.KnowledgeCompilationSimulator(kc_circuit,
initial_state=1,
intermediate=False)
kc_results = kc_simulator.run(kc_circuit, repetitions=10000)
print(
"~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~"
)
print("ConstantQubitNoiseModel with amplitude damping of rate",
cirq.amplitude_damp(amplitude_damp))
print(
'DENSITY_MATRIX_SIMULATOR: Sampling of qubit "q" after application of X gate:'
)
print(dm_results.histogram(key='after_not_gate'))
print(
'KNOWLEDGE_COMPILATION_SIMULATOR: Sampling of qubit "q" after application of X gate:'
)
print(kc_results.histogram(key='after_not_gate'))
print(
"~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~"
)
def noisy_moment(self, moment, system_qubits):
duration = max((op.gate.duration for op in moment.operations
if isinstance(op.gate, cirq.WaitGate)),
default=cirq.Duration())
if duration > cirq.Duration(nanos=500):
yield cirq.amplitude_damp(1).on_each(system_qubits)
yield moment
def noisy_moment(self, moment, system_qubits):
duration = max((op.gate.duration for op in moment.operations
if isinstance(op.gate, cirq.WaitGate)),
default=cirq.Duration(nanos=1))
yield cirq.amplitude_damp(
1 - 0.99**duration.total_nanos()).on_each(system_qubits)
yield moment
def test_custom_delay_sweep(experiment_type):
results = t2.t2_decay(
sampler=cirq.DensityMatrixSimulator(noise=cirq.amplitude_damp(1)),
qubit=cirq.GridQubit(0, 0),
num_points=4,
repetitions=10,
min_delay=cirq.Duration(nanos=100),
max_delay=cirq.Duration(micros=1),
experiment_type=experiment_type,
delay_sweep=cirq.Points('delay_ns',
[1.0, 10.0, 100.0, 1000.0, 10000.0]))
print(results)
assert results == cirq.experiments.T2DecayResult(
x_basis_data=pd.DataFrame(columns=['delay_ns', 0, 1],
index=range(5),
data=[
[1.0, 10, 0],
[10.0, 10, 0],
[100.0, 10, 0],
[1000.0, 10, 0],
[10000.0, 10, 0],
]),
y_basis_data=pd.DataFrame(columns=['delay_ns', 0, 1],
index=range(5),
data=[
[1.0, 10, 0],
[10.0, 10, 0],
[100.0, 10, 0],
[1000.0, 10, 0],
[10000.0, 10, 0],
]),
)
def test_all_off_results(experiment_type):
pulses = [1] if experiment_type == t2.ExperimentType.CPMG else None
results = t2.t2_decay(
sampler=cirq.DensityMatrixSimulator(noise=cirq.amplitude_damp(1)),
qubit=cirq.GridQubit(0, 0),
num_points=4,
repetitions=10,
min_delay=cirq.Duration(nanos=100),
max_delay=cirq.Duration(micros=1),
num_pulses=pulses,
experiment_type=experiment_type)
assert results == cirq.experiments.T2DecayResult(
x_basis_data=pd.DataFrame(columns=['delay_ns', 0, 1],
index=range(4),
data=[
[100.0, 10, 0],
[400.0, 10, 0],
[700.0, 10, 0],
[1000.0, 10, 0],
]),
y_basis_data=pd.DataFrame(columns=['delay_ns', 0, 1],
index=range(4),
data=[
[100.0, 10, 0],
[400.0, 10, 0],
[700.0, 10, 0],
[1000.0, 10, 0],
]),
)
def test_noise_aggregation():
q0 = cirq.LineQubit(0)
# damp_prob is set high to minimize test variance.
# Even with this setting, estimation of states and expectation values from
# noisy circuits is highly variable, so this test uses wide tolerances.
damp_prob = 0.4
circuit = cirq.Circuit(
cirq.X(q0),
cirq.amplitude_damp(gamma=damp_prob).on(q0),
)
psum1 = cirq.Z(q0)
psum2 = cirq.X(q0)
# Test expectation value aggregation over repetitions of a noisy circuit.
# Repetitions are handled in C++, so overhead costs are minimal.
qsim_simulator = qsimcirq.QSimSimulator(qsim_options={"r": 10000}, seed=1)
qsim_evs = qsim_simulator.simulate_expectation_values_sweep(
circuit, [psum1, psum2], params={}, permit_terminal_measurements=True)
assert len(qsim_evs) == 1
assert len(qsim_evs[0]) == 2
# <Z> = (-1) * (probability of |1>) + 1 * (probability of |0>)
# For damp_prob = 0.4, <Z> == -0.2
damped_zval = damp_prob - (1 - damp_prob)
expected_evs = [[damped_zval, 0]]
assert cirq.approx_eq(qsim_evs, expected_evs, atol=0.05)
def test_constant_qubit_noise():
a, b, c = cirq.LineQubit.range(3)
damp = cirq.amplitude_damp(0.5)
damp_all = cirq.ConstantQubitNoiseModel(damp)
actual = damp_all.noisy_moments(
[cirq.Moment([cirq.X(a)]), cirq.Moment()], [a, b, c])
expected = [
[
cirq.Moment([cirq.X(a)]),
cirq.Moment(
d.with_tags(ops.VirtualTag())
for d in [damp(a), damp(b), damp(c)]),
],
[
cirq.Moment(),
cirq.Moment(
d.with_tags(ops.VirtualTag())
for d in [damp(a), damp(b), damp(c)]),
],
]
assert actual == expected
cirq.testing.assert_equivalent_repr(damp_all)
with pytest.raises(ValueError, match='num_qubits'):
_ = cirq.ConstantQubitNoiseModel(cirq.CNOT**0.01)
def test_sample():
q = cirq.NamedQubit('q')
with pytest.raises(ValueError, match="no measurements"):
cirq.sample(cirq.Circuit.from_ops(cirq.X(q)))
# Unitary.
results = cirq.sample(cirq.Circuit.from_ops(cirq.X(q), cirq.measure(q)))
assert results.histogram(key=q) == collections.Counter({1: 1})
# Intermediate measurements.
results = cirq.sample(
cirq.Circuit.from_ops(
cirq.measure(q, key='drop'),
cirq.X(q),
cirq.measure(q),
))
assert results.histogram(key='drop') == collections.Counter({0: 1})
assert results.histogram(key=q) == collections.Counter({1: 1})
# Overdamped everywhere.
results = cirq.sample(cirq.Circuit.from_ops(
cirq.measure(q, key='drop'),
cirq.X(q),
cirq.measure(q),
),
noise=cirq.ConstantQubitNoiseModel(
cirq.amplitude_damp(1)))
assert results.histogram(key='drop') == collections.Counter({0: 1})
assert results.histogram(key=q) == collections.Counter({0: 1})
def test_amplitude_damping_channel():
d = cirq.amplitude_damp(0.3)
np.testing.assert_almost_equal(
cirq.channel(d), (np.array([[1., 0.], [0., np.sqrt(1. - 0.3)]]),
np.array([[0., np.sqrt(0.3)], [0., 0.]])))
assert cirq.has_channel(d)
assert not cirq.has_mixture(d)
def test_amplitude_damping_channel_text_diagram():
ad = cirq.amplitude_damp(0.38059322)
assert cirq.circuit_diagram_info(
ad, args=round_to_6_prec) == cirq.CircuitDiagramInfo(
wire_symbols=('AD(0.380593)', ))
assert cirq.circuit_diagram_info(
ad, args=round_to_2_prec) == cirq.CircuitDiagramInfo(
wire_symbols=('AD(0.38)', ))
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 noisy_circuit_demo(amplitude_damp):
"""Demonstrates a noisy circuit simulation.
"""
q = cirq.NamedQubit('q')
circuit = cirq.Circuit.from_ops(
cirq.measure(q, key='initial_state'),
cirq.X(q),
cirq.measure(q, key='after_not_gate'),
)
results = cirq.sample(program=circuit,
noise=cirq.ConstantQubitNoiseModel(
cirq.amplitude_damp(amplitude_damp)),
repetitions=100)
print("ConstantQubitNoiseModel with amplitude damping of rate",
cirq.amplitude_damp(amplitude_damp))
print('Sampling of initial state of qubit "q":')
print(results.histogram(key='initial_state'))
print('Sampling of qubit "q" after application of X gate:')
print(results.histogram(key='after_not_gate'))
def noisy_moment(self, moment, system_qubits):
duration = max(
(op.gate.duration for op in moment.operations
if isinstance(op.gate, cirq.WaitGate)),
default=cirq.Duration(nanos=0),
)
if duration > cirq.Duration(nanos=0):
# Found a wait gate in this moment.
return cirq.amplitude_damp(1 - np.exp(
-duration.total_nanos() / self.t1)).on_each(system_qubits)
return moment
def test_random_channel_has_random_behavior():
q = cirq.LineQubit(0)
s = cirq.Simulator().sample(
cirq.Circuit(cirq.X(q),
cirq.amplitude_damp(0.4).on(q), cirq.measure(q,
key='out')),
repetitions=100,
)
v = s['out'].value_counts()
assert v[0] > 1
assert v[1] > 1
def test_amplitude_damping_channel():
d = cirq.amplitude_damp(0.3)
np.testing.assert_almost_equal(
cirq.kraus(d),
(
np.array([[1.0, 0.0], [0.0, np.sqrt(1.0 - 0.3)]]),
np.array([[0.0, np.sqrt(0.3)], [0.0, 0.0]]),
),
)
assert cirq.has_kraus(d)
assert not cirq.has_mixture(d)
def test_run_decomposable_channel(dtype):
q0, q1 = cirq.LineQubit.range(2)
circuit = cirq.Circuit(
cirq.X(q0),
_TestDecomposingChannel([
cirq.amplitude_damp(0.5),
cirq.amplitude_damp(0),
]).on(q0, q1),
cirq.measure(q0),
cirq.measure(q1),
)
simulator = cirq.DensityMatrixSimulator(dtype=dtype)
result = simulator.run(circuit, repetitions=100)
np.testing.assert_equal(result.measurements['1'], [[0]] * 100)
# Test that we get at least one of each result. Probability of this test
# failing is 2 ** (-99).
q0_measurements = set(x[0] for x in result.measurements['0'].tolist())
assert q0_measurements == {0, 1}
def test_ampl_damping_error():
t1_ns = 200.0
# Create qubits and circuit
qubits = [cirq.LineQubit(0), cirq.LineQubit(1)]
circuit = cirq.Circuit(
cirq.Moment([cirq.X(qubits[0])]),
cirq.Moment([cirq.CNOT(qubits[0], qubits[1])]),
cirq.Moment([cirq.FSimGate(5 * np.pi / 2, np.pi).on_each(qubits)]),
cirq.Moment([
cirq.measure(qubits[0], key='q0'),
cirq.measure(qubits[1], key='q1')
]),
)
# Create noise model from NoiseProperties object with specified noise
prop = NoiseProperties(t1_ns=t1_ns)
noise_model = NoiseModelFromNoiseProperties(prop)
noisy_circuit = cirq.Circuit(noise_model.noisy_moments(circuit, qubits))
# Insert expected channels to circuit
expected_circuit = cirq.Circuit(
cirq.Moment([cirq.X(qubits[0])]),
cirq.Moment(
[cirq.amplitude_damp(1 - np.exp(-25.0 / t1_ns)).on_each(qubits)]),
cirq.Moment([cirq.CNOT(qubits[0], qubits[1])]),
cirq.Moment(
[cirq.amplitude_damp(1 - np.exp(-25.0 / t1_ns)).on_each(qubits)]),
cirq.Moment([cirq.FSimGate(np.pi / 2, np.pi).on_each(qubits)]),
cirq.Moment(
[cirq.amplitude_damp(1 - np.exp(-12.0 / t1_ns)).on_each(qubits)]),
cirq.Moment([
cirq.measure(qubits[0], key='q0'),
cirq.measure(qubits[1], key='q1')
]),
cirq.Moment([
cirq.amplitude_damp(1 - np.exp(-4000.0 / t1_ns)).on_each(qubits)
]),
)
assert_equivalent_op_tree(expected_circuit, noisy_circuit)
def test_final_density_matrix_noise():
a = cirq.LineQubit(0)
np.testing.assert_allclose(cirq.final_density_matrix(
[cirq.H(a), cirq.Z(a),
cirq.H(a), cirq.measure(a)]), [[0, 0], [0, 1]],
atol=1e-4)
np.testing.assert_allclose(cirq.final_density_matrix(
[cirq.H(a), cirq.Z(a),
cirq.H(a), cirq.measure(a)],
noise=cirq.ConstantQubitNoiseModel(cirq.amplitude_damp(1.0))),
[[1, 0], [0, 0]],
atol=1e-4)
def test_constant_qubit_noise():
a, b, c = cirq.LineQubit.range(3)
damp = cirq.amplitude_damp(0.5)
damp_all = cirq.ConstantQubitNoiseModel(damp)
assert damp_all.noisy_moments(
[cirq.Moment([cirq.X(a)]), cirq.Moment()],
[a, b, c]) == [[cirq.X(a), damp(a),
damp(b), damp(c)], [damp(a), damp(b),
damp(c)]]
with pytest.raises(ValueError, match='num_qubits'):
_ = cirq.ConstantQubitNoiseModel(cirq.CNOT**0.01)
def test_all_off_results():
results = cirq.experiments.t1_decay(
sampler=cirq.DensityMatrixSimulator(noise=cirq.amplitude_damp(1)),
qubit=cirq.GridQubit(0, 0),
num_points=4,
repetitions=10,
min_delay=cirq.Duration(nanos=100),
max_delay=cirq.Duration(micros=1),
)
assert results == cirq.experiments.T1DecayResult(data=pd.DataFrame(
columns=['delay_ns', 'false_count', 'true_count'],
index=range(4),
data=[[100.0, 10, 0], [400.0, 10, 0], [700.0, 10, 0], [1000.0, 10, 0]],
))
def test_amplitude_damping_channel_eq():
a = cirq.amplitude_damp(0.0099999)
b = cirq.amplitude_damp(0.01)
c = cirq.amplitude_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.amplitude_damp(0.1))
et.add_equality_group(cirq.amplitude_damp(0.4))
et.add_equality_group(cirq.amplitude_damp(0.6))
et.add_equality_group(cirq.amplitude_damp(0.8))
def test_noise_model_discrete(gamma):
results = cirq.experiments.t1_decay(
sampler=cirq.DensityMatrixSimulator(
noise=cirq.NoiseModel.from_noise_model_like(
cirq.amplitude_damp(gamma))),
qubit=cirq.GridQubit(0, 0),
num_points=4,
repetitions=100,
min_delay=cirq.Duration(nanos=100),
max_delay=cirq.Duration(micros=1),
)
data = results.data
probs = data['true_count'] / (data['true_count'] + data['false_count'])
# Check that there is no decay in probability over time
np.testing.assert_allclose(probs, np.mean(probs), atol=0.2)
def test_multiple_pulses():
results = t2.t2_decay(
sampler=cirq.DensityMatrixSimulator(noise=cirq.amplitude_damp(1)),
qubit=cirq.GridQubit(0, 0),
num_points=4,
repetitions=10,
min_delay=cirq.Duration(nanos=100),
max_delay=cirq.Duration(micros=1),
experiment_type=t2.ExperimentType.CPMG,
num_pulses=[1, 2, 3, 4],
delay_sweep=cirq.Points('delay_ns',
[1.0, 10.0, 100.0, 1000.0, 10000.0]))
data = [[1.0, 1, 10, 0], [1.0, 2, 10, 0], [1.0, 3, 10, 0], [1.0, 4, 10, 0],
[10.0, 1, 10, 0], [10.0, 2, 10, 0], [10.0, 3, 10, 0],
[10.0, 4, 10, 0], [100.0, 1, 10, 0], [100.0, 2, 10, 0],
[100.0, 3, 10, 0], [100.0, 4, 10, 0], [1000.0, 1, 10, 0],
[1000.0, 2, 10, 0], [1000.0, 3, 10, 0], [1000.0, 4, 10, 0],
[10000.0, 1, 10, 0], [10000.0, 2, 10, 0], [10000.0, 3, 10, 0],
[10000.0, 4, 10, 0]]
assert results == cirq.experiments.T2DecayResult(
x_basis_data=pd.DataFrame(
columns=['delay_ns', 'num_pulses', 0, 1],
index=range(20),
data=data,
),
y_basis_data=pd.DataFrame(
columns=['delay_ns', 'num_pulses', 0, 1],
index=range(20),
data=data,
),
)
expected = pd.DataFrame(columns=['delay_ns', 'num_pulses', 'value'],
index=range(20),
data=[[1.0, 1, -1.0], [1.0, 2, -1.0],
[1.0, 3, -1.0], [1.0, 4, -1.0],
[10.0, 1, -1.0], [10.0, 2, -1.0],
[10.0, 3, -1.0], [10.0, 4, -1.0],
[100.0, 1, -1.0], [100.0, 2, -1.0],
[100.0, 3, -1.0], [100.0, 4, -1.0],
[1000.0, 1, -1.0], [1000.0, 2, -1.0],
[1000.0, 3, -1.0], [1000.0, 4, -1.0],
[10000.0, 1, -1.0], [10000.0, 2, -1.0],
[10000.0, 3, -1.0], [10000.0, 4, -1.0]])
assert results.expectation_pauli_x.equals(expected)
def test_final_density_matrix_qubit_order():
a, b = cirq.LineQubit.range(2)
np.testing.assert_allclose(
cirq.final_density_matrix([cirq.X(a), cirq.X(b)**0.5],
qubit_order=[a, b]),
[[0, 0, 0, 0], [0, 0, 0, 0], [0, 0, 0.5, 0.5j], [0, 0, -0.5j, 0.5]])
np.testing.assert_allclose(
cirq.final_density_matrix([cirq.X(a), cirq.X(b)**0.5],
qubit_order=[b, a]),
[[0, 0, 0, 0], [0, 0.5, 0, 0.5j], [0, 0, 0, 0], [0, -0.5j, 0, 0.5]])
np.testing.assert_allclose(
cirq.final_density_matrix([cirq.X(a), cirq.X(b)**0.5],
qubit_order=[b, a],
noise=cirq.ConstantQubitNoiseModel(
cirq.amplitude_damp(1.0))),
[[1, 0, 0, 0], [0, 0, 0, 0], [0, 0, 0, 0], [0, 0, 0, 0]])
def test_channel_simulation():
q0, q1 = cirq.LineQubit.range(2)
# These probabilities are set unreasonably high in order to reduce the number
# of runs required to observe every possible operator.
amp_damp = cirq.amplitude_damp(gamma=0.5)
gen_amp_damp = cirq.generalized_amplitude_damp(p=0.4, gamma=0.6)
cirq_circuit = cirq.Circuit(
cirq.X(q0)**0.5,
cirq.X(q1)**0.5,
amp_damp.on(q0),
gen_amp_damp.on(q1),
)
possible_circuits = [
cirq.Circuit(cirq.X(q0)**0.5,
cirq.X(q1)**0.5, ad, gad)
# Extract the operators from the channels to construct trajectories.
for ad in [NoiseStep(m).on(q0) for m in cirq.channel(amp_damp)]
for gad in [NoiseStep(m).on(q1) for m in cirq.channel(gen_amp_damp)]
]
possible_states = [
cirq.Simulator().simulate(pc).state_vector()
for pc in possible_circuits
]
# Since some "gates" were non-unitary, we must normalize.
possible_states = [ps / np.linalg.norm(ps) for ps in possible_states]
# Minimize flaky tests with a fixed seed.
qsimSim = qsimcirq.QSimSimulator(seed=1)
result_hist = [0] * len(possible_states)
run_count = 200
for _ in range(run_count):
result = qsimSim.simulate(cirq_circuit, qubit_order=[q0, q1])
for i, ps in enumerate(possible_states):
if cirq.allclose_up_to_global_phase(result.state_vector(), ps):
result_hist[i] += 1
break
# Each observed result should match one of the possible_results.
assert sum(result_hist) == run_count
# Over 200 runs, it's reasonable to expect all eight outcomes.
assert all(result_count > 0 for result_count in result_hist)
def test_final_state_vector_ignore_terminal_measurement():
a, b = cirq.LineQubit.range(2)
np.testing.assert_allclose(
cirq.final_state_vector(
[cirq.X(a), cirq.X(b)**0.5,
cirq.measure(a, b, key='m')],
ignore_terminal_measurements=True,
),
[0, 0, 0.5 + 0.5j, 0.5 - 0.5j],
)
with pytest.raises(ValueError, match='is not unitary'):
_ = (cirq.final_state_vector(
[
cirq.X(a),
cirq.amplitude_damp(0.1).on(b),
cirq.measure(a, b, key='m')
],
ignore_terminal_measurements=True,
), )
def test_constant_qubit_noise_prepend():
a, b, c = cirq.LineQubit.range(3)
damp = cirq.amplitude_damp(0.5)
damp_all = cirq.ConstantQubitNoiseModel(damp, prepend=True)
actual = damp_all.noisy_moments(
[cirq.Moment([cirq.X(a)]), cirq.Moment()], [a, b, c])
expected = [
[
cirq.Moment(
d.with_tags(ops.VirtualTag())
for d in [damp(a), damp(b), damp(c)]),
cirq.Moment([cirq.X(a)]),
],
[
cirq.Moment(
d.with_tags(ops.VirtualTag())
for d in [damp(a), damp(b), damp(c)]),
cirq.Moment(),
],
]
assert actual == expected
cirq.testing.assert_equivalent_repr(damp_all)
