def test_run_qudit_increments(dtype):
q0, q1 = cirq.LineQid.for_qid_shape((3, 4))
simulator = cirq.DensityMatrixSimulator(dtype=dtype)
for b0 in [0, 1, 2]:
for b1 in [0, 1, 2, 3]:
circuit = cirq.Circuit(
[PlusGate(3, 1)(q0)] * b0,
[PlusGate(4, 1)(q1)] * b1,
cirq.measure(q0),
cirq.measure(q1),
)
result = simulator.run(circuit)
np.testing.assert_equal(result.measurements, {'0 (d=3)': [[b0]], '1 (d=4)': [[b1]]})
def test_run_channel(dtype):
q0, q1 = cirq.LineQubit.range(2)
circuit = cirq.Circuit.from_ops(cirq.X(q0),
cirq.amplitude_damp(0.5)(q0),
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_simulate_moment_steps_intermediate_measurement(dtype):
q0 = cirq.LineQubit(0)
circuit = cirq.Circuit.from_ops(cirq.H(q0), cirq.measure(q0), cirq.H(q0))
simulator = cirq.DensityMatrixSimulator(dtype=dtype)
for i, step in enumerate(simulator.simulate_moment_steps(circuit)):
if i == 1:
result = int(step.measurements['0'][0])
expected = np.zeros((2, 2))
expected[result, result] = 1
np.testing.assert_almost_equal(step.density_matrix(), expected)
if i == 2:
expected = np.array([[0.5, 0.5 * (-1)**result],
[0.5 * (-1)**result, 0.5]])
np.testing.assert_almost_equal(step.density_matrix(), expected)
def test_run_repetitions_measurement_not_terminal(dtype):
q0, q1 = cirq.LineQubit.range(2)
simulator = cirq.DensityMatrixSimulator(dtype=dtype)
for b0 in [0, 1]:
for b1 in [0, 1]:
circuit = cirq.Circuit.from_ops((cirq.X**b0)(q0), (cirq.X**b1)(q1),
cirq.measure(q0), cirq.measure(q1),
cirq.H(q0), cirq.H(q1))
result = simulator.run(circuit, repetitions=3)
np.testing.assert_equal(result.measurements, {
'0': [[b0]] * 3,
'1': [[b1]] * 3
})
assert result.repetitions == 3
def test_run_repetitions_measure_at_end(dtype):
q0, q1 = cirq.LineQubit.range(2)
simulator = cirq.DensityMatrixSimulator(dtype=dtype)
with mock.patch.object(simulator, '_base_iterator',
wraps=simulator._base_iterator) as mock_sim:
for b0 in [0, 1]:
for b1 in [0, 1]:
circuit = cirq.Circuit((cirq.X**b0)(q0), (cirq.X**b1)(q1),
cirq.measure(q0), cirq.measure(q1))
result = simulator.run(circuit, repetitions=3)
np.testing.assert_equal(result.measurements,
{'0': [[b0]] * 3, '1': [[b1]] * 3})
assert result.repetitions == 3
assert mock_sim.call_count == 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 test_random_seed_terminal_measurements_deterministic():
a = cirq.NamedQubit('a')
circuit = cirq.Circuit(cirq.X(a)**0.5, cirq.measure(a, key='a'))
sim = cirq.DensityMatrixSimulator(seed=1234)
result1 = sim.run(circuit, repetitions=30)
result2 = sim.run(circuit, repetitions=30)
assert np.all(result1.measurements['a'] ==
[[0], [1], [0], [1], [1], [0], [0], [1], [1], [1], [0], [1],
[1], [1], [0], [1], [1], [0], [1], [1], [0], [1], [0], [0],
[1], [1], [0], [1], [0], [1]])
assert np.all(result2.measurements['a'] ==
[[1], [0], [1], [0], [1], [1], [0], [1], [0], [1], [0], [0],
[0], [1], [1], [1], [0], [1], [0], [1], [0], [1], [1], [0],
[1], [1], [1], [1], [1], [1]])
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_simulator = cirq.DensityMatrixSimulator()
estimated_fidelity, _ = dfe.direct_fidelity_estimation(
circuit,
qubits,
no_noise_simulator,
n_measured_operators=3,
samples_per_term=0)
assert np.isclose(estimated_fidelity, 1.0, atol=0.01)
def test_direct_fidelity_estimation_clifford_all_trials():
qubits = cirq.LineQubit.range(2)
circuit = cirq.Circuit(cirq.Z(qubits[0]), cirq.X(qubits[1]))
no_noise_simulator = cirq.DensityMatrixSimulator()
for n_measured_operators in [1, 2, 3, 4, None]:
estimated_fidelity, _ = dfe.direct_fidelity_estimation(
circuit,
qubits,
no_noise_simulator,
n_measured_operators=n_measured_operators,
samples_per_term=0)
assert np.isclose(estimated_fidelity, 1.0, atol=0.01)
def test_get_samples_inputs(self):
"""Test that get_samples only accepts inputs it should."""
circuit_execution_ops.get_sampling_op()
circuit_execution_ops.get_sampling_op(backend=cirq.Simulator())
circuit_execution_ops.get_sampling_op(
backend=cirq.DensityMatrixSimulator())
mock_engine = mock.Mock()
circuit_execution_ops.get_sampling_op(
backend=cirq.google.QuantumEngineSampler(engine=mock_engine,
processor_id='test',
gate_set=cirq.google.XMON))
with self.assertRaisesRegex(TypeError,
expected_regex="Expected a Cirq.Sampler"):
circuit_execution_ops.get_sampling_op(backend="junk")
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_bangbang_protocol(self):
system = TFIMChain(3, 1, 1, sparse=True)
system.normalize()
c = bangbang_protocol(system, ('Y'), 3)
# expected circuit length:
# iterations * qubits * (len(HS) + len(coupl) + reset)
self.assertEqual(len(c), 3 * 3 * (4 + 2 + 1))
s = cirq.DensityMatrixSimulator()
res = s.simulate(c)
final_state = trace_out(res.final_density_matrix, -1)
final_energy = system.energy_expval(final_state)
self.assertLess(final_energy, 0)
def test_run_param_resolver(dtype):
q0, q1 = cirq.LineQubit.range(2)
simulator = cirq.DensityMatrixSimulator(dtype=dtype)
for b0 in [0, 1]:
for b1 in [0, 1]:
circuit = cirq.Circuit((cirq.X**sympy.Symbol('b0'))(q0),
(cirq.X**sympy.Symbol('b1'))(q1),
cirq.measure(q0), cirq.measure(q1))
param_resolver = {'b0': b0, 'b1': b1}
result = simulator.run(circuit, param_resolver=param_resolver)
np.testing.assert_equal(result.measurements,
{'0': [[b0]], '1': [[b1]] })
np.testing.assert_equal(result.params,
cirq.ParamResolver(param_resolver))
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 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_simulate_initial_qudit_state(dtype):
q0, q1 = cirq.LineQid.for_qid_shape((3, 4))
simulator = cirq.DensityMatrixSimulator(dtype=dtype)
for b0 in [0, 1, 2]:
for b1 in [0, 1, 2, 3]:
circuit = cirq.Circuit(
PlusGate(3, b0)(q0),
PlusGate(4, b1)(q1),
)
result = simulator.simulate(circuit, initial_state=6)
expected_density_matrix = np.zeros(shape=(12, 12))
expected_density_matrix[(b0 + 1) % 3 * 4 + (b1 + 2) % 4,
(b0 + 1) % 3 * 4 + (b1 + 2) % 4] = 1.0
np.testing.assert_equal(result.final_density_matrix,
expected_density_matrix)
def test_run_qudits_repetitions_measure_at_end(dtype):
q0, q1 = cirq.LineQid.for_qid_shape((2, 3))
simulator = cirq.DensityMatrixSimulator(dtype=dtype)
with mock.patch.object(simulator, '_base_iterator', wraps=simulator._base_iterator) as mock_sim:
for b0 in [0, 1]:
for b1 in [0, 1, 2]:
circuit = cirq.Circuit(
(cirq.X ** b0)(q0), PlusGate(3, b1)(q1), cirq.measure(q0), cirq.measure(q1)
)
result = simulator.run(circuit, repetitions=3)
np.testing.assert_equal(
result.measurements, {'0 (d=2)': [[b0]] * 3, '1 (d=3)': [[b1]] * 3}
)
assert result.repetitions == 3
assert mock_sim.call_count == 6
def test_simulate_param_resolver(dtype):
q0, q1 = cirq.LineQubit.range(2)
simulator = cirq.DensityMatrixSimulator(dtype=dtype)
for b0 in [0, 1]:
for b1 in [0, 1]:
circuit = cirq.Circuit.from_ops((cirq.X**sympy.Symbol('b0'))(q0),
(cirq.X**sympy.Symbol('b1'))(q1))
resolver = cirq.ParamResolver({'b0': b0, 'b1': b1})
result = simulator.simulate(circuit, param_resolver=resolver)
expected_density_matrix = np.zeros(shape=(4, 4))
expected_density_matrix[2 * b0 + b1, 2 * b0 + b1] = 1.0
np.testing.assert_equal(result.final_density_matrix,
expected_density_matrix)
assert result.params == resolver
assert len(result.measurements) == 0
def test_simulate_moment_steps_sample(dtype):
q0, q1 = cirq.LineQubit.range(2)
circuit = cirq.Circuit.from_ops(cirq.H(q0), cirq.CNOT(q0, q1))
simulator = cirq.DensityMatrixSimulator(dtype=dtype)
for i, step in enumerate(simulator.simulate_moment_steps(circuit)):
if i == 0:
samples = step.sample([q0, q1], repetitions=10)
for sample in samples:
assert (np.array_equal(sample, [True, False])
or np.array_equal(sample, [False, False]))
else:
samples = step.sample([q0, q1], repetitions=10)
for sample in samples:
assert (np.array_equal(sample, [True, True])
or np.array_equal(sample, [False, False]))
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 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_simulate_bit_flips(dtype):
q0, q1 = cirq.LineQubit.range(2)
simulator = cirq.DensityMatrixSimulator(dtype=dtype)
for b0 in [0, 1]:
for b1 in [0, 1]:
circuit = cirq.Circuit.from_ops((cirq.X**b0)(q0),
(cirq.X**b1)(q1),
cirq.measure(q0),
cirq.measure(q1))
result = simulator.simulate(circuit)
np.testing.assert_equal(result.measurements, {'0': [b0], '1': [b1]})
expected_density_matrix = np.zeros(shape=(4, 4))
expected_density_matrix[b0 * 2 + b1, b0 * 2 + b1] = 1.0
np.testing.assert_equal(result.final_density_matrix,
expected_density_matrix)
def test_simulate_qudit_increments(dtype):
q0, q1 = cirq.LineQid.for_qid_shape((2, 3))
simulator = cirq.DensityMatrixSimulator(dtype=dtype)
for b0 in [0, 1]:
for b1 in [0, 1, 2]:
circuit = cirq.Circuit((cirq.X**b0)(q0), (PlusGate(3)(q1),) * b1,
cirq.measure(q0), cirq.measure(q1))
result = simulator.simulate(circuit)
np.testing.assert_equal(result.measurements, {
'0 (d=2)': [b0],
'1 (d=3)': [b1]
})
expected_density_matrix = np.zeros(shape=(6, 6))
expected_density_matrix[b0 * 3 + b1, b0 * 3 + b1] = 1.0
np.testing.assert_equal(result.final_density_matrix,
expected_density_matrix)
def sample_bitstrings(
circuit: cirq.Circuit,
noise_model: cirq.NOISE_MODEL_LIKE = cirq.amplitude_damp, # type: ignore
noise_level: Tuple[float] = (0.01, ),
sampler: cirq.Sampler = cirq.DensityMatrixSimulator(),
shots: int = 8192,
) -> MeasurementResult:
if sum(noise_level) > 0:
circuit = circuit.with_noise(noise_model(*noise_level)) # type: ignore
result = sampler.run(circuit, repetitions=shots)
return MeasurementResult(
result=np.column_stack(list(result.measurements.values())),
qubit_indices=tuple(
int(q) for k in result.measurements.keys() for q in k.split(",")),
)
def main(self,
n_computation_qubits=10,
n_bath_qubits=0,
n_simulations=100,
print_circuit=False,
bath_type='Markovian',
unknown_gate_phase=.8 * np.pi,
prob_ground=0.821662):
""" Runs QPE on (n_computation_qubits)-qubits """
self.prob_ground = prob_ground
self.n_computation_qubits = n_computation_qubits
self.n_bath_qubits = n_bath_qubits
self.n_simulations = n_simulations
self.unknown_gate = self.gate(unknown_gate_phase / (2 * np.pi))
self.bath_type = bath_type
self.computation_qubits, self.ancil_qubit = self.set_io_qubits(
) # Set up input and output qubits.
# compile QPE
simulator = cirq.DensityMatrixSimulator() # initialize simulator
# result = simulator.run(self.c, repetitions=n_simulations) # run the simulations 1000 times
solutions = []
fold_func = lambda ms: ''.join(np.flip(ms, 0).astype(int).astype(str))
for i in range(n_simulations):
# compile a quantum circuit for QPE algorithm each time to set different qubits according to partition function
self.c = self.make_qpe_circuit()
result = simulator.run(self.c, repetitions=1) # run the simulation
hist = result.histogram(key='result', fold_func=fold_func)
solutions += [hist.most_common(1)[0][0]] # see result
if print_circuit: print(self.c) # plot quantum circuit
count = Counter(solutions)
estimate_bin = list(map(int, list(count.most_common()[0][0])))
estimate = (sum([
float(s) * 0.5**(order + 1) for order, s in enumerate(estimate_bin)
])) * (2 * np.pi) #Calculates phase estimate
#returns the chosen gate phase followed by the algorithims estimate, difference between the two, and the most probable measurement
return unknown_gate_phase, estimate, abs(
estimate - unknown_gate_phase), count.most_common()[0][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 execute_with_depolarizing_noise(circ: cirq.Circuit, obs: np.ndarray,
noise: float) -> float:
"""Simulates a circuit with depolarizing noise at level noise.
Args:
circ: The input Cirq circuit.
obs: The observable to measure as a NumPy array.
noise: The depolarizing noise as a float, i.e. 0.001 is 0.1% noise.
Returns:
The expectation value of obs as a float.
"""
circuit = circ.with_noise(cirq.depolarize(p=noise))
simulator = cirq.DensityMatrixSimulator()
rho = simulator.simulate(circuit).final_density_matrix
expectation = np.real(np.trace(rho @ obs))
return expectation
def _estimate_pauli_traces_general(
qubits: List[cirq.Qid], circuit: cirq.Circuit,
n_measured_operators: Optional[int]) -> List[PauliTrace]:
"""
Estimates the Pauli traces in case the circuit is not Clifford. In this case
we cannot use the speedup implemented in the function
_estimate_pauli_traces_clifford() above, and so do a slow, density matrix
simulation.
Args:
qubits: The list of qubits.
circuit: The (non Clifford) circuit.
n_measured_operators: The total number of Pauli measurements, or None to
explore each Pauli state once.
Returns:
A list of Pauli states (represented as tuples of Pauli string, rho_i,
and probability.
"""
n_qubits = len(qubits)
dense_simulator = cirq.DensityMatrixSimulator()
# rho in https://arxiv.org/abs/1104.3835
clean_density_matrix = cast(
cirq.DensityMatrixTrialResult,
dense_simulator.simulate(circuit)).final_density_matrix
all_operators = itertools.product([cirq.I, cirq.X, cirq.Y, cirq.Z],
repeat=n_qubits)
if n_measured_operators is not None:
dense_operators = random.sample(tuple(all_operators),
n_measured_operators)
else:
dense_operators = list(all_operators)
pauli_traces: List[PauliTrace] = []
for P_i in dense_operators:
pauli_string: cirq.PauliString[cirq.Qid] = cirq.PauliString(
dict(zip(qubits, P_i)))
rho_i, Pr_i = compute_characteristic_function(circuit, pauli_string,
qubits,
clean_density_matrix)
pauli_traces.append(
PauliTrace(P_i=pauli_string, rho_i=rho_i, Pr_i=Pr_i))
return pauli_traces
def test_get_expectation_inputs(self):
"""Test that get expectation only accepts inputs it should."""
circuit_execution_ops.get_expectation_op()
circuit_execution_ops.get_expectation_op(backend=cirq.Simulator())
circuit_execution_ops.get_expectation_op(
backend=cirq.DensityMatrixSimulator())
circuit_execution_ops.get_expectation_op()
with self.assertRaisesRegex(NotImplementedError,
expected_regex='Sample-based'):
mock_engine = mock.Mock()
circuit_execution_ops.get_expectation_op(
cirq.google.QuantumEngineSampler(engine=mock_engine,
processor_id='test',
gate_set=cirq.google.XMON))
with self.assertRaisesRegex(
TypeError, expected_regex="a Cirq.SimulatesFinalState"):
circuit_execution_ops.get_expectation_op(backend="junk")
