RamseyXY¶

class RamseyXY(qubit, backend=None, delays=None, osc_freq=2000000.0)[source]¶

Ramsey XY experiment to measure the frequency of a qubit.

Overview

This experiment differs from the T2Ramsey since it is sensitive to the sign of the frequency offset from the main transition. This experiment consists of following two circuits:

(Ramsey X) The second pulse rotates by pi-half around the X axis

           ┌────┐┌─────────────┐┌───────┐┌────┐ ░ ┌─┐
      q_0: ┤ √X ├┤ Delay(τ[s]) ├┤ Rz(θ) ├┤ √X ├─░─┤M├
           └────┘└─────────────┘└───────┘└────┘ ░ └╥┘
measure: 1/════════════════════════════════════════╩═
                                                   0

(Ramsey Y) The second pulse rotates by pi-half around the Y axis

           ┌────┐┌─────────────┐┌───────────┐┌────┐ ░ ┌─┐
      q_0: ┤ √X ├┤ Delay(τ[s]) ├┤ Rz(θ-π/2) ├┤ √X ├─░─┤M├
           └────┘└─────────────┘└───────────┘└────┘ ░ └╥┘
measure: 1/════════════════════════════════════════════╩═
                                                       0

The first and second circuits measure the expectation value along the -Y and X axes, respectively. This experiment therefore tracks the dynamics of the Bloch vector around the equator. The drive frequency of the control electronics defines a reference frame, which differs from the true qubit frequency by \(\Delta\omega\). The Hamiltonian during the Delay instruction is \(H^R = - \frac{1}{2} \Delta\omega\) in the rotating frame, and the propagator will be \(U(\tau) = \exp(-iH^R\tau / \hbar)\) where \(\tau\) is the duration of the delay. By scanning this duration, we can get

\[\begin{split}{\cal E}_x(\tau) = {\rm Re} {\rm Tr}\left( Y U \rho U^\dagger \right) &= - \cos(\Delta\omega\tau) = \sin(\Delta\omega\tau - \frac{\pi}{2}), \\ {\cal E}_y(\tau) = {\rm Re} {\rm Tr}\left( X U \rho U^\dagger \right) &= \sin(\Delta\omega\tau),\end{split}\]

where \(\rho\) is prepared by the first \(\sqrt{\rm X}\) gate. Note that phase difference of these two outcomes \({\cal E}_x, {\cal E}_y\) depends on the sign and the magnitude of the frequency offset \(\Delta\omega\). By contrast, the measured data in the standard Ramsey experiment does not depend on the sign of \(\Delta\omega\), because \(\cos(-\Delta\omega\tau) = \cos(\Delta\omega\tau)\).

The experiment also allows users to add a small frequency offset to better resolve any oscillations. This is implemented by a virtual Z rotation in the circuits. In the circuit above it appears as the delay-dependent angle θ(τ).

Analysis Class Reference

RamseyXYAnalysis

Experiment Options

These options can be set by set_experiment_options() method.

Parameters:

delays (list) – The list of delays that will be scanned in the experiment, in seconds.
osc_freq (float) – A frequency shift in Hz that will be applied by means of a virtual Z rotation to increase the frequency of the measured oscillation.

Transpiler Options

This option can be set by set_transpile_options() method.

This option is used for circuit optimization. See the documentation of qiskit.transpile for available options.

Backend Run Options

This option can be set by set_run_options() method.

This option is used for controlling job execution condition. Note that this option is provider dependent. See provider’s backend runner API for available options. See the documentation of IBMQBackend.run for the IBM Quantum Service.

Initialization

Create new experiment.

Parameters:

qubit (int) – The qubit on which to run the Ramsey XY experiment.
backend (Optional[Backend]) – Optional, the backend to run the experiment on.
delays (Optional[List]) – The delays to scan, in seconds.
osc_freq (float) – the oscillation frequency induced by the user through a virtual Rz rotation. This quantity is given in Hz.

Attributes

`RamseyXY.analysis`	Return the analysis instance for the experiment
`RamseyXY.analysis_options`	Return the analysis options for `run()` analysis.
`RamseyXY.backend`	Return the backend for the experiment
`RamseyXY.experiment_options`	Return the options for the experiment.
`RamseyXY.experiment_type`	Return experiment type.
`RamseyXY.num_qubits`	Return the number of qubits for the experiment.
`RamseyXY.physical_qubits`	Return the device qubits for the experiment.
`RamseyXY.run_options`	Return options values for the experiment `run()` method.
`RamseyXY.transpile_options`	Return the transpiler options for the `run()` method.

Methods

`RamseyXY.circuits`()	Create the circuits for the Ramsey XY characterization experiment.
`RamseyXY.config`()	Return the config dataclass for this experiment
`RamseyXY.copy`()	Return a copy of the experiment
`RamseyXY.enable_restless`([rep_delay, ...])	Enables a restless experiment by setting the restless run options and the restless data processor.
`RamseyXY.from_config`(config)	Initialize an experiment from experiment config
`RamseyXY.run`([backend, analysis, timeout])	Run an experiment and perform analysis.
`RamseyXY.set_experiment_options`(**fields)	Set the experiment options.
`RamseyXY.set_run_options`(**fields)	Set options values for the experiment `run()` method.
`RamseyXY.set_transpile_options`(**fields)	Set the transpiler options for `run()` method.