Half angle

qiskit_experiments/library/__init__.py

@@ -62,6 +62,7 @@
     ~characterization.EFSpectroscopy
     ~characterization.CrossResonanceHamiltonian
     ~characterization.EchoedCrossResonanceHamiltonian
+    ~characterization.HalfAngle
 
 .. _calibration:
 
@@ -109,6 +110,7 @@ class instance to manage parameters and pulse schedules.
     EFSpectroscopy,
     CrossResonanceHamiltonian,
     EchoedCrossResonanceHamiltonian,
+    HalfAngle,
 )
 from .randomized_benchmarking import StandardRB, InterleavedRB
 from .tomography import StateTomography, ProcessTomography

qiskit_experiments/library/calibration/analysis/__init__.py

@@ -13,3 +13,4 @@
 """Calibration Analysis Classes"""
 
 from .drag_analysis import DragCalAnalysis
+from .fine_half_angle_analysis import FineHalfAngleAnalysis

qiskit_experiments/library/calibration/analysis/fine_half_angle_analysis.py

@@ -0,0 +1,30 @@
+# 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.
+
+"""Fine half angle calibration analysis."""
+
+from qiskit_experiments.curve_analysis import ErrorAmplificationAnalysis
+
+
+class FineHalfAngleAnalysis(ErrorAmplificationAnalysis):
+    r"""Analysis class for the HalfAngle experiment to define the fixed parameters.
+
+    # section: note
+
+        The following parameters are fixed.
+
+        * :math:`{\rm apg}` The angle per gate is set by the user, for example pi for a pi-pulse.
+        * :math:`{\rm phase\_offset}` The phase offset in the cosine oscillation.
+        * :math:`{\rm amp}` The amplitude of the oscillation.
+    """
+
+    __fixed_parameters__ = ["angle_per_gate", "phase_offset", "amp"]

qiskit_experiments/library/characterization/__init__.py

@@ -28,6 +28,7 @@
     QubitSpectroscopy
     CrossResonanceHamiltonian
     EchoedCrossResonanceHamiltonian
+    HalfAngle
 
 
 Analysis
@@ -51,3 +52,4 @@
 from .t2ramsey_analysis import T2RamseyAnalysis
 from .cr_hamiltonian import CrossResonanceHamiltonian, EchoedCrossResonanceHamiltonian
 from .cr_hamiltonian_analysis import CrossResonanceHamiltonianAnalysis
+from .half_angle import HalfAngle

qiskit_experiments/library/characterization/half_angle.py

