HEAT experiments

qiskit_experiments/library/__init__.py

@@ -120,6 +120,7 @@ class instance to manage parameters and pulse schedules.
 )
 from .randomized_benchmarking import StandardRB, InterleavedRB
 from .tomography import StateTomography, ProcessTomography
+from .heat import ZXHeatZError, ZXHeatYError
 from .quantum_volume import QuantumVolume
 
 # Experiment Sub-modules

qiskit_experiments/library/heat/__init__.py

@@ -0,0 +1,16 @@
+# This code is part of Qiskit.
+#
+# (C) Copyright IBM 2021.
+#
+# This code is licensed under the Apache License, Version 2.0. You may
+# obtain a copy of this license in the LICENSE.txt file in the root directory
+# of this source tree or at http://www.apache.org/licenses/LICENSE-2.0.
+#
+# Any modifications or derivative works of this code must retain this
+# copyright notice, and modified files need to carry a notice indicating
+# that they have been altered from the originals.
+"""
+Hamiltonian Error Amplifying Tomography Experiments.
+"""
+
+from .zx_heat import ZXHeatYError, ZXHeatZError

qiskit_experiments/library/heat/base_analysis.py

@@ -0,0 +1,126 @@
+# This code is part of Qiskit.
+#
+# (C) Copyright IBM 2021.
+#
+# This code is licensed under the Apache License, Version 2.0. You may
+# obtain a copy of this license in the LICENSE.txt file in the root directory
+# of this source tree or at http://www.apache.org/licenses/LICENSE-2.0.
+#
+# Any modifications or derivative works of this code must retain this
+# copyright notice, and modified files need to carry a notice indicating
+# that they have been altered from the originals.
+"""
+Analysis for HEAT experiments.
+"""
+
+from abc import ABC
+
+import numpy as np
+
+from qiskit_experiments.curve_analysis import ErrorAmplificationAnalysis
+from qiskit_experiments.exceptions import AnalysisError
+from qiskit_experiments.framework import (
+    CompositeAnalysis,
+    CompositeExperimentData,
+    AnalysisResultData,
+    Options,
+    FitVal,
+)
+
+
+class HeatAnalysis(ErrorAmplificationAnalysis):
+    """An analysis class for HEAT experiment to define the fixed parameters."""
+
+    __fixed_parameters__ = ["angle_per_gate", "phase_offset", "amp"]
+
+    @classmethod
+    def _default_options(cls) -> Options:
+        """Default analysis options."""
+        options = super()._default_options()
+        options.angle_per_gate = np.pi
+        options.phase_offset = np.pi / 2
+        options.amp = 1.0
+
+        return options
+
+
+class CompositeHeatAnalysis(CompositeAnalysis, ABC):
+    r"""A composite error amplification analysis to get unitary error coefficients.
+
+    # section: fit_model
+
+        This analysis takes a set of `d_theta` parameters from two error amplification
+        analysis results. Each parameter is extracted from the HEAT experiment with
+        different control qubit states. Namely,
+
+        .. math::
+
+            A_{I\beta} = \frac{{d\theta_{\beta 0}} + d\theta_{\beta 1}}}{2}
+
+            A_{Z\beta} = \frac{{d\theta_{\beta 0}} - d\theta_{\beta 1}}}{2}
+
+        where, :math:`\beta \in [X, Y, Z]` is one of single qubit Pauli terms,
+        :math:`d\theta_{\beta k}` is `d_theta` parameter extracted from the HEAT experiment
+        with the control qubit state :math:`|k\rangle \in [|0\rangle, |1\rangle]`.
+
+    # section: see_also
+        qiskit_experiments.curve_analysis.standard_analysis.error_amplification_analysis.\
+        ErrorAmplificationAnalysis
+
+    """
+    __fit_params__ = []
+    __out_params__ = []
+
+    def _run_analysis(self, experiment_data: CompositeExperimentData, **options):
+
+        # Validate setup
+        if len(self.__fit_params__) != 2:
+            raise AnalysisError(
+                f"{self.__class__.__name__} assumes two fit parameters extracted from "
+                "a set of experiments with different control qubit state input. "
+                f"{len(self.__fit_params__)} input parameter names are specified."
+            )
+
+        if len(self.__out_params__) != 2:
+            raise AnalysisError(
+                f"{self.__class__.__name__} assumes two output parameters computed with "
+                "a set of experiment results with different control qubit state input. "
+                f"{len(self.__out_params__)} output parameter names are specified."
+            )
+
+        # Create analysis data of nested experiment and discard redundant entry.
+        # Note that experiment_data is mutable.
+        super()._run_analysis(experiment_data, **options)
+
+        sub_analysis_results = [
+            experiment_data.component_experiment_data(i).analysis_results(pname)
+            for i, pname in enumerate(self.__fit_params__)
+        ]
+
+        # Check data quality
+        is_good_quality = all(r.quality == "good" for r in sub_analysis_results)
+
+        # Compute unitary terms
+        ib = (sub_analysis_results[0].value.value + sub_analysis_results[1].value.value) / 2
+        zb = (sub_analysis_results[0].value.value - sub_analysis_results[1].value.value) / 2
+
+        # Compute new variance
+        sigma = np.sqrt(
+            sub_analysis_results[0].value.stderr ** 2 + sub_analysis_results[1].value.stderr ** 2
+        )
+
+        estimate_ib = AnalysisResultData(
+            name=self.__out_params__[0],
+            value=FitVal(value=ib, stderr=sigma, unit="rad"),
+            quality="good" if is_good_quality else "bad",
+        )
+
+        estimate_zb = AnalysisResultData(
+            name=self.__out_params__[1],
+            value=FitVal(value=zb, stderr=sigma, unit="rad"),
+            quality="good" if is_good_quality else "bad",
+        )
+
+        composite_analysis_results = [estimate_ib, estimate_zb]
+
+        return composite_analysis_results, None

