HEAT experiments

qiskit_experiments/framework/composite/__init__.py

@@ -18,3 +18,5 @@
 # Composite experiment classes
 from .parallel_experiment import ParallelExperiment
 from .batch_experiment import BatchExperiment
+
+from .composite_experiment import sync_experiment_options, sync_transpile_options

qiskit_experiments/framework/composite/composite_experiment.py

@@ -13,8 +13,9 @@
 Composite Experiment abstract base class.
 """
 
-from typing import List, Sequence, Optional, Union
+from typing import List, Sequence, Optional, Union, Type
 from abc import abstractmethod
+import functools
 import warnings
 from qiskit.providers.backend import Backend
 from qiskit_experiments.framework import BaseExperiment, ExperimentData
@@ -131,3 +132,75 @@ def _postprocess_transpiled_circuits(self, circuits, **run_options):
         for expr in self._experiments:
             if not isinstance(expr, CompositeExperiment):
                 expr._postprocess_transpiled_circuits(circuits, **run_options)
+
+
+def sync_transpile_options(
+    composite_cls: Type[CompositeExperiment],
+) -> Type[CompositeExperiment]:
+    """A class decorator that overrides the transpile option setter method.
+
+    This method overrides the behavior of :meth:`set_transpile_options` method.
+    The option values set to the composite instance
+    will be propagated through all component experiments.
+
+    Args:
+        composite_cls: CompositeExperiment subclass to decorate.
+
+    Returns:
+        Composite experiment that implements option synchronization.
+
+    Raises:
+        TypeError: When class is not subclass of :class:`CompositeExperiment`
+    """
+    if not issubclass(composite_cls, CompositeExperiment):
+        raise TypeError("Class is not composite experiment. Cannot override method.")
+
+    options_setter = getattr(composite_cls, "set_transpile_options")
+
+    @functools.wraps(options_setter)
+    def sync_opts(instance, **fields):
+        options_setter(instance, **fields)
+        # set the same options to component experiments
+        for comp in instance.component_experiment():
+            comp.set_transpile_options(**fields)
+
+    # override set method
+    setattr(composite_cls, "set_transpile_options", sync_opts)
+
+    return composite_cls
+
+
+def sync_experiment_options(
+    composite_cls: Type[CompositeExperiment],
+) -> Type[CompositeExperiment]:
+    """A class decorator that overrides the experiment option setter method.
+
+    This method overrides the behavior of :meth:`set_experiment_options` method.
+    The option values set to the composite instance
+    will be propagated through all component experiments.
+
+    Args:
+        composite_cls: CompositeExperiment subclass to decorate.
+
+    Returns:
+        Composite experiment that implements option synchronization.
+
+    Raises:
+        TypeError: When class is not subclass of :class:`CompositeExperiment`
+    """
+    if not issubclass(composite_cls, CompositeExperiment):
+        raise TypeError("Class is not composite experiment. Cannot override method.")
+
+    options_setter = getattr(composite_cls, "set_experiment_options")
+
+    @functools.wraps(options_setter)
+    def sync_opts(instance, **fields):
+        options_setter(instance, **fields)
+        # set the same options to component experiments
+        for comp in instance.component_experiment():
+            comp.set_experiment_options(**fields)
+
+    # override set method
+    setattr(composite_cls, "set_experiment_options", sync_opts)
+
+    return composite_cls

qiskit_experiments/library/hamiltonian/__init__.py

@@ -56,11 +56,10 @@
     :template: autosummary/experiment.rst
 
     HeatElement
-    BatchHeatHelper
 
 
 """
 
-from .heat_base import HeatElement, BatchHeatHelper
+from .heat_base import HeatElement
 from .heat_zx import ZXHeat, ZX90HeatXError, ZX90HeatYError, ZX90HeatZError
 from .heat_analysis import HeatElementAnalysis, HeatAnalysis

qiskit_experiments/library/hamiltonian/heat_analysis.py

@@ -17,7 +17,7 @@
 
 import numpy as np
 