@@ -0,0 +1,123 @@
+# 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.
+
+"""Half angle calibration."""
+
+from typing import Optional
+import numpy as np
+
+from qiskit import QuantumCircuit
+from qiskit.providers import Backend
+
+from qiskit_experiments.framework import BaseExperiment, Options
+from qiskit_experiments.library.calibration.analysis import FineHalfAngleAnalysis
+
+
+class HalfAngle(BaseExperiment):
+    r"""A calibration experiment class to perform half angle calibration.
+
+    # section: overview
+
+        This experiment runs circuits that repeat blocks of :code:`sx - sx - y`
+        circuits inserted in a Ramsey type experiment, i.e. the full gate sequence is thus
+        :code:`Ry(π/2) - [sx - sx - y] ^ n - sx` where :code:`n` is varied, see [1]. This
+        gate sequence is designed to amplify X-Y axis errors. Such errors can occur due to
+        phase errors.
+
+        .. parsed-literal::
+
+                    ┌─────────┐┌────┐┌────┐┌───┐   ┌────┐┌────┐┌───┐┌────┐ ░ ┌─┐
+               q_0: ┤ Ry(π/2) ├┤ sx ├┤ sx ├┤ y ├...┤ sx ├┤ sx ├┤ y ├┤ sx ├─░─┤M├
+                    └─────────┘└────┘└────┘└───┘   └────┘└────┘└───┘└────┘ ░ └╥┘
+            meas: 1/════════════════════════════...═══════════════════════════╩═
+                                                                              0
+
+    # section: reference
+        .. ref_arxiv:: 1 1504.06597
+    """
+
+    __analysis_class__ = FineHalfAngleAnalysis
+
+    @classmethod
+    def _default_experiment_options(cls) -> Options:
+        r"""Default values for the fine amplitude experiment.
+
+        Experiment Options:
+            repetitions (List[int]): A list of the number of times that the gate
+                sequence :code:`[sx sx y]` is repeated.
+        """
+        options = super()._default_experiment_options()
+        options.repetitions = list(range(15))
+
+        return options
+
+    @classmethod
+    def _default_analysis_options(cls) -> Options:
+        r"""Default analysis options.
+
+        If the rotation error is very small the fit may chose a d_theta close to
+        :math:`\pm\pi`. To prevent this we impose bounds on d_theta.
+        """
+        options = super()._default_analysis_options()
+        options.normalization = True
+        options.angle_per_gate = np.pi
+        options.phase_offset = -np.pi / 2
+        options.amp = 1.0
+        options.bounds = {"d_theta": (-np.pi / 2, np.pi / 2)}
+
+        return options
+
+    def __init__(self, qubit: int):
+        """Setup a fine amplitude experiment on the given qubit.
+
+        Args:
+            qubit: The qubit on which to run the fine amplitude calibration experiment.
+        """
+        super().__init__([qubit])
+
+    @staticmethod
+    def _pre_circuit() -> QuantumCircuit:
+        """Return the preparation circuit for the experiment."""
+        return QuantumCircuit(1)
+
+    def circuits(self, backend: Optional[Backend] = None):
+        """Create the circuits for the half angle calibration experiment."""
+
+        circuits = []
+
+        for repetition in self.experiment_options.repetitions:
+            circuit = self._pre_circuit()
+
+            # First ry gate
+            circuit.rz(np.pi / 2, 0)
+            circuit.sx(0)
+            circuit.rz(-np.pi / 2, 0)
+
+            # Error amplifying sequence
+            for _ in range(repetition):
+                circuit.sx(0)
+                circuit.sx(0)
+                circuit.y(0)
+
+            circuit.sx(0)
+            circuit.measure_all()
+
+            circuit.metadata = {
+                "experiment_type": self._type,
+                "qubits": self.physical_qubits,
+                "xval": repetition,
+                "unit": "repetition number",
+            }
+
+            circuits.append(circuit)
+
+        return circuits

test/test_half_angle.py

@@ -0,0 +1,52 @@
+# 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.
+
+"""Test the half angle experiment."""
+
+import numpy as np
+
+from qiskit import QuantumCircuit
+from qiskit.test import QiskitTestCase
+
+from qiskit_experiments.test.mock_iq_backend import MockIQBackend
+from qiskit_experiments.library import HalfAngle
+
+
+class HalfAngleTestBackend(MockIQBackend):
+    """A simple and primitive backend, to be run by the half angle tests."""
+
+    def __init__(self, error: float):
+        """Initialize the class."""
+        super().__init__()
+        self._error = error
+
+    def _compute_probability(self, circuit: QuantumCircuit) -> float:
+        """Returns the probability of measuring the excited state."""
+
+        n_gates = circuit.metadata["xval"]
+
+        return 0.5 * np.sin((-1) ** n_gates * n_gates * self._error) + 0.5
+
+
+class TestHalfAngle(QiskitTestCase):
+    """Class to test the half angle experiment."""
+
+    def test_end_to_end(self):
+        """Test a full experiment end to end."""
+
+        tol = 0.005
+        for error in [-0.05, -0.02, 0.02, 0.05]:
+            hac = HalfAngle(0)
+            exp_data = hac.run(HalfAngleTestBackend(error)).block_for_results()
+            d_theta = exp_data.analysis_results(1).value.value
+
+            self.assertTrue(abs(d_theta - error) < tol)