def test_sampled_expectation_empty(self, op_and_sim, n_qubits,
symbol_names, max_paulisum_length):
"""Test empty circuits for sampled expectation using cirq and tfq."""
op = op_and_sim[0]
sim = op_and_sim[1]
qubits = cirq.GridQubit.rect(1, n_qubits)
circuit_batch = [cirq.Circuit() for _ in range(BATCH_SIZE)]
resolver_batch = [cirq.ParamResolver({}) for _ in range(BATCH_SIZE)]
symbol_values_array = np.array([[0.0 for _ in symbol_names]
for _ in resolver_batch])
pauli_sums = util.random_pauli_sums(qubits, max_paulisum_length,
BATCH_SIZE)
num_samples = [[1000]] * BATCH_SIZE
op_expectations = op(
util.convert_to_tensor(circuit_batch), symbol_names,
symbol_values_array,
util.convert_to_tensor([[psum] for psum in pauli_sums]),
num_samples)
cirq_expectations = batch_util.batch_calculate_sampled_expectation(
circuit_batch, resolver_batch, [[x] for x in pauli_sums],
num_samples, sim)
self.assertAllClose(op_expectations.numpy().flatten(),
cirq_expectations.flatten(),
rtol=1e-1,
atol=1e-1)
def test_sampled_expectation(self, op_and_sim, n_qubits, symbol_names,
max_paulisum_length):
"""Compute sampled expectations using cirq and tfq."""
op = op_and_sim[0]
sim = op_and_sim[1]
qubits = cirq.GridQubit.rect(1, n_qubits)
circuit_batch, resolver_batch = \
util.random_symbol_circuit_resolver_batch(
qubits, symbol_names, BATCH_SIZE)
symbol_values_array = np.array(
[[resolver[symbol] for symbol in symbol_names]
for resolver in resolver_batch])
pauli_sums = util.random_pauli_sums(qubits, max_paulisum_length,
BATCH_SIZE)
num_samples = [[2000]] * BATCH_SIZE
op_expectations = op(
util.convert_to_tensor(circuit_batch), symbol_names,
symbol_values_array,
util.convert_to_tensor([[psum] for psum in pauli_sums]),
num_samples)
cirq_expectations = batch_util.batch_calculate_sampled_expectation(
circuit_batch, resolver_batch, [[x] for x in pauli_sums],
num_samples, sim)
self.assertAllClose(op_expectations.numpy().flatten(),
cirq_expectations.flatten(),
rtol=1e-1,
atol=1e-1)
def test_no_circuit(self, sim):
"""Test functions with no circuits and empty arrays."""
# (1) Test expectation
results = batch_util.batch_calculate_expectation([], [], [[]], sim)
self.assertDTypeEqual(results, np.float32)
self.assertEqual(np.zeros(shape=(0, 0)).shape, results.shape)
# (2) Test sampled_expectation
results = batch_util.batch_calculate_sampled_expectation([], [], [[]],
[[]], sim)
self.assertDTypeEqual(results, np.float32)
self.assertEqual(np.zeros(shape=(0, 0)).shape, results.shape)
# (3) Test state
results = batch_util.batch_calculate_state([], [], sim)
self.assertDTypeEqual(results, np.complex64)
if isinstance(sim, cirq.Simulator):
self.assertEqual(np.zeros(shape=(0, 0)).shape, results.shape)
else:
self.assertEqual(np.zeros(shape=(0, 0, 0)).shape, results.shape)
# (4) Test sampling
results = batch_util.batch_sample([], [], [], sim)
self.assertDTypeEqual(results, np.int8)
self.assertEqual(np.zeros(shape=(0, 0, 0)).shape, results.shape)
def test_empty_circuits(self, sim):
"""Test functions with empty circuits."""
# Common preparation
resolver_batch = [cirq.ParamResolver({}) for _ in range(BATCH_SIZE)]
circuit_batch = [cirq.Circuit() for _ in range(BATCH_SIZE)]
qubits = cirq.GridQubit.rect(1, N_QUBITS)
ops = util.random_pauli_sums(qubits, PAULI_LENGTH, BATCH_SIZE)
n_samples = [[1000] for _ in range(len(ops))]
# If there is no op on a qubit, the expectation answer is -2.0
true_expectation = (-2.0, )
# (1) Test expectation
results = batch_util.batch_calculate_expectation(
circuit_batch, resolver_batch, [[x] for x in ops], sim)
for _, _, result, _ in zip(circuit_batch, resolver_batch, results,
ops):
self.assertAllClose(true_expectation, result, rtol=1e-5, atol=1e-5)
self.assertDTypeEqual(results, np.float32)
# (2) Test sampled_expectation
results = batch_util.batch_calculate_sampled_expectation(
circuit_batch, resolver_batch, [[x] for x in ops], n_samples, sim)
for _, _, result, _ in zip(circuit_batch, resolver_batch, results,
ops):
self.assertAllClose(true_expectation, result, rtol=1.0, atol=1e-1)
self.assertDTypeEqual(results, np.float32)
# (3) Test state
results = batch_util.batch_calculate_state(circuit_batch,
resolver_batch, sim)
for circuit, resolver, result in zip(circuit_batch, resolver_batch,
results):
r = _pad_state(sim, sim.simulate(circuit, resolver), 0)
self.assertAllClose(r, result, rtol=1e-5, atol=1e-5)
self.assertDTypeEqual(results, np.complex64)
# (4) Test sampling
n_samples = 2000 * (2**N_QUBITS)
results = batch_util.batch_sample(circuit_batch, resolver_batch,
n_samples, sim)
for circuit, resolver, a in zip(circuit_batch, resolver_batch,
results):
state = sim.simulate(circuit, resolver)
r = _sample_helper(sim, state, len(circuit.all_qubits()),
n_samples)
self.assertAllClose(r, a, atol=1e-5)
self.assertDTypeEqual(results, np.int32)
def test_sampled_expectation_no_circuits(self, op_and_sim):
"""Test no circuits for states using cirq and tfq."""
op = op_and_sim[0]
sim = op_and_sim[1]
circuit_batch = tf.raw_ops.Empty(shape=(0,), dtype=tf.string)
empty_params = tf.raw_ops.Empty(shape=(0, 0), dtype=tf.float32)
empty_ops = tf.raw_ops.Empty(shape=(0, 0), dtype=tf.string)
empty_samples = tf.raw_ops.Empty(shape=(0, 0), dtype=tf.int32)
op_exp = op(circuit_batch, [], empty_params, empty_ops,
empty_samples).numpy()
cirq_exp = batch_util.batch_calculate_sampled_expectation([], [], [[]],
[], sim)
self.assertEqual(op_exp.shape, cirq_exp.shape)
def test_batch_sampled_expectation(self, sim):
"""Test expectation."""
qubits = cirq.GridQubit.rect(1, N_QUBITS)
circuit_batch, resolver_batch = _get_mixed_batch(
qubits + [cirq.GridQubit(9, 9)], SYMBOLS, BATCH_SIZE)
ops = util.random_pauli_sums(qubits, PAULI_LENGTH, BATCH_SIZE)
n_samples = [[1000] for _ in range(len(ops))]
results = batch_util.batch_calculate_sampled_expectation(
circuit_batch, resolver_batch, [[x] for x in ops], n_samples, sim)
for circuit, resolver, result, op in zip(circuit_batch, resolver_batch,
results, ops):
r = _expectation_helper(sim, circuit, resolver, op)
self.assertAllClose(r, result, rtol=1.0, atol=1e-1)
self.assertDTypeEqual(results, np.float32)
def cirq_sampled_expectation(programs, symbol_names, symbol_values,
pauli_sums, num_samples):
"""Calculate the sampled expectation value of circuits wrt some
operator(s).
Estimates the expectation value for all the `cirq.PauliSum`s in
`pauli_sums` on each `cirq.Circuit` in `programs`. Each circuit will
have the values in `symbol_values` resolved into the symbols in the
circuit (with the ordering defined by `symbol_names`).
```python
symbol_names = ['a', 'b', 'c']
programs = tfq.convert_to_tensor(
[cirq.Circuit(H(q0) ** sympy.Symbol('a'),
X(q1) ** sympy.Symbol('b'),
Y(q2) ** sympy.Symbol('c'))]
)
symbol_values = [[3,2,1]]
pauli_sums = tfq.convert_to_tensor(
[1.5 * cirq.Z(q0) * cirq.Z(q1)]
)
n_samples = [[100]]
cirq_sampled_expectation(
programs, symbol_names, sybmol_values, pauli_sums, n_samples)
```
Would place the values of 3 into the Symbol labeled 'a', 2 into the
symbol labeled 'b' and 1 into the symbol labeled 'c'. Then it would
estimate the ZZ expectation on this circuit by draw samples from the
circuit 100 times.
Args:
programs: `tf.Tensor` of strings with shape [batch_size] containing
the string representations of the circuits to be executed.
symbol_names: `tf.Tensor` of strings with shape [n_params], which
is used to specify the order in which the values in
`symbol_values` should be placed inside of the circuits in
`programs`.
symbol_values: `tf.Tensor` of real numbers with shape
[batch_size, n_params] specifying parameter values to resolve
into the circuits specified by programs, following the ordering
dictated by `symbol_names`.
pauli_sums: `tf.Tensor` of strings with shape [batch_size, n_ops]
containing the string representation of the operators that will
be used on all of the circuits in the expectation calculations.
num_samples: `tf.Tensor` with `n_samples[i][j]` is equal to the
number of samples to draw in each term of `pauli_sums[i][j]`
when estimating the expectation.
Returns:
`tf.Tensor` with shape [batch_size, n_ops] that holds the
expectation value for each circuit with each op applied to it
(after resolving the corresponding parameters in).
"""
_input_check_helper(programs, symbol_names, symbol_values)
if not (pauli_sums.dtype == tf.dtypes.string):
raise TypeError('pauli_sums tensor must be of type string.')
if not (pauli_sums.shape[0] == programs.shape[0]) or \
len(pauli_sums.shape) != 2:
raise TypeError('pauli_sums tensor must have the same batch shape '
'as programs tensor.')
if not (num_samples.dtype == tf.dtypes.int32 or
num_samples.dtype == tf.dtypes.int64):
raise TypeError('num_samples tensor must be of type int32 of '
'int64.')
if not (num_samples.shape == pauli_sums.shape):
raise TypeError('num_samples tensor must have the same shape '
'as pauli_sums tensor. got: {} expected: {}'.format(
num_samples.shape, pauli_sums.shape))
if tf.less_equal(num_samples, 0).numpy().any():
raise TypeError('num_samples contains sample value <= 0.')
programs, resolvers = _batch_deserialize_helper(programs, symbol_names,
symbol_values)
num_samples = num_samples.numpy().tolist()
sum_inputs = []
for sub_list in pauli_sums.numpy():
to_append = []
for x in sub_list:
obj = pauli_sum_pb2.PauliSum()
obj.ParseFromString(x)
to_append.append(serializer.deserialize_paulisum(obj))
sum_inputs.append(to_append)
expectations = batch_util.batch_calculate_sampled_expectation(
programs, resolvers, sum_inputs, num_samples, sampler)
return expectations
