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_noise_composition(): # Verify that noise models can be composed without regard to ordering, as # long as the noise operators commute with one another. a, b, c = cirq.LineQubit.range(3) noise_z = cirq.ConstantQubitNoiseModel(cirq.Z) noise_inv_s = cirq.ConstantQubitNoiseModel(cirq.S**-1) base_moments = [ cirq.Moment([cirq.X(a)]), cirq.Moment([cirq.Y(b)]), cirq.Moment([cirq.H(c)]) ] circuit_z = cirq.Circuit(noise_z.noisy_moments(base_moments, [a, b, c])) circuit_s = cirq.Circuit(noise_inv_s.noisy_moments(base_moments, [a, b, c])) actual_zs = cirq.Circuit( noise_inv_s.noisy_moments(circuit_z.moments, [a, b, c])) actual_sz = cirq.Circuit( noise_z.noisy_moments(circuit_s.moments, [a, b, c])) expected_circuit = cirq.Circuit( cirq.Moment([cirq.X(a)]), cirq.Moment([cirq.S(a), cirq.S(b), cirq.S(c)]), cirq.Moment([cirq.Y(b)]), cirq.Moment([cirq.S(a), cirq.S(b), cirq.S(c)]), cirq.Moment([cirq.H(c)]), cirq.Moment([cirq.S(a), cirq.S(b), cirq.S(c)]), ) # All of the gates will be the same, just out of order. Merging fixes this. actual_zs = cirq.merge_single_qubit_gates_to_phased_x_and_z(actual_zs) actual_sz = cirq.merge_single_qubit_gates_to_phased_x_and_z(actual_sz) expected_circuit = cirq.merge_single_qubit_gates_to_phased_x_and_z( expected_circuit) assert_equivalent_op_tree(actual_zs, actual_sz) assert_equivalent_op_tree(actual_zs, expected_circuit)
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 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 introduce_noise_type( op_tree: cirq.OP_TREE, noise_func: Callable[[], List[cirq.Gate]]) -> cirq.OP_TREE: result = [] for op_list in op_tree: for gate_op in op_list: noise_list = noise_func( ) # Create random noise operation per gate operation new_gate_list = [gate_op] for noise_op in noise_list: noise_model = cirq.ConstantQubitNoiseModel(noise_op) # Check if evaluated gate is no virtual noise moment if isinstance( new_gate_list[0], cirq.Moment) and noise_model.is_virtual_moment( new_gate_list[0]): continue # Handle obscure noisy_operation function output new_moment_list = noise_model.noisy_operation( operation=new_gate_list[0]) new_gate_list.append( new_moment_list[1] ) # Collects the added noise moment after gate operation # Append to new moment result.append(new_gate_list) result = [val for sublist in result for val in sublist] # Flatten list of list of cirq.Moments return result
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_svg_noise(): noise_model = cirq.ConstantQubitNoiseModel(cirq.DepolarizingChannel(p=1e-3)) q = cirq.LineQubit(0) circuit = cirq.Circuit(cirq.X(q)) circuit = cirq.Circuit(noise_model.noisy_moments(circuit.moments, [q])) svg = circuit_to_svg(circuit) assert '>D(0.001)</text>' in svg
def objective_function_monte_carlo(self, u_params): U = U4(u_params) V = self.get_env(U) assert abs( full_tomography_env_objective_function(FullStateTensor(U), FullEnvironment(V))) < 1e-6 qbs = cirq.LineQubit.range(4) C = cirq.Circuit().from_ops( cirq.decompose( State(FullStateTensor(U), FullEnvironment(V), 2)(*qbs))) noise = cirq.ConstantQubitNoiseModel( cirq.depolarize(self.depolarizing_prob)) system_qubits = sorted(C.all_qubits()) noisy_circuit = cirq.Circuit() for moment in C: noisy_circuit.append(noise.noisy_moment(moment, system_qubits)) sim = cirq.Simulator() ψ = sim.simulate(noisy_circuit).final_state H = kron(kron(eye(2), self.H), eye(2)) f = real(ψ.conj().T @ H @ ψ) #sim = cirq.DensityMatrixSimulator(noise=noise) #ρ = sim.simulate(noisy_circuit).final_density_matrix #f = real(trace(ρ@H)) return f
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 main(*, num_qubits: int, depth: int, num_circuits: int, seed: int, routes: int): """Run the quantum volume algorithm with a preset configuration. See the calculate_quantum_volume documentation for more details. Args: num_qubits: Pass-through to calculate_quantum_volume. depth: Pass-through to calculate_quantum_volume num_circuits: Pass-through to calculate_quantum_volume seed: Pass-through to calculate_quantum_volume Returns: Pass-through from calculate_quantum_volume. """ device = cirq.google.Bristlecone compiler = lambda circuit: cirq.google.optimized_for_xmon( circuit=circuit, new_device=device) noisy = cirq.DensityMatrixSimulator(noise=cirq.ConstantQubitNoiseModel( qubit_noise_gate=cirq.DepolarizingChannel(p=0.005))) calculate_quantum_volume(num_qubits=num_qubits, depth=depth, num_circuits=num_circuits, random_state=seed, device_or_qubits=device, samplers=[cirq.Simulator(), noisy], routing_attempts=routes, compiler=compiler)
def objective_function_monte_carlo(self, u_params): U = self.state_tensor(self.D, u_params) V = FullEnvironment(get_env_exact(cirq.unitary(U))) # for testing qbs = cirq.LineQubit.range(int(2 * np.log2(self.D) + 2)) C = cirq.Circuit().from_ops(cirq.decompose(State(U, V, 2)(*qbs))) noise = cirq.ConstantQubitNoiseModel( cirq.depolarize(self.depolarizing_prob)) system_qubits = sorted(C.all_qubits()) noisy_circuit = cirq.Circuit() for moment in C: noisy_circuit.append(noise.noisy_moment(moment, system_qubits)) sim = cirq.Simulator() ψ = sim.simulate(noisy_circuit).final_state H = kron(kron(eye(self.D), self.H), eye(self.D)) f = real(ψ.conj().T @ H @ ψ) #sim = cirq.DensityMatrixSimulator(noise=noise) #ρ = sim.simulate(noisy_circuit).final_density_matrix #f = real(trace(ρ@H)) return f
def test_tensor_density_matrix_4(): qubits = cirq.LineQubit.range(4) circuit = cirq.testing.random_circuit(qubits=qubits, n_moments=100, op_density=0.8) cirq.DropEmptyMoments().optimize_circuit(circuit) noise_model = cirq.ConstantQubitNoiseModel(cirq.DepolarizingChannel(p=1e-3)) circuit = cirq.Circuit(noise_model.noisy_moments(circuit.moments, qubits)) rho1 = cirq.final_density_matrix(circuit, dtype=np.complex128) rho2 = ccq.tensor_density_matrix(circuit, qubits) np.testing.assert_allclose(rho1, rho2, atol=1e-8)
def test_tensor_density_matrix_gridqubit(): qubits = cirq.GridQubit.rect(2, 2) circuit = cirq.testing.random_circuit(qubits=qubits, n_moments=10, op_density=0.8) circuit = cirq.drop_empty_moments(circuit) noise_model = cirq.ConstantQubitNoiseModel(cirq.DepolarizingChannel(p=1e-3)) circuit = cirq.Circuit(noise_model.noisy_moments(circuit.moments, qubits)) rho1 = cirq.final_density_matrix(circuit, dtype=np.complex128) rho2 = ccq.tensor_density_matrix(circuit, qubits) np.testing.assert_allclose(rho1, rho2, atol=1e-8)
def syc23_noisy(state): return qb.CirqBoard( state, sampler=cirq.DensityMatrixSimulator(noise=cirq.ConstantQubitNoiseModel( qubit_noise_gate=cirq.DepolarizingChannel(0.005)), seed=get_seed()), device=utils.get_device_obj_by_name('Syc23-simulator'), error_mitigation=enums.ErrorMitigation.Correct, noise_mitigation=0.10)
def test_nondeterministic_mixture_noise(): q = cirq.LineQubit(0) circuit = cirq.Circuit(cirq.I(q), cirq.measure(q)) simulator = cirq.Simulator(noise=cirq.ConstantQubitNoiseModel(cirq.depolarize(0.5))) result1 = simulator.run(circuit, repetitions=50) result2 = simulator.run(circuit, repetitions=50) assert result1 != result2
def main(): circuit, qubits = build_circuit() circuit.append(cirq.measure(*qubits, key='y')) noise = cirq.ConstantQubitNoiseModel(cirq.depolarize(0.1)) estimated_fidelity = direct_fidelity_estimation(circuit, qubits, noise, n_trials=10) print(estimated_fidelity)
def test_wrap(): class Forget(cirq.NoiseModel): def noisy_operation(self, operation): raise NotImplementedError() forget = Forget() assert cirq.NoiseModel.from_noise_model_like(None) is cirq.NO_NOISE assert cirq.NoiseModel.from_noise_model_like( cirq.depolarize(0.1)) == cirq.ConstantQubitNoiseModel( cirq.depolarize(0.1)) assert cirq.NoiseModel.from_noise_model_like( cirq.Z**0.01) == cirq.ConstantQubitNoiseModel(cirq.Z**0.01) assert cirq.NoiseModel.from_noise_model_like(forget) is forget with pytest.raises(TypeError, match='Expected a NOISE_MODEL_LIKE'): _ = cirq.NoiseModel.from_noise_model_like('test') with pytest.raises(ValueError, match='Multi-qubit gate'): _ = cirq.NoiseModel.from_noise_model_like(cirq.CZ**0.01)
def test_direct_fidelity_estimation(): qubits = cirq.LineQubit.range(3) circuit = cirq.Circuit( cirq.Z(qubits[0])**0.25, # T-Gate, non Clifford. cirq.X(qubits[1])**0.123, cirq.X(qubits[2])**0.456) noise = cirq.ConstantQubitNoiseModel(cirq.depolarize(0.1)) estimated_fidelity = direct_fidelity_estimation.direct_fidelity_estimation( circuit, qubits, noise, n_trials=10) assert estimated_fidelity >= -1.0 and estimated_fidelity <= 1.0
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 main(*, n_measured_operators: Optional[int], samples_per_term: int): circuit, qubits = build_circuit() noise = cirq.ConstantQubitNoiseModel(cirq.depolarize(0.1)) print('Noise model: %s' % (noise)) noisy_simulator = cirq.DensityMatrixSimulator(noise=noise) estimated_fidelity, _ = direct_fidelity_estimation( circuit, qubits, noisy_simulator, n_measured_operators=n_measured_operators, samples_per_term=samples_per_term) print('Estimated fidelity: %f' % (estimated_fidelity))
def main(*, n_trials: int, samples_per_term: int): circuit, qubits = build_circuit() circuit.append(cirq.measure(*qubits, key='y')) noise = cirq.ConstantQubitNoiseModel(cirq.depolarize(0.1)) print('Noise model: %s' % (noise)) estimated_fidelity = direct_fidelity_estimation( circuit, qubits, noise, n_trials=n_trials, samples_per_term=samples_per_term) print('Estimated fidelity: %f' % (estimated_fidelity))
def test_direct_fidelity_estimation_with_noise_clifford(): qubits = cirq.LineQubit.range(3) circuit = cirq.Circuit(cirq.Z(qubits[0]), cirq.X(qubits[1]), cirq.X(qubits[2])) noise = cirq.ConstantQubitNoiseModel(cirq.depolarize(0.1)) noisy_simulator = cirq.DensityMatrixSimulator(noise=noise) estimated_fidelity, _ = dfe.direct_fidelity_estimation( circuit, qubits, noisy_simulator, n_measured_operators=None, samples_per_term=100) assert estimated_fidelity >= -1.0 and estimated_fidelity <= 1.0
def main(*, n_trials: int, n_clifford_trials: int, samples_per_term: int): circuit, qubits = build_circuit() noise = cirq.ConstantQubitNoiseModel(cirq.depolarize(0.1)) print('Noise model: %s' % (noise)) noisy_simulator = cirq.DensityMatrixSimulator(noise=noise) estimated_fidelity = direct_fidelity_estimation( circuit, qubits, noisy_simulator, n_trials=n_trials, n_clifford_trials=n_clifford_trials, samples_per_term=samples_per_term) print('Estimated fidelity: %f' % (estimated_fidelity))
def get_sampler(self, ) -> 'cirq.Sampler': """Return a local `cirq.Sampler` based on the `noise_strength` attribute. If `self.noise_strength` is `0` return a noiseless state-vector simulator. If it's set to `float('inf')` the simulator will be `cirq.ZerosSampler`. Otherwise, we return a density matrix simulator with a depolarizing model with `noise_strength` probability of noise. """ if self.noise_strength == 0: return cirq.Simulator() if self.noise_strength == float('inf'): return cirq.ZerosSampler() return cirq.DensityMatrixSimulator(noise=cirq.ConstantQubitNoiseModel( cirq.depolarize(p=self.noise_strength)))
def test_direct_fidelity_estimation_no_noise_non_clifford(): qubits = cirq.LineQubit.range(3) circuit = cirq.Circuit( cirq.Z(qubits[0])**0.123, cirq.X(qubits[1]), cirq.X(qubits[2])) no_noise = cirq.ConstantQubitNoiseModel(cirq.depolarize(0.0)) estimated_fidelity = direct_fidelity_estimation.direct_fidelity_estimation( circuit, qubits, no_noise, n_trials=100, n_clifford_trials=3, samples_per_term=0) assert np.isclose(estimated_fidelity, 1.0, atol=0.01)
def test_direct_fidelity_estimation_no_noise_clifford(): qubits = cirq.LineQubit.range(3) circuit = cirq.Circuit(cirq.Z(qubits[0]), cirq.X(qubits[1]), cirq.X(qubits[2])) no_noise = cirq.ConstantQubitNoiseModel(cirq.depolarize(0.0)) no_noise_simulator = cirq.DensityMatrixSimulator(noise=no_noise) estimated_fidelity, _ = dfe.direct_fidelity_estimation(circuit, qubits, no_noise_simulator, n_trials=100, n_clifford_trials=3, samples_per_term=0) assert np.isclose(estimated_fidelity, 1.0, atol=0.01)
def test_direct_fidelity_estimation_with_noise_non_clifford(): qubits = cirq.LineQubit.range(3) circuit = cirq.Circuit( cirq.Z(qubits[0])**0.25, # T-Gate, non Clifford. cirq.X(qubits[1])**0.123, cirq.X(qubits[2])**0.456) noise = cirq.ConstantQubitNoiseModel(cirq.depolarize(0.1)) noisy_simulator = cirq.KnowledgeCompilationSimulator(circuit, noise=noise) estimated_fidelity, _ = dfe.direct_fidelity_estimation( circuit, qubits, noisy_simulator, n_measured_operators=None, samples_per_term=100) assert estimated_fidelity >= -1.0 and estimated_fidelity <= 1.0
def test_direct_fidelity_estimation_with_noise(): qubits = cirq.LineQubit.range(3) circuit = cirq.Circuit( cirq.Z(qubits[0])**0.25, # T-Gate, non Clifford. cirq.X(qubits[1])**0.123, cirq.X(qubits[2])**0.456) noise = cirq.ConstantQubitNoiseModel(cirq.depolarize(0.1)) noisy_simulator = cirq.DensityMatrixSimulator(noise=noise) estimated_fidelity, _ = dfe.direct_fidelity_estimation(circuit, qubits, noisy_simulator, n_trials=10, n_clifford_trials=3, samples_per_term=10) assert estimated_fidelity >= -1.0 and estimated_fidelity <= 1.0
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 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]])