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)