-from qiskit_experiments.curve_analysis import ErrorAmplificationAnalysis
+from qiskit_experiments.curve_analysis import ErrorAmplificationAnalysis, ParameterRepr
 from qiskit_experiments.exceptions import AnalysisError
 from qiskit_experiments.framework import (
     CompositeAnalysis,
@@ -97,22 +97,29 @@ def __init__(
         Raises:
             AnalysisError: When size of ``fit_params`` or ``out_params`` are not 2.
         """
-        super().__init__()
-
         if len(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(fit_params)} input parameter names are specified."
             )
-        self._fit_params = fit_params
 
         if len(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(out_params)} output parameter names are specified."
             )
+
+        analyses = []
+        for fit_parm in fit_params:
+            sub_analysis = HeatElementAnalysis()
+            sub_analysis.set_options(result_parameters=[ParameterRepr("d_theta", fit_parm, "rad")])
+            analyses.append(sub_analysis)
+
+        super().__init__(analyses=analyses)
+
+        self._fit_params = fit_params
         self._out_params = out_params
 
     def _run_analysis(self, experiment_data: ExperimentData):

qiskit_experiments/library/hamiltonian/heat_base.py

@@ -13,14 +13,13 @@
 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
-from qiskit_experiments.curve_analysis import ParameterRepr
-from .heat_analysis import HeatElementAnalysis, HeatAnalysis
+
+from qiskit_experiments.framework import BaseExperiment, Options
+from .heat_analysis import HeatElementAnalysis
 
 
 class HeatElement(BaseExperiment):
@@ -68,11 +67,8 @@ class HeatElement(BaseExperiment):
     # section: note
 
         This class is usually not exposed to end users.
-        Developer of new HEAT experiment must design amplification sequence and
-        instantiate the class implicitly in the batch experiment.
-        The :class:`BatchHeatHelper` provides a convenient wrapper class of
-        the :class:`qiskit_experiments.framework.BatchExperiment` for implementing a
-        typical HEAT experiment.
+        The developer of a new HEAT experiment must design the amplification sequences and
+        create instances of this class implicitly in the batch experiment.
 
     # section: analysis_ref
         :py:class:`HeatElementAnalysis`
@@ -88,7 +84,6 @@ def __init__(
         echo_circ: QuantumCircuit,
         meas_circ: QuantumCircuit,
         backend: Optional[Backend] = None,
-        parameter_name: Optional[str] = "d_theta",
         **kwargs,
     ):
         """Create new HEAT sub experiment.
@@ -99,17 +94,11 @@ def __init__(
             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.
-            parameter_name: A name of :math:`d\\theta` parameter from the
-                amplification fit. The fit parameter is represented by this name
-                in the analysis result.
 
         Keyword Args:
             See :meth:`experiment_options` for details.
         """
-        analysis = HeatElementAnalysis()
-        analysis.set_options(result_parameters=[ParameterRepr("d_theta", parameter_name, "rad")])
-
-        super().__init__(qubits=qubits, backend=backend, analysis=analysis)
+        super().__init__(qubits=qubits, backend=backend, analysis=HeatElementAnalysis())
         self.set_experiment_options(**kwargs)
 
         # These are not user configurable options. Be frozen once assigned.
@@ -165,86 +154,3 @@ def circuits(self) -> List[QuantumCircuit]:
             circs.append(circ)
 
         return circs
-
-
-class BatchHeatHelper(BatchExperiment, ABC):
-    """A wrapper class of ``BatchExperiment`` to implement HEAT experiment.
-
-    # section: overview
-
-        This is a helper class for experiment developers of HEAT experiments.
-        This class overrides the :meth:`set_experiment_options` and :meth:`set_transpile_options`
-        methods of :class:`BatchExperiment` such that they set the options of the
-        individual amplification sub-experiments to the same values. Therefore, from
-        end user's perspective, this experiment behaves as if a single HEAT experiment.
-
-    # section: analysis_ref
-        :py:class:`HeatAnalysis`
-    """
-
-    def __init__(
-        self,
-        heat_experiments: List[HeatElement],
-        heat_analysis: HeatAnalysis,
-        backend: Optional[Backend] = None,
-    ):
-        """Create new HEAT experiment.
-
-        Args:
-            heat_experiments: A list of error amplification sequence that might be
-                implemented as :class:``HeatElement`` instance.
-            heat_analysis: HEAT analysis instance.
-            backend: Optional, the backend to run the experiment on.
-        """
-        super().__init__(experiments=heat_experiments, backend=backend)
-
-        # override analysis. we expect the instance is initialized with
-        # parameter names specific to child amplification experiments.
-        self.analysis = heat_analysis
-
-    @classmethod
-    def _default_experiment_options(cls) -> Options:
-        """Default experiment options.
-
-        Experiment Options:
-            repetitions (Sequence[int]): A list of the number of echo repetitions.
-            heat_gate (Gate): A gate instance representing the entangling sequence.
-        """
-        options = super()._default_experiment_options()
-        options.repetitions = list(range(21))
-        options.heat_gate = circuit.Gate("heat", num_qubits=2, params=[])
-
-        return options
-
-    def set_experiment_options(self, **fields):
-        """Set the analysis options for :meth:`run` method.
-
-        Args:
-            fields: The fields to update the options
-        """
-        # propagate options through all nested amplification experiments.
-        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", "heat"]
-        options.optimization_level = 1
-
-        return options
-
-    def set_transpile_options(self, **fields):
-        """Set the transpiler options for :meth:`run` method.
-
-        Args:
-            fields: The fields to update the options
-        """
-        # propagate options through all nested amplification experiments.
-        for comp_exp in self.component_experiment():
-            comp_exp.set_transpile_options(**fields)
-
-        super().set_transpile_options(**fields)