# Source code for mitiq.ddd.ddd

```
# Copyright (C) Unitary Fund
#
# This source code is licensed under the GPL license (v3) found in the
# LICENSE file in the root directory of this source tree.
"""High-level digital dynamical decoupling (DDD) tools."""
from functools import partial, wraps
from typing import Any, Callable, Dict, List, Optional, Tuple, Union
import numpy as np
from mitiq import QPROGRAM, Executor, Observable, QuantumResult
from mitiq.ddd.insertion import insert_ddd_sequences
[docs]def execute_with_ddd(
circuit: QPROGRAM,
executor: Union[Executor, Callable[[QPROGRAM], QuantumResult]],
observable: Optional[Observable] = None,
*,
rule: Callable[[int], QPROGRAM],
rule_args: Dict[str, Any] = {},
num_trials: int = 1,
full_output: bool = False,
) -> Union[float, Tuple[float, Dict[str, Any]]]:
r"""Estimates the error-mitigated expectation value associated to the
input circuit, via the application of digital dynamical decoupling (DDD).
Args:
circuit: The input circuit to execute with DDD.
executor: A Mitiq executor that executes a circuit and returns the
unmitigated ``QuantumResult`` (e.g. an expectation value).
observable: Observable to compute the expectation value of. If None,
the ``executor`` must return an expectation value. Otherwise,
the ``QuantumResult`` returned by ``executor`` is used to compute
the expectation of the observable.
rule: A function that takes as main argument a slack length (i.e. the
number of idle moments) of a slack window (i.e. a single-qubit idle
window in a circuit) and returns the DDD sequence of gates to be
applied in that window. Mitiq provides standard built-in rules
that can be directly imported from ``mitiq.ddd.rules``.
rule_args: An optional dictionary of keyword arguments for ``rule``.
num_trials: The number of independent experiments to average over.
A number larger than 1 can be useful to average over multiple
applications of a rule returning non-deterministic DDD sequences.
full_output: If ``False`` only the mitigated expectation value is
returned. If ``True`` a dictionary containing all DDD data is
returned too.
Returns:
The tuple ``(ddd_value, ddd_data)`` where ``ddd_value`` is the
expectation value estimated with DDD and ``ddd_data`` is a dictionary
containing all the raw data involved in the DDD process (e.g. the
circuit filled with DDD sequences). If ``full_output`` is false,
only ``ddd_value`` is returned.
"""
# Initialize executor
if not isinstance(executor, Executor):
executor = Executor(executor)
rule_partial: Callable[[int], QPROGRAM]
rule_partial = partial(rule, **rule_args)
# Insert DDD sequences in (a copy of) the input circuit
circuits_with_ddd = [
insert_ddd_sequences(circuit, rule_partial) for _ in range(num_trials)
]
results = executor.evaluate(
circuits_with_ddd,
observable,
force_run_all=True,
)
assert len(results) == num_trials
ddd_value = np.sum(results) / num_trials
if not full_output:
return ddd_value
ddd_data = {
"ddd_value": ddd_value,
"ddd_trials": results,
"circuits_with_ddd": circuits_with_ddd,
}
return ddd_value, ddd_data
[docs]def mitigate_executor(
executor: Callable[[QPROGRAM], QuantumResult],
observable: Optional[Observable] = None,
*,
rule: Callable[[int], QPROGRAM],
rule_args: Dict[str, Any] = {},
num_trials: int = 1,
full_output: bool = False,
) -> Callable[[QPROGRAM], Union[float, Tuple[float, Dict[str, Any]]]]:
"""Returns a modified version of the input 'executor' which is
error-mitigated with digital dynamical decoupling (DDD).
Args:
executor: A function that executes a circuit and returns the
unmitigated `QuantumResult` (e.g. an expectation value).
observable: Observable to compute the expectation value of. If None,
the `executor` must return an expectation value. Otherwise,
the `QuantumResult` returned by `executor` is used to compute the
expectation of the observable.
rule: A function that takes as main argument a slack length (i.e. the
number of idle moments) of a slack window (i.e. a single-qubit idle
window in a circuit) and returns the DDD sequence of gates to be
applied in that window. Mitiq provides standard built-in rules
that can be directly imported from `mitiq.ddd.rules`.
rule_args: An optional dictionary of keyword arguments for `rule`.
num_trials: The number of independent experiments to average over.
A number larger than 1 can be useful to average over multiple
applications of a rule returning non-deterministic DDD sequences.
full_output: If False only the mitigated expectation value is returned.
If True a dictionary containing all DDD data is returned too.
Returns:
The error-mitigated version of the input executor.
"""
executor_obj = Executor(executor)
if not executor_obj.can_batch:
@wraps(executor)
def new_executor(
circuit: QPROGRAM,
) -> Union[float, Tuple[float, Dict[str, Any]]]:
return execute_with_ddd(
circuit,
executor,
observable,
rule=rule,
rule_args=rule_args,
num_trials=num_trials,
full_output=full_output,
)
else:
@wraps(executor)
def new_executor(
circuits: List[QPROGRAM],
) -> List[Union[float, Tuple[float, Dict[str, Any]]]]:
return [
execute_with_ddd(
circuit,
executor,
observable,
rule=rule,
rule_args=rule_args,
num_trials=num_trials,
full_output=full_output,
)
for circuit in circuits
]
return new_executor
[docs]def ddd_decorator(
observable: Optional[Observable] = None,
*,
rule: Callable[[int], QPROGRAM],
rule_args: Dict[str, Any] = {},
num_trials: int = 1,
full_output: bool = False,
) -> Callable[
[Callable[[QPROGRAM], QuantumResult]],
Callable[[QPROGRAM], Union[float, Tuple[float, Dict[str, Any]]]],
]:
"""Decorator which adds an error-mitigation layer based on digital
dynamical decoupling (DDD) to an executor function, i.e., a function which
executes a quantum circuit with an arbitrary backend and returns a
``QuantumResult`` (e.g. an expectation value).
Args:
observable: Observable to compute the expectation value of. If None,
the `executor` must return an expectation value. Otherwise,
the `QuantumResult` returned by `executor` is used to compute the
expectation of the observable.
rule: A function that takes as main argument a slack length (i.e. the
number of idle moments) of a slack window (i.e. a single-qubit idle
window in a circuit) and returns the DDD sequence of gates to be
applied in that window. Mitiq provides standard built-in rules
that can be directly imported from `mitiq.ddd.rules`.
rule_args: An optional dictionary of keyword arguments for `rule`.
num_trials: The number of independent experiments to average over.
A number larger than 1 can be useful to average over multiple
applications of a rule returning non-deterministic DDD sequences.
full_output: If False only the mitigated expectation value is returned.
If True a dictionary containing all DDD data is returned too.
Returns:
The error-mitigating decorator to be applied to an executor function.
"""
def decorator(
executor: Callable[[QPROGRAM], QuantumResult]
) -> Callable[[QPROGRAM], Union[float, Tuple[float, Dict[str, Any]]]]:
return mitigate_executor(
executor,
observable,
rule=rule,
rule_args=rule_args,
num_trials=num_trials,
full_output=full_output,
)
return decorator
```