Reduce documentation build time and update docs (#1549)

* Reduce number of circuits in jupyter-execute examples where possible
(T2 manual, tphi, quantum volume, randomized benchmarking, ramsey_xy)
and re-run analysis rather than running a new experiment where possible
  (visualization tutorial, t2ramsey)
* Remove outdated references to qiskit-dynamics
* Use AerSimulator rather than a fake backend where possible
* Fix misleading description of T2 delay meaning
* Fix fit parameter guesses in t2ramsey.rst
* Various wording and formatting fixes (print circuit with finite delay
instead of 0 delay; fix indentation error in example visualization code;
...)
* Remove old Qiskit Pulse warning filters

Author: wshanks

docs/manuals/characterization/t2hahn.rst

@@ -63,13 +63,14 @@ and can analytically extract the desired values.
 
     qubit = 0
     conversion_factor = 1e-6 # our delay will be in micro-sec
-    delays = list(range(0, 50, 1) )
-    delays = [float(_) * conversion_factor for _ in delays]
+    delays = list(range(0, 51, 5) )
+    # Round so that the delay gates in the circuit display does not have trailing 9999's
+    delays = [round(float(_) * conversion_factor, ndigits=6) for _ in delays]
     number_of_echoes = 1
 
     # Create a T2Hahn experiment. Print the first circuit as an example
     exp1 = T2Hahn(physical_qubits=(qubit,), delays=delays, num_echoes=number_of_echoes)
-    print(exp1.circuits()[0])
+    print(exp1.circuits()[1])
 
 
 We run the experiment on a simple simulated backend tailored
@@ -118,7 +119,7 @@ curve is expected to decay toward :math:`0.5`, the natural choice for
 parameter :math:`B` is :math:`0.5`. When there is no :math:`T_2` error,
 we would expect that the probability to measure ``1`` is :math:`100\%`,
 therefore we will guess that A is :math:`0.5`. In this experiment,
-``t2hahn`` is the parameter of interest. Good estimate for it is the
+``t2hahn`` is the parameter of interest. A good estimate for it is the
 value computed in previous experiments on this qubit or a similar value
 computed for other qubits.
 
@@ -143,61 +144,35 @@ Number of echoes
 ----------------
 
 The user can provide the number of echoes that the circuit will perform.
-This will determine the amount of delay and echo gates. As the number of
-echoes increases, the total time of the circuit will grow. The echoes
+This will determine the amount of delay and echo gates.
+The echoes
 decrease the effects of :math:`T_{1}` noise and frequency inaccuracy
 estimation. Due to that, the Hahn Echo experiment improves our estimate
 for :math:`T_{2}`. In the following code, we will compare results of the
 Hahn experiment with ``0`` echoes and ``1`` echo. The analysis should
 fail for the circuit with ``0`` echoes. In order to see it, we will add
 frequency to the qubit and see how it affect the estimated :math:`T_2`.
-The list ``delays`` is the times provided to each delay gate, not the
-total delay time.
 
 .. jupyter-execute::
 
     import numpy as np
 
     qubit2 = 0
-    # set the desired delays
-    conversion_factor = 1e-6
-    
-    # The delays aren't equally spaced due the behavior of the exponential
-    # decay curve where the change in the result during earlier times is 
-    # larger than later times. In addition, since the total delay is 
-    # 'delay * 2 * num_of_echoes', the construction of the delays for 
-    # each experiment will be different such that their total length
-    # will be the same.
-    
-    # Delays for Hahn Echo Experiment with 0 echoes
-    delays2 = np.append(
-                        (np.linspace(0.0, 51.0, num=26)).astype(float),
-                        (np.linspace(53, 100.0, num=25)).astype(float),
-                    )
-    
-    delays2 = [float(_) * conversion_factor for _ in delays2]
-    
-    # Delays for Hahn Echo Experiment with 1 echo
-    delays3 = np.append(
-                        (np.linspace(0.0, 25.5, num=26)).astype(float),
-                        (np.linspace(26.5, 50, num=25)).astype(float),
-                    )  
-    delays3 = [float(_) * conversion_factor for _ in delays3]
 
     num_echoes = 1
-    estimated_t2hahn2 = 30 * conversion_factor
+    estimated_t2hahn2 = 30e-6
 
     # Create a T2Hahn experiment with 0 echoes
-    exp2_0echoes = T2Hahn((qubit2,), delays2, num_echoes=0)
+    exp2_0echoes = T2Hahn((qubit2,), delays, num_echoes=0)
     exp2_0echoes.analysis.set_options(p0={"amp": 0.5, "tau": estimated_t2hahn2, "base": 0.5})
-    print("The first circuit of hahn echo experiment with 0 echoes:")
-    print(exp2_0echoes.circuits()[0])
+    print("The second circuit of hahn echo experiment with 0 echoes:")
+    print(exp2_0echoes.circuits()[1])
 
     # Create a T2Hahn experiment with 1 echo. Print the first circuit as an example
-    exp2_1echoes = T2Hahn((qubit2,), delays3, num_echoes=num_echoes)
+    exp2_1echoes = T2Hahn((qubit2,), delays, num_echoes=num_echoes)
     exp2_1echoes.analysis.set_options(p0={"amp": 0.5, "tau": estimated_t2hahn2, "base": 0.5})
-    print("The first circuit of hahn echo experiment with 1 echo:")
-    print(exp2_1echoes.circuits()[0])
+    print("The second circuit of hahn echo experiment with 1 echo:")
+    print(exp2_1echoes.circuits()[1])
 
 
 

docs/manuals/characterization/t2ramsey.rst

@@ -117,16 +117,13 @@ computed for other qubits.
 .. jupyter-execute::
 
     user_p0={
-        "A": 0.5,
-        "T2star": 20e-6,
-        "f": 110000,
+        "amp": 0.5,
+        "tau": 20e-6,
+        "freq": 110000,
         "phi": 0,
-        "B": 0.5
-            }
-    exp_with_p0 = T2Ramsey((qubit,), delays, osc_freq=1e5)
-    exp_with_p0.analysis.set_options(p0=user_p0)
-    exp_with_p0.set_transpile_options(scheduling_method='asap')
-    expdata_with_p0 = exp_with_p0.run(backend=backend, shots=2000, seed_simulator=101)
+        "base": 0.5
+    }
+    expdata_with_p0 = exp1.analysis.run(expdata1, p0=user_p0)
     expdata_with_p0.block_for_results()
 
     # Display fit figure

docs/manuals/characterization/tphi.rst

@@ -45,8 +45,8 @@ From the :math:`T_1` and :math:`T_2` estimates, we compute the results for
     backend = AerSimulator.from_backend(FakePerth(), noise_model=noise_model)
 
     # Time intervals to wait before measurement for t1 and t2
-    delays_t1 = np.arange(1e-6, 300e-6, 10e-6)
-    delays_t2 = np.arange(1e-6, 50e-6, 2e-6)
+    delays_t1 = np.arange(1e-6, 300e-6, 30e-6)
+    delays_t2 = np.arange(1e-6, 600e-6, 30e-6)
 
 By default, the :class:`.Tphi` experiment will use the Hahn echo experiment for its transverse
 relaxation time estimate. We can see that the component experiments of the batch 
@@ -65,7 +65,7 @@ Run the experiment and print results:
 
 .. jupyter-execute::
 
-    expdata = exp.run(backend=backend, seed_simulator=100).block_for_results()
+    expdata = exp.run(backend=backend, seed_simulator=100, shots=2000).block_for_results()
     display(expdata.analysis_results("T_phi", dataframe=True))
 
 You can also retrieve the results and figures of the constituent experiments. :class:`.T1`:
@@ -88,19 +88,20 @@ experiment:
 
 .. jupyter-execute::
 
+    delays_t2ramsey = np.arange(1e-6, 200e-6, 10e-6)
     exp = Tphi(physical_qubits=(0,), 
                delays_t1=delays_t1, 
-               delays_t2=delays_t2, 
+               delays_t2=delays_t2ramsey,
                t2type="ramsey", 
-               osc_freq=1e5)
+               osc_freq=15e3)
 
     exp.component_experiment(1).circuits()[-1].draw(output="mpl", style="iqp")
 
 Run and display results:
 
 .. jupyter-execute::
 
-    expdata = exp.run(backend=backend, seed_simulator=100).block_for_results()
+    expdata = exp.run(backend=backend, seed_simulator=100, shots=2000).block_for_results()
     display(expdata.analysis_results("T_phi", dataframe=True))
     display(expdata.figure(1))
 

docs/manuals/verification/quantum_volume.rst

@@ -25,9 +25,9 @@ probability` > 2/3 with confidence level > 0.977 (corresponding to
 z_value = 2), and at least 100 trials have been ran.
 
 .. note::
-    This tutorial requires the :external+qiskit_aer:doc:`qiskit-aer <index>` and :external+qiskit_ibm_runtime:doc:`qiskit-ibm-runtime <index>`
-    packages to run simulations.  You can install them with ``python -m pip
-    install qiskit-aer qiskit-ibm-runtime``.
+    This tutorial requires the :external+qiskit_aer:doc:`qiskit-aer <index>`
+    package to run simulations.  You can install it with ``python -m pip
+    install qiskit-aer``.
 
 .. jupyter-execute::
 
@@ -36,9 +36,13 @@ z_value = 2), and at least 100 trials have been ran.
 
     # For simulation
     from qiskit_aer import AerSimulator
-    from qiskit_ibm_runtime.fake_provider import FakeSydneyV2
-    
-    backend = AerSimulator.from_backend(FakeSydneyV2())
+    from qiskit_aer.noise import NoiseModel, depolarizing_error
+
+    noise_model = NoiseModel()
+    noise_model.add_all_qubit_quantum_error(depolarizing_error(5e-4, 1), ["sx", "x"])
+    noise_model.add_all_qubit_quantum_error(depolarizing_error(0, 1), ["rz"])
+    noise_model.add_all_qubit_quantum_error(depolarizing_error(1e-2, 2), ["cx"])
+    backend = AerSimulator(noise_model=noise_model, seed_simulator=42)
 
 QV experiment
 -------------
@@ -70,7 +74,7 @@ The analysis results of the QV Experiment are:
 
 -  The mean heavy-output probabilities (HOP) and standard deviation
 
--  The calculated quantum volume, which will be None if the experiment
+-  The calculated quantum volume, which will be 1 if the experiment
    does not pass the threshold
 
 Extra data included in the analysis results includes
@@ -114,7 +118,7 @@ re-running the experiment.
 
 .. jupyter-execute::
 
-    qv_exp.set_experiment_options(trials=60)
+    qv_exp.set_experiment_options(trials=10)
     expdata2 = qv_exp.run(backend, analysis=None).block_for_results()
     expdata2.add_data(expdata.data())
     qv_exp.analysis.run(expdata2).block_for_results()
@@ -134,7 +138,7 @@ enhancements might be required (See Ref. [2]_ for details).
 
 .. jupyter-execute::
 
-    exps = [QuantumVolume(tuple(range(i)), trials=200) for i in range(3, 6)]
+    exps = [QuantumVolume(tuple(range(i))) for i in range(3, 5)]
 
     batch_exp = BatchExperiment(exps)
     batch_exp.set_transpile_options(optimization_level=3)

docs/manuals/verification/randomized_benchmarking.rst

@@ -12,9 +12,9 @@ error estimates for the quantum device, by calculating the Error Per Clifford. S
 explanation on the RB method, which is based on Refs. [1]_ [2]_.
 
 .. note::
-    This tutorial requires the :external+qiskit_aer:doc:`qiskit-aer <index>` and :external+qiskit_ibm_runtime:doc:`qiskit-ibm-runtime <index>`
-    packages to run simulations.  You can install them with ``python -m pip
-    install qiskit-aer qiskit-ibm-runtime``.
+    This tutorial requires the :external+qiskit_aer:doc:`qiskit-aer <index>`
+    package to run simulations.  You can install it with ``python -m pip
+    install qiskit-aer``.
 
 .. jupyter-execute::
 
@@ -25,9 +25,13 @@ explanation on the RB method, which is based on Refs. [1]_ [2]_.
 
     # For simulation
     from qiskit_aer import AerSimulator
-    from qiskit_ibm_runtime.fake_provider import FakePerth
-    
-    backend = AerSimulator.from_backend(FakePerth())
+    from qiskit_aer.noise import NoiseModel, depolarizing_error
+
+    noise_model = NoiseModel()
+    noise_model.add_all_qubit_quantum_error(depolarizing_error(5e-3, 1), ["sx", "x"])
+    noise_model.add_all_qubit_quantum_error(depolarizing_error(0, 1), ["rz"])
+    noise_model.add_all_qubit_quantum_error(depolarizing_error(5e-2, 2), ["cx"])
+    backend = AerSimulator(noise_model=noise_model)
 
 Standard RB experiment
 ----------------------
@@ -51,6 +55,12 @@ in order to generate the RB circuits and run them on a backend:
    sequences are constructed by appending additional Clifford samples to
    shorter sequences. The default is ``False``
 
+.. note::
+   In the examples here, the sequence lengths and number of samples are chosen
+   to be as low as possible while still producing typical results in order to
+   minimize the simulation times. For accurate results, larger numbers may be
+   necessary.
+
 The analysis results of the RB Experiment may include:
 
 -  ``EPC``: The estimated Error Per Clifford
@@ -101,8 +111,8 @@ interleaved RB experiment will always give you accurate error value :math:`e_i`.
 
 .. jupyter-execute::
 
-    lengths = np.arange(1, 800, 200)
-    num_samples = 10
+    lengths = [1, 10, 30, 80, 150] + np.arange(200, 1100, 200).tolist()
+    num_samples = 5
     seed = 1010
     qubits = [0]
 
@@ -168,9 +178,9 @@ The EPGs of two-qubit RB are analyzed with the corrected EPC if available.
 
 .. jupyter-execute::
 
-    lengths_2_qubit = np.arange(1, 200, 30)
-    lengths_1_qubit = np.arange(1, 800, 200)
-    num_samples = 10
+    lengths_2_qubit = np.arange(1, 80, 10)
+    lengths_1_qubit = [1, 10, 30, 80, 150] + np.arange(200, 1100, 200).tolist()
+    num_samples = 5
     seed = 1010
     qubits = (1, 2)
 
@@ -266,8 +276,8 @@ Let's run an interleaved RB experiment on two qubits:
 
 .. jupyter-execute::
 
-    lengths = np.arange(1, 200, 30)
-    num_samples = 10
+    lengths = [1, 2, 4, 8] + np.arange(10, 80, 10).tolist()
+    num_samples = 3
     seed = 1010
     qubits = (1, 2)
 
@@ -278,8 +288,6 @@ Let's run an interleaved RB experiment on two qubits:
     int_expdata2 = int_exp2.run(backend).block_for_results()
     int_results2 = int_expdata2.analysis_results(dataframe=True)
 
-.. jupyter-execute::
-
     # View result data
     display(int_expdata2.figure(0))
     display(int_results2)

docs/tutorials/data_processor.rst

@@ -64,22 +64,6 @@ To illustrate the data processing module, we consider an example
 in which we measure qubit relaxation with different data levels.
 The code below sets up the :class:`.T1` experiment.
 
-.. jupyter-execute::
-    :hide-code:
-
-    import warnings
-
-    warnings.filterwarnings(
-        "ignore",
-        message=".*Due to the deprecation of Qiskit Pulse.*",
-        category=DeprecationWarning,
-    )
-    warnings.filterwarnings(
-        "ignore",
-        message=".*The entire Qiskit Pulse package is being deprecated.*",
-        category=DeprecationWarning,
-    )
-
 .. jupyter-execute::
 
     import numpy as np