def test_generalized_amplitude_damping_channel_eq(): et = cirq.testing.EqualsTester() c = cirq.generalized_amplitude_damp(0.0, 0.0) et.make_equality_group(lambda: c) et.add_equality_group(cirq.generalized_amplitude_damp(0.1, 0.0)) et.add_equality_group(cirq.generalized_amplitude_damp(0.0, 0.1)) et.add_equality_group(cirq.generalized_amplitude_damp(0.6, 0.4)) et.add_equality_group(cirq.generalized_amplitude_damp(0.8, 0.2))
def main(): q0 = cirq.LineQubit(0) circuit = cirq.Circuit( cirq.generalized_amplitude_damp(9/25,49/625)(q0) ) print("circuit:") print(circuit) initial_state = 1 # sv_simulator = cirq.Simulator() dm_simulator = cirq.DensityMatrixSimulator() kc_simulator = cirq.KnowledgeCompilationSimulator( circuit, initial_state=initial_state ) # sv_result = sv_simulator.simulate( circuit, initial_state=initial_state ) # print("sv_result.state_vector():") # print(sv_result.state_vector()) dm_result = dm_simulator.simulate( circuit, initial_state=initial_state ) print("dm_result:") print(dm_result) kc_result = kc_simulator.simulate( circuit ) print("kc_result:") print(kc_result) np.testing.assert_almost_equal( kc_result.final_density_matrix, dm_result.final_density_matrix, decimal=4)
def test_generalized_amplitude_damping_channel_text_diagram(): a = cirq.generalized_amplitude_damp(0.1, 0.39558391) assert cirq.circuit_diagram_info( a, args=round_to_6_prec) == cirq.CircuitDiagramInfo( wire_symbols=('GAD(0.1,0.395584)', )) assert cirq.circuit_diagram_info( a, args=round_to_2_prec) == cirq.CircuitDiagramInfo( wire_symbols=('GAD(0.1,0.4)', ))
def test_generalized_amplitude_damping_channel(): d = cirq.generalized_amplitude_damp(0.1, 0.3) np.testing.assert_almost_equal( cirq.channel(d), (np.sqrt(0.1) * np.array([[1., 0.], [0., np.sqrt(1. - 0.3)]]), np.sqrt(0.1) * np.array([[0., np.sqrt(0.3)], [0., 0.]]), np.sqrt(0.9) * np.array([[np.sqrt(1. - 0.3), 0.], [0., 1.]]), np.sqrt(0.9) * np.array([[0., 0.], [np.sqrt(0.3), 0.]])))
def test_generalized_amplitude_damping_channel(): d = cirq.generalized_amplitude_damp(0.1, 0.3) np.testing.assert_almost_equal( cirq.channel(d), ( np.sqrt(0.1) * np.array([[1.0, 0.0], [0.0, np.sqrt(1.0 - 0.3)]]), np.sqrt(0.1) * np.array([[0.0, np.sqrt(0.3)], [0.0, 0.0]]), np.sqrt(0.9) * np.array([[np.sqrt(1.0 - 0.3), 0.0], [0.0, 1.0]]), np.sqrt(0.9) * np.array([[0.0, 0.0], [np.sqrt(0.3), 0.0]]), ), ) assert cirq.has_channel(d) assert not cirq.has_mixture(d)
def test_generalized_amplitude_damping_channel_eq(): a = cirq.generalized_amplitude_damp(0.0099999, 0.01) b = cirq.generalized_amplitude_damp(0.01, 0.0099999) assert cirq.approx_eq(a, b, atol=1e-2) et = cirq.testing.EqualsTester() c = cirq.generalized_amplitude_damp(0.0, 0.0) et.make_equality_group(lambda: c) et.add_equality_group(cirq.generalized_amplitude_damp(0.1, 0.0)) et.add_equality_group(cirq.generalized_amplitude_damp(0.0, 0.1)) et.add_equality_group(cirq.generalized_amplitude_damp(0.6, 0.4)) et.add_equality_group(cirq.generalized_amplitude_damp(0.8, 0.2))
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 main(): q0, q1 = cirq.LineQubit.range(2) for iteration in range(3): random_circuit = cirq.testing.random_circuit(qubits=[q0, q1], n_moments=2, op_density=0.99) print("random_circuit:") print(random_circuit) # noise = cirq.ConstantQubitNoiseModel(cirq.asymmetric_depolarize(0.2,0.3,0.4)) # mixture: size four noise not implemented # noise = cirq.ConstantQubitNoiseModel(cirq.depolarize(0.1)) # mixture: size four noise not implemented # noise = cirq.ConstantQubitNoiseModel(cirq.phase_flip(0.1)) # mixture: works well # noise = cirq.ConstantQubitNoiseModel(cirq.bit_flip(0.1)) # mixture: works well noise = cirq.ConstantQubitNoiseModel( cirq.generalized_amplitude_damp( 9 / 25, 49 / 625)) # channel: size four noise not implemented # noise = cirq.ConstantQubitNoiseModel(cirq.amplitude_damp(0.1)) # channel: # noise = cirq.ConstantQubitNoiseModel(cirq.phase_damp(0.1)) # channel: # reset? kc_simulator = cirq.KnowledgeCompilationSimulator(random_circuit, noise=noise, intermediate=True) dm_simulator = cirq.DensityMatrixSimulator(noise=noise) for initial_state in range(3): kc_result = kc_simulator.simulate(random_circuit, initial_state=initial_state) print("kc_result:") print(kc_result) dm_result = dm_simulator.simulate(random_circuit, initial_state=initial_state) print("dm_result:") print(dm_result) np.testing.assert_almost_equal(kc_result.final_density_matrix, dm_result.final_density_matrix, decimal=5)
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_generalized_amplitude_damping_channel_bigly_probability(p, gamma): with pytest.raises(ValueError, match='was greater than 1'): cirq.generalized_amplitude_damp(p, gamma)
def test_generalized_amplitude_damping_channel_negative_probability(p, gamma): with pytest.raises(ValueError, match='was less than 0'): cirq.generalized_amplitude_damp(p, gamma)
def test_generalized_amplitude_damping_str(): assert (str(cirq.generalized_amplitude_damp( 0.1, 0.3)) == 'generalized_amplitude_damp(p=0.1,gamma=0.3)')
def test_generalized_amplitude_damping_channel_text_diagram(): a = cirq.generalized_amplitude_damp(0.1, 0.3) assert (cirq.circuit_diagram_info(a) == cirq.CircuitDiagramInfo( wire_symbols=('GAD(0.1,0.3)', )))