async def estimate_characteristic_function(circuit: cirq.Circuit,
pauli_string: cirq.PauliString,
qubits: List[cirq.Qid],
sampler: cirq.Sampler,
samples_per_term: int):
"""
Estimates the characteristic function using a (noisy) circuit simulator by
sampling the results.
Args:
circuit: The circuit to run the simulation on.
pauli_string: The Pauli string.
qubits: The list of qubits.
sampler: Either a noisy simulator or an engine.
samples_per_term: An integer greater than 0, the number of samples.
Returns:
The estimated characteristic function.
"""
p = cirq.PauliSumCollector(circuit=circuit,
observable=pauli_string,
samples_per_term=samples_per_term)
await p.collect_async(sampler=sampler)
sigma_i = p.estimated_energy()
assert np.isclose(sigma_i.imag, 0.0, atol=1e-6)
sigma_i = sigma_i.real
return sigma_i
async def estimate_characteristic_function(
circuit: cirq.Circuit, P_i: Tuple[cirq.Gate, ...],
qubits: List[cirq.Qid], simulator: cirq.DensityMatrixSimulator,
samples_per_term: int):
"""
Estimates the characteristic function using a (noisy) circuit simulator by
sampling the results.
Args:
circuit: The circuit to run the simulation on.
P_i: The Pauli matrix.
qubits: The list of qubits.
simulator: The (noisy) simulator.
samples_per_term: An integer greater than 0, the number of samples.
Returns:
The estimated characteristic function.
"""
pauli_string = cirq.PauliString(dict(zip(qubits, P_i)))
p = cirq.PauliSumCollector(circuit=circuit,
observable=pauli_string,
samples_per_term=samples_per_term)
await p.collect_async(sampler=simulator)
sigma_i = p.estimated_energy()
assert np.isclose(sigma_i.imag, 0.0, atol=1e-6)
sigma_i = sigma_i.real
return sigma_i
def test_pauli_string_sample_collector_extra_qubit_x():
a, b = cirq.LineQubit.range(2)
p = cirq.PauliSumCollector(circuit=cirq.Circuit(cirq.H(a)),
observable=3 * cirq.X(b),
samples_per_term=10000)
p.collect(sampler=cirq.Simulator())
assert abs(p.estimated_energy()) < 0.5
def test_pauli_string_sample_single():
a, b = cirq.LineQubit.range(2)
p = cirq.PauliSumCollector(circuit=cirq.Circuit(cirq.H(a), cirq.CNOT(a, b),
cirq.X(a), cirq.Z(b)),
observable=cirq.X(a) * cirq.X(b),
samples_per_term=100)
completion = p.collect_async(sampler=cirq.Simulator())
cirq.testing.assert_asyncio_will_have_result(completion, None)
assert p.estimated_energy() == -1
async def test_pauli_string_sample_single():
a, b = cirq.LineQubit.range(2)
p = cirq.PauliSumCollector(
circuit=cirq.Circuit(cirq.H(a), cirq.CNOT(a, b), cirq.X(a), cirq.Z(b)),
observable=cirq.X(a) * cirq.X(b),
samples_per_term=100,
)
result = await p.collect_async(sampler=cirq.Simulator())
assert result is None
assert p.estimated_energy() == -1
async def test_pauli_string_sample_collector():
a, b = cirq.LineQubit.range(2)
p = cirq.PauliSumCollector(circuit=cirq.Circuit(cirq.H(a), cirq.CNOT(a, b),
cirq.X(a), cirq.Z(b)),
observable=cirq.X(a) * cirq.X(b) -
16 * cirq.Y(a) * cirq.Y(b) +
4 * cirq.Z(a) * cirq.Z(b),
samples_per_term=100)
completion = p.collect_async(sampler=cirq.Simulator())
assert await completion is None
assert p.estimated_energy() == 11
async def test_pauli_string_sample_collector():
a, b = cirq.LineQubit.range(2)
p = cirq.PauliSumCollector(
circuit=cirq.Circuit(cirq.H(a), cirq.CNOT(a, b), cirq.X(a), cirq.Z(b)),
observable=(1 + 0j) * cirq.X(a) * cirq.X(b) -
16 * cirq.Y(a) * cirq.Y(b) + 4 * cirq.Z(a) * cirq.Z(b) + (1 - 0j),
samples_per_term=100,
)
result = await p.collect_async(sampler=cirq.Simulator())
assert result is None
energy = p.estimated_energy()
assert isinstance(energy, float) and energy == 12
def execute_with_shots(circ: cirq.Circuit, obs: cirq.PauliString,
shots: int) -> float:
"""Simulates noiseless wavefunction evolution and returns the
expectation value of a PauliString observable.
Args:
circ: The input Cirq circuit.
obs: The observable to measure as a cirq.PauliString.
shots: The number of measurements.
Returns:
The expectation value of obs as a float.
"""
# Do the sampling
psum = cirq.PauliSumCollector(circ, obs, samples_per_term=shots)
psum.collect(sampler=cirq.Simulator())
# Return the expectation value
return psum.estimated_energy()
def execute_with_shots_and_depolarizing_noise(
circuit: cirq.Circuit, obs: PauliSumLike, noise: float,
shots: int) -> Union[float, complex]:
"""Simulates a circuit with depolarizing noise at level noise.
Args:
circuit: The input Cirq circuit.
obs: The observable to measure as a NumPy array.
noise: The depolarizing noise strength as a float (0.001 is 0.1%)
shots: The number of measurements.
Returns:
The expectation value of obs as a float.
"""
# Add noise
noisy = circuit.with_noise(cirq.depolarize(p=noise)) # type: ignore
# Do the sampling
psum = cirq.PauliSumCollector(noisy, obs, samples_per_term=shots)
psum.collect(sampler=cirq.DensityMatrixSimulator())
# Return the expectation value
return psum.estimated_energy()
def test_pauli_string_sample_collector_identity():
p = cirq.PauliSumCollector(circuit=cirq.Circuit(),
observable=cirq.PauliSum() + 2j,
samples_per_term=100)
p.collect(sampler=cirq.Simulator())
assert p.estimated_energy() == 2j