qiskit_experiments/library/heat/base_experiment.py

@@ -0,0 +1,194 @@
+# This code is part of Qiskit.
+#
+# (C) Copyright IBM 2021.
+#
+# This code is licensed under the Apache License, Version 2.0. You may
+# obtain a copy of this license in the LICENSE.txt file in the root directory
+# of this source tree or at http://www.apache.org/licenses/LICENSE-2.0.
+#
+# Any modifications or derivative works of this code must retain this
+# copyright notice, and modified files need to carry a notice indicating
+# that they have been altered from the originals.
+"""
+Base Class for general Hamiltonian Error Amplifying Tomography experiments.
+"""
+
+from abc import ABC
+from typing import List, Tuple, Optional
+
+from qiskit import circuit, QuantumCircuit
+from qiskit.providers import Backend
+
+from qiskit_experiments.framework import BaseExperiment, BatchExperiment, Options, fix_class_docs
+from .base_analysis import HeatAnalysis
+
+
+@fix_class_docs
+class HeatElement(BaseExperiment):
+    """Base class of HEAT experiment elements.
+
+    This class implements a single error amplification sequence.
+
+    Subclasses must implement :py:meth:`_echo_circuit` to provide echo sequence that
+    selectively amplifies a specific Pauli component local to the target qubit.
+
+    """
+
+    __analysis_class__ = HeatAnalysis
+
+    def __init__(
+        self,
+        qubits: Tuple[int, int],
+        prep_circ: QuantumCircuit,
+        echo_circ: QuantumCircuit,
+        meas_circ: QuantumCircuit,
+        backend: Optional[Backend] = None,
+        **kwargs
+    ):
+        """Create new HEAT sub experiment.
+
+        Args:
+            qubits: Index of control and target qubit, respectively.
+            prep_circ: A circuit to prepare qubit before the echo sequence.
+            echo_circ: A circuit to selectively amplify the specific error term.
+            meas_circ: A circuit to project target qubit onto the basis of interest.
+            backend: Optional, the backend to run the experiment on.
+
+        Keyword Args:
+            See :meth:`experiment_options` for details.
+        """
+        super().__init__(qubits=qubits, backend=backend)
+        self.set_experiment_options(**kwargs)
+
+        # These are not user configurable options. Be frozen once assigned.
+        self._prep_circuit = prep_circ
+        self._echo_circuit = echo_circ
+        self._meas_circuit = meas_circ
+
+    @classmethod
+    def _default_experiment_options(cls) -> Options:
+        """Default experiment options.
+
+        Experiment Options:
+            repetitions (Sequence[int]): A list of the number of echo repetitions.
+            cr_gate (Gate): A gate instance representing the ZX(pi/2).
+        """
+        options = super()._default_experiment_options()
+        options.repetitions = list(range(21))
+        options.heat_gate = circuit.Gate("heat", num_qubits=2, params=[])
+
+        return options
+
+    @classmethod
+    def _default_transpile_options(cls) -> Options:
+        """Default transpile options."""
+        options = super()._default_transpile_options()
+        options.basis_gates = ["sx", "x", "rz", "cr"]
+        options.optimization_level = 0
+
+        return options
+
+    def circuits(self, backend: Optional[Backend] = None) -> List[QuantumCircuit]:
+        opt = self.experiment_options
+
+        circs = list()
+        for repetition in opt.repetitions:
+            circ = circuit.QuantumCircuit(2, 1)
+            circ.compose(self._prep_circuit, qubits=[0, 1], inplace=True)
+            circ.barrier()
+            for _ in range(repetition):
+                circ.append(self.experiment_options.heat_gate, [0, 1])
+                circ.compose(self._echo_circuit, qubits=[0, 1], inplace=True)
+                circ.barrier()
+            circ.compose(self._meas_circuit, qubits=[0, 1], inplace=True)
+            circ.measure(1, 0)
+
+            # add metadata
+            circ.metadata = {
+                "experiment_type": self.experiment_type,
+                "qubits": self.physical_qubits,
+                "xval": repetition,
+            }
+
+            circs.append(circ)
+
+        return circs
+
+
+@fix_class_docs
+class BaseCompositeHeat(BatchExperiment, ABC):
+    """Base class of HEAT experiments.
+
+    This class implements a batch experiment consisting of multiple HEAT element experiments
+    to compute specific unitary error terms from extracted `d_theta` parameters.
+
+    Class Attributes:
+        - ``__heat_elements__``: A dictionary of fit parameter name and associated experiment
+            class.
+
+    """
+
+    __heat_elements__ = {}
+
+    def __init__(
+        self,
+        heat_experiments: List[HeatElement],
+        backend: Optional[Backend] = None,
+    ):
+        """Create new HEAT experiment.
+
+        Args:
+            heat_experiments: A list of configured HEAT experiments.
+            backend: Optional, the backend to run the experiment on.
+        """
+        super().__init__(experiments=heat_experiments, backend=backend)
+
+    @classmethod
+    def _default_experiment_options(cls) -> Options:
+        """Default experiment options.
+
+        Experiment Options:
+            repetitions (Sequence[int]): A list of the number of echo repetitions.
+            cr_gate (Gate): A gate instance representing the ZX(pi/2).
+        """
+        options = super()._default_experiment_options()
+        options.repetitions = list(range(21))
+        options.cr_gate = circuit.Gate("cr", num_qubits=2, params=[])
+
+        return options
+
+    def set_experiment_options(self, **fields):
+        """Set the analysis options for :meth:`run` method.
+
+        Same experiment options are applied to all subset HEAT experiments.
+
+        Args:
+            fields: The fields to update the options
+        """
+        for comp_exp in self.component_experiment():
+            comp_exp.set_experiment_options(**fields)
+
+        super().set_experiment_options(**fields)
+
+    @classmethod
+    def _default_transpile_options(cls) -> Options:
+        """Default transpile options."""
+        options = super()._default_transpile_options()
+        options.basis_gates = ["sx", "x", "rz", "cr"]
+        options.optimization_level = 0
+
+        return options
+
+    def set_transpile_options(self, **fields):
+        """Set the transpiler options for :meth:`run` method.
+
+        Same transpile options are applied to all subset HEAT experiments.
+
+        Args:
+            fields: The fields to update the options
+        """
+        # TODO wait for #380 to apply individual transpile options to nested experiments
+        for comp_exp in self.component_experiment():
+            comp_exp.set_transpile_options(**fields)
+
+        super().set_transpile_options(**fields)