<br />

|---|
| [![](https://www.tensorflow.org/images/GitHub-Mark-32px.png) View source on GitHub](https://github.com/tensorflow/quantum/blob/v0.7.6/tensorflow_quantum/core/ops/noise/noisy_expectation_op.py#L23-L98) |

Calculate the analytic expectation values using monte-carlo trajectories.

    tfq.noise.expectation(
        programs, symbol_names, symbol_values, pauli_sums, num_samples
    )

Simulate the final state of `programs` given `symbol_values` are placed
inside of the symbols with the name in `symbol_names` in each circuit.
Channels in this simulation will be "tossed" to a certain realization
during simulation. This simulation is repeated `num_samples` times and
analytic expectation calculations with the given `pauli_sums` are calculated
after each run. Once all the runs are finished, these quantities are
averaged together. This process can be thought of as analyical expectation
calculation done using monte carlo state vector simulation to account
for noisy operations in the given circuits.

    # Prepare some inputs.
    qubit = cirq.GridQubit(0, 0)
    my_symbol = sympy.Symbol('alpha')
    my_circuit_tensor = tfq.convert_to_tensor([
        cirq.Circuit(
            cirq.H(qubit) ** my_symbol,
            cirq.depolarize(0.01)(qubit)
        )
    ])
    my_values = np.array([[0.123]])
    my_paulis = tfq.convert_to_tensor([[
        3.5 * cirq.X(qubit) - 2.2 * cirq.Y(qubit)
    ]])
    my_num_samples = np.array([[100]])
    # This op can now be run with:
    output = tfq.noise.expectation(
        my_circuit_tensor, ['alpha'], my_values, my_paulis, my_num_samples)
    output
    tf.Tensor([[0.71530885]], shape=(1, 1), dtype=float32)

In order to make the op differentiable, a `tfq.differentiator` object is
needed. see [`tfq.differentiators`](https://www.tensorflow.org/quantum/api_docs/python/tfq/differentiators) for more details. Below is a simple
example of how to make the from the above code block differentiable:

    diff = tfq.differentiators.ForwardDifference()
    my_differentiable_op = diff.generate_differentiable_op(
        sampled_op=tfq.noise.expectation
    )

<br />

<br />

<br />

| ## Args ||
|---|---|
| `programs` | [`tf.Tensor`](https://www.tensorflow.org/api_docs/python/tf/Tensor) of strings with shape \[batch_size\] containing the string representations of the circuits to be executed. |
| `symbol_names` | [`tf.Tensor`](https://www.tensorflow.org/api_docs/python/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`](https://www.tensorflow.org/api_docs/python/tf/Tensor) of real numbers with shape \[batch_size, n_params\] specifying parameter values to resolve into the circuits specificed by programs, following the ordering dictated by `symbol_names`. |
| `pauli_sums` | [`tf.Tensor`](https://www.tensorflow.org/api_docs/python/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`](https://www.tensorflow.org/api_docs/python/tf/Tensor) with `num_samples[i][j]` is equal to the number of times `programs[i]` will be simulated to estimate `pauli_sums[i][j]`. Therefore, `num_samples` must have the same shape as `pauli_sums`. Note: internally this quantity can get rounded up to the nearest multiple of the number of available threads to TensorFlow. For best performance ensure that the quantities in `num_samples` are a multiple of the number of available threads. |

<br />

<br />

<br />

<br />

| ## Returns ||
|---|---|
| [`tf.Tensor`](https://www.tensorflow.org/api_docs/python/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). ||

<br />