From a149464ea7e1585b677ec73f29a851d5fff03f4f Mon Sep 17 00:00:00 2001 From: Arnau Casau <47946624+arnaucasau@users.noreply.github.com> Date: Mon, 23 Dec 2024 19:53:42 +0100 Subject: [PATCH] Regenerate addons with images with alt text (#2527) This PR regenerates `qiskit-addon-mpf`, `qiskit-addon-utils`, and `qiskit-addon-obp` after adding the alt text in all their images. Commands ran: ```bash npm run regen-apis -- -p qiskit-addon-obp npm run regen-apis -- -p qiskit-addon-utils npm run regen-apis -- -p qiskit-addon-mpf ``` --- ...backends-quimb-circuit-circuit-evolver.mdx | 6 ++-- .../backends-quimb-circuit-circuit-state.mdx | 2 +- .../backends-quimb-circuit.mdx | 10 +++--- .../backends-quimb-layers-layer-model.mdx | 12 +++---- ...ackends-quimb-layers-layerwise-evolver.mdx | 2 +- .../backends-quimb-layers.mdx | 10 +++--- .../backends-quimb-tebd-mpo-state.mdx | 22 ++++++------ .../backends-quimb-tebd-tebd-evolver.mdx | 22 ++++++------ .../qiskit-addon-mpf/backends-quimb-tebd.mdx | 16 ++++----- .../backends-tenpy-layers-layer-model.mdx | 4 +-- .../backends-tenpy-layers.mdx | 6 ++-- docs/api/qiskit-addon-mpf/backends.mdx | 16 ++++----- docs/api/qiskit-addon-mpf/costs.mdx | 6 ++-- docs/api/qiskit-addon-mpf/dynamic.mdx | 6 ++-- .../api/qiskit-addon-obp/qiskit-addon-obp.mdx | 6 ++-- .../api/qiskit-addon-obp/utils-operations.mdx | 18 +++++----- docs/api/qiskit-addon-obp/utils-simplify.mdx | 4 +-- .../api/qiskit-addon-obp/utils-truncating.mdx | 6 ++-- .../qiskit-addon-obp/utils-visualization.mdx | 30 ++++++++-------- .../qiskit-addon-utils/problem-generators.mdx | 16 ++++----- ...ing-transpiler-passes-collect-op-color.mdx | 10 +++--- ...cing-transpiler-passes-collect-op-size.mdx | 10 +++--- ...cing-transpiler-passes-collect-op-type.mdx | 10 +++--- docs/api/qiskit-addon-utils/slicing.mdx | 32 +++++++++--------- public/api/qiskit-addon-mpf/0.1/objects.inv | Bin 1568 -> 1574 bytes public/api/qiskit-addon-mpf/objects.inv | Bin 4403 -> 4407 bytes ...skit_addon_mpf-backends-quimb_layers-2.png | Bin 32884 -> 32885 bytes ...skit_addon_mpf-backends-quimb_layers-3.png | Bin 43085 -> 43086 bytes ...skit_addon_mpf-backends-tenpy_layers-2.png | Bin 32884 -> 32885 bytes ...skit_addon_mpf-backends-tenpy_layers-3.png | Bin 43085 -> 43086 bytes ...iskit_addon_obp-utils-visualization-10.png | Bin 13809 -> 13810 bytes ...iskit_addon_obp-utils-visualization-12.png | Bin 16643 -> 16644 bytes ...iskit_addon_obp-utils-visualization-14.png | Bin 18098 -> 18099 bytes ...qiskit_addon_obp-utils-visualization-2.png | Bin 22833 -> 22834 bytes ...qiskit_addon_obp-utils-visualization-4.png | Bin 29161 -> 29162 bytes ...qiskit_addon_obp-utils-visualization-6.png | Bin 15360 -> 15361 bytes ...qiskit_addon_obp-utils-visualization-8.png | Bin 21541 -> 21542 bytes ...iskit_addon_utils-problem_generators-1.png | Bin 27044 -> 27045 bytes scripts/js/commands/checkImages.ts | 3 -- 39 files changed, 141 insertions(+), 144 deletions(-) diff --git a/docs/api/qiskit-addon-mpf/backends-quimb-circuit-circuit-evolver.mdx b/docs/api/qiskit-addon-mpf/backends-quimb-circuit-circuit-evolver.mdx index ff783a528ec..5da21778925 100644 --- a/docs/api/qiskit-addon-mpf/backends-quimb-circuit-circuit-evolver.mdx +++ b/docs/api/qiskit-addon-mpf/backends-quimb-circuit-circuit-evolver.mdx @@ -20,8 +20,8 @@ python_api_name: qiskit_addon_mpf.backends.quimb_circuit.CircuitEvolver **Parameters** * **evolution\_state** ([*CircuitState*](backends-quimb-circuit-circuit-state "qiskit_addon_mpf.backends.quimb_circuit.CircuitState")) – a reference to the time-evolution state. - * **circuit** (*QuantumCircuit*) – the template circuit encoding the time-evolution of a single Trotter step. This circuit **must** be parameterized (see [`Parameter`](/api/qiskit/qiskit.circuit.Parameter "(in Qiskit v1.2)") in place of the Trotter methods time step. This parameter must be named `dt`. - * **dt** ([*float*](https://docs.python.org/3/library/functions.html#float "(in Python v3.13)")) – the time step that will be used and later bound to the [`Parameter`](/api/qiskit/qiskit.circuit.Parameter "(in Qiskit v1.2)") of the `circuit` object. + * **circuit** (*QuantumCircuit*) – the template circuit encoding the time-evolution of a single Trotter step. This circuit **must** be parameterized (see [`Parameter`](/api/qiskit/qiskit.circuit.Parameter "(in Qiskit v1.3)") in place of the Trotter methods time step. This parameter must be named `dt`. + * **dt** ([*float*](https://docs.python.org/3/library/functions.html#float "(in Python v3.13)")) – the time step that will be used and later bound to the [`Parameter`](/api/qiskit/qiskit.circuit.Parameter "(in Qiskit v1.3)") of the `circuit` object. ## Attributes @@ -46,7 +46,7 @@ python_api_name: qiskit_addon_mpf.backends.quimb_circuit.CircuitEvolver ### circuit - The parameterized [`QuantumCircuit`](/api/qiskit/qiskit.circuit.QuantumCircuit "(in Qiskit v1.2)") describing the Trotter step. + The parameterized [`QuantumCircuit`](/api/qiskit/qiskit.circuit.QuantumCircuit "(in Qiskit v1.3)") describing the Trotter step. ## Methods diff --git a/docs/api/qiskit-addon-mpf/backends-quimb-circuit-circuit-state.mdx b/docs/api/qiskit-addon-mpf/backends-quimb-circuit-circuit-state.mdx index 8d8797dd454..8b72b1d0e96 100644 --- a/docs/api/qiskit-addon-mpf/backends-quimb-circuit-circuit-state.mdx +++ b/docs/api/qiskit-addon-mpf/backends-quimb-circuit-circuit-state.mdx @@ -39,7 +39,7 @@ python_api_name: qiskit_addon_mpf.backends.quimb_circuit.CircuitState Compute the overlap of this state with the provided initial state. - This implementation only supports instances of [`qiskit.circuit.QuantumCircuit`](/api/qiskit/qiskit.circuit.QuantumCircuit "(in Qiskit v1.2)") for `initial_state`. + This implementation only supports instances of [`qiskit.circuit.QuantumCircuit`](/api/qiskit/qiskit.circuit.QuantumCircuit "(in Qiskit v1.3)") for `initial_state`. **Parameters** diff --git a/docs/api/qiskit-addon-mpf/backends-quimb-circuit.mdx b/docs/api/qiskit-addon-mpf/backends-quimb-circuit.mdx index fbc09e71030..c02be8d967a 100644 --- a/docs/api/qiskit-addon-mpf/backends-quimb-circuit.mdx +++ b/docs/api/qiskit-addon-mpf/backends-quimb-circuit.mdx @@ -14,7 +14,7 @@ python_api_name: qiskit_addon_mpf.backends.quimb_circuit `qiskit_addon_mpf.backends.quimb_circuit` -A circuit-based time-evolution backend using [`quimb`](https://quimb.readthedocs.io/en/latest/autoapi/quimb/index.html#module-quimb "(in quimb v1.9)"). +A circuit-based time-evolution backend using [`quimb`](https://quimb.readthedocs.io/en/latest/autoapi/quimb/index.html#module-quimb "(in quimb v1.10)"). This backend is only available if the optional dependencies have been installed: @@ -31,7 +31,7 @@ A circuit-based time-evolution backend using [`quimb`](https://quimb.readthedocs ## Underlying method -Quimb boasts direct support for the simulation of quantum circuits in the form of its tensor-network based [`quimb.tensor.Circuit`](https://quimb.readthedocs.io/en/latest/autoapi/quimb/tensor/index.html#quimb.tensor.Circuit "(in quimb v1.9)") representation. We can leverage this, to bypass any explicit time-evolution algorithm and instead directly encode the time-evolution in a [`QuantumCircuit`](/api/qiskit/qiskit.circuit.QuantumCircuit "(in Qiskit v1.2)") and use [`quimb`](https://quimb.readthedocs.io/en/latest/autoapi/quimb/index.html#module-quimb "(in quimb v1.9)") to compute the overlap between two such circuits. For more information, check out their guide on [Quantum Circuits](https://quimb.readthedocs.io/en/latest/tensor-circuit.html "(in quimb v1.9)"). +Quimb boasts direct support for the simulation of quantum circuits in the form of its tensor-network based [`quimb.tensor.Circuit`](https://quimb.readthedocs.io/en/latest/autoapi/quimb/tensor/index.html#quimb.tensor.Circuit "(in quimb v1.10)") representation. We can leverage this, to bypass any explicit time-evolution algorithm and instead directly encode the time-evolution in a [`QuantumCircuit`](/api/qiskit/qiskit.circuit.QuantumCircuit "(in Qiskit v1.3)") and use [`quimb`](https://quimb.readthedocs.io/en/latest/autoapi/quimb/index.html#module-quimb "(in quimb v1.10)") to compute the overlap between two such circuits. For more information, check out their guide on [Quantum Circuits](https://quimb.readthedocs.io/en/latest/tensor-circuit.html "(in quimb v1.10)"). ## Code example @@ -44,7 +44,7 @@ The [`IdentityStateFactory`](dynamic#identitystatefactory "qiskit_addon_mpf.dyna >>> identity_factory = CircuitState ``` -The setup of the [`CircuitEvolver`](backends-quimb-circuit-circuit-evolver "qiskit_addon_mpf.backends.quimb_circuit.CircuitEvolver") is slightly more involved. It requires a **parameterized** [`QuantumCircuit`](/api/qiskit/qiskit.circuit.QuantumCircuit "(in Qiskit v1.2)") object as its input where the [`Parameter`](/api/qiskit/qiskit.circuit.Parameter "(in Qiskit v1.2)") should take the place of the Trotter methods time step (`dt`). +The setup of the [`CircuitEvolver`](backends-quimb-circuit-circuit-evolver "qiskit_addon_mpf.backends.quimb_circuit.CircuitEvolver") is slightly more involved. It requires a **parameterized** [`QuantumCircuit`](/api/qiskit/qiskit.circuit.QuantumCircuit "(in Qiskit v1.3)") object as its input where the [`Parameter`](/api/qiskit/qiskit.circuit.Parameter "(in Qiskit v1.3)") should take the place of the Trotter methods time step (`dt`). To show how such a parameterized Trotter circuit template is constructed, we reuse the same Hamiltonian and second-order Suzuki-Trotter formula as in [`quimb_layers`](backends-quimb-layers#module-qiskit_addon_mpf.backends.quimb_layers "qiskit_addon_mpf.backends.quimb_layers"). @@ -59,7 +59,7 @@ To show how such a parameterized Trotter circuit template is constructed, we reu ... ) ``` -But this time, we specify a [`Parameter`](/api/qiskit/qiskit.circuit.Parameter "(in Qiskit v1.2)") as the `time` argument when constructing the actual circuits. +But this time, we specify a [`Parameter`](/api/qiskit/qiskit.circuit.Parameter "(in Qiskit v1.3)") as the `time` argument when constructing the actual circuits. ```python >>> from functools import partial @@ -73,7 +73,7 @@ But this time, we specify a [`Parameter`](/api/qiskit/qiskit.circuit.Parameter " ``` - It is **necessary** that the name of the [`Parameter`](/api/qiskit/qiskit.circuit.Parameter "(in Qiskit v1.2)") is `dt`! + It is **necessary** that the name of the [`Parameter`](/api/qiskit/qiskit.circuit.Parameter "(in Qiskit v1.3)") is `dt`! We can choose a higher order Trotter formula for the `exact_evolver_factory`. But note, that we must once again use a parameterized circuit, even if we immediately bind its parameter when constructing the `partial` function. diff --git a/docs/api/qiskit-addon-mpf/backends-quimb-layers-layer-model.mdx b/docs/api/qiskit-addon-mpf/backends-quimb-layers-layer-model.mdx index 1a340707aa4..e179fba905e 100644 --- a/docs/api/qiskit-addon-mpf/backends-quimb-layers-layer-model.mdx +++ b/docs/api/qiskit-addon-mpf/backends-quimb-layers-layer-model.mdx @@ -9,15 +9,15 @@ python_api_name: qiskit_addon_mpf.backends.quimb_layers.LayerModel # LayerModel - Bases: [`LocalHam1D`](https://quimb.readthedocs.io/en/latest/autoapi/quimb/tensor/tensor_1d_tebd/index.html#quimb.tensor.tensor_1d_tebd.LocalHam1D "(in quimb v1.9)") + Bases: [`LocalHam1D`](https://quimb.readthedocs.io/en/latest/autoapi/quimb/tensor/tensor_1d_tebd/index.html#quimb.tensor.tensor_1d_tebd.LocalHam1D "(in quimb v1.10)") A model for representing a layer of time-evolution interactions. - Essentially, this class is a simple wrapper of [`quimb.tensor.LocalHam1D`](https://quimb.readthedocs.io/en/latest/autoapi/quimb/tensor/index.html#quimb.tensor.LocalHam1D "(in quimb v1.9)"). Its main purpose is to provide a simple interface for constructing a Quimb-compatible Hamiltonian from Qiskit objects. + Essentially, this class is a simple wrapper of [`quimb.tensor.LocalHam1D`](https://quimb.readthedocs.io/en/latest/autoapi/quimb/tensor/index.html#quimb.tensor.LocalHam1D "(in quimb v1.10)"). Its main purpose is to provide a simple interface for constructing a Quimb-compatible Hamiltonian from Qiskit objects. Initialize a [`LayerModel`](#qiskit_addon_mpf.backends.quimb_layers.LayerModel "qiskit_addon_mpf.backends.quimb_layers.LayerModel") instance. - Most of the arguments below are simply forwarded to [`quimb.tensor.LocalHam1D`](https://quimb.readthedocs.io/en/latest/autoapi/quimb/tensor/index.html#quimb.tensor.LocalHam1D "(in quimb v1.9)") so check out its documentation for more details. + Most of the arguments below are simply forwarded to [`quimb.tensor.LocalHam1D`](https://quimb.readthedocs.io/en/latest/autoapi/quimb/tensor/index.html#quimb.tensor.LocalHam1D "(in quimb v1.10)") so check out its documentation for more details. **Parameters** @@ -40,13 +40,13 @@ python_api_name: qiskit_addon_mpf.backends.quimb_layers.LayerModel ### from\_quantum\_circuit - Construct a [`LayerModel`](#qiskit_addon_mpf.backends.quimb_layers.LayerModel "qiskit_addon_mpf.backends.quimb_layers.LayerModel") from a [`QuantumCircuit`](/api/qiskit/qiskit.circuit.QuantumCircuit "(in Qiskit v1.2)"). + Construct a [`LayerModel`](#qiskit_addon_mpf.backends.quimb_layers.LayerModel "qiskit_addon_mpf.backends.quimb_layers.LayerModel") from a [`QuantumCircuit`](/api/qiskit/qiskit.circuit.QuantumCircuit "(in Qiskit v1.3)"). You can see an example of this function in action in the docs of `quimb_layers`. **Parameters** - * **circuit** ([*QuantumCircuit*](/api/qiskit/qiskit.circuit.QuantumCircuit "(in Qiskit v1.2)")) – the quantum circuit to parse. + * **circuit** ([*QuantumCircuit*](/api/qiskit/qiskit.circuit.QuantumCircuit "(in Qiskit v1.3)")) – the quantum circuit to parse. * **scaling\_factor** ([*float*](https://docs.python.org/3/library/functions.html#float "(in Python v3.13)")) – a factor with which to scale the term strengths. This can be used to apply (for example) a time step scaling factor. It may also be used (e.g.) to split onsite terms into two layers (even and odd) with \$0.5\$ of the strength, each. * **keep\_only\_odd** ([*bool*](https://docs.python.org/3/library/functions.html#bool "(in Python v3.13)") *| None*) – the value to use for [`keep_only_odd`](#qiskit_addon_mpf.backends.quimb_layers.LayerModel.keep_only_odd "qiskit_addon_mpf.backends.quimb_layers.LayerModel.keep_only_odd"). * **kwargs** – any additional keyword arguments to pass to the [`LayerModel`](#qiskit_addon_mpf.backends.quimb_layers.LayerModel "qiskit_addon_mpf.backends.quimb_layers.LayerModel") constructor. @@ -82,7 +82,7 @@ python_api_name: qiskit_addon_mpf.backends.quimb_layers.LayerModel **Return type** - [*ndarray*](https://numpy.org/doc/stable/reference/generated/numpy.ndarray.html#numpy.ndarray "(in NumPy v2.1)") | None + [*ndarray*](https://numpy.org/doc/stable/reference/generated/numpy.ndarray.html#numpy.ndarray "(in NumPy v2.2)") | None diff --git a/docs/api/qiskit-addon-mpf/backends-quimb-layers-layerwise-evolver.mdx b/docs/api/qiskit-addon-mpf/backends-quimb-layers-layerwise-evolver.mdx index b5477d89ccf..3c3c1857d23 100644 --- a/docs/api/qiskit-addon-mpf/backends-quimb-layers-layerwise-evolver.mdx +++ b/docs/api/qiskit-addon-mpf/backends-quimb-layers-layerwise-evolver.mdx @@ -13,7 +13,7 @@ python_api_name: qiskit_addon_mpf.backends.quimb_layers.LayerwiseEvolver A special case of the [`TEBDEvolver`](backends-quimb-tebd-tebd-evolver "qiskit_addon_mpf.backends.quimb_tebd.TEBDEvolver") based on layer-wise evolution models. - As also explained in [`quimb_layers`](backends-quimb-layers#module-qiskit_addon_mpf.backends.quimb_layers "qiskit_addon_mpf.backends.quimb_layers"), this implementation extracts the alternating even/odd bond updates implemented inside of the original [`quimb.tensor.TEBD`](https://quimb.readthedocs.io/en/latest/autoapi/quimb/tensor/index.html#quimb.tensor.TEBD "(in quimb v1.9)") to become the end users responsibility. It does so, by replacing the single Hamiltonian provided to the [`TEBDEvolver`](backends-quimb-tebd-tebd-evolver "qiskit_addon_mpf.backends.quimb_tebd.TEBDEvolver") instance with a sequence of [`LayerModel`](backends-quimb-layers-layer-model "qiskit_addon_mpf.backends.quimb_layers.LayerModel") instances. Every single instance of these encodes a single **layer** of interactions. These should enforce the alternating updates of even and odd bonds of the underlying tensor network. + As also explained in [`quimb_layers`](backends-quimb-layers#module-qiskit_addon_mpf.backends.quimb_layers "qiskit_addon_mpf.backends.quimb_layers"), this implementation extracts the alternating even/odd bond updates implemented inside of the original [`quimb.tensor.TEBD`](https://quimb.readthedocs.io/en/latest/autoapi/quimb/tensor/index.html#quimb.tensor.TEBD "(in quimb v1.10)") to become the end users responsibility. It does so, by replacing the single Hamiltonian provided to the [`TEBDEvolver`](backends-quimb-tebd-tebd-evolver "qiskit_addon_mpf.backends.quimb_tebd.TEBDEvolver") instance with a sequence of [`LayerModel`](backends-quimb-layers-layer-model "qiskit_addon_mpf.backends.quimb_layers.LayerModel") instances. Every single instance of these encodes a single **layer** of interactions. These should enforce the alternating updates of even and odd bonds of the underlying tensor network. The motivation for this more complicated interface is that is provides a lot more flexbility and enables users to define custom Trotter product formulas rather than being limited to the ones implemented by `quimb` directly. diff --git a/docs/api/qiskit-addon-mpf/backends-quimb-layers.mdx b/docs/api/qiskit-addon-mpf/backends-quimb-layers.mdx index 3020b671de5..9eae432a923 100644 --- a/docs/api/qiskit-addon-mpf/backends-quimb-layers.mdx +++ b/docs/api/qiskit-addon-mpf/backends-quimb-layers.mdx @@ -14,7 +14,7 @@ python_api_name: qiskit_addon_mpf.backends.quimb_layers `qiskit_addon_mpf.backends.quimb_layers` -A layer-wise time-evolution backend using [`quimb`](https://quimb.readthedocs.io/en/latest/autoapi/quimb/index.html#module-quimb "(in quimb v1.9)"). +A layer-wise time-evolution backend using [`quimb`](https://quimb.readthedocs.io/en/latest/autoapi/quimb/index.html#module-quimb "(in quimb v1.10)"). This backend is only available if the optional dependencies have been installed: @@ -31,7 +31,7 @@ A layer-wise time-evolution backend using [`quimb`](https://quimb.readthedocs.io ## Underlying method -This module provides a time-evolution backend similar to the TEBD-based one provided by the [`quimb_tebd`](backends-quimb-tebd#module-qiskit_addon_mpf.backends.quimb_tebd "qiskit_addon_mpf.backends.quimb_tebd") module. The main difference is that this module gives the user full flexibility for defining their product formulas, thereby not limiting them to the options built into the [`quimb`](https://quimb.readthedocs.io/en/latest/autoapi/quimb/index.html#module-quimb "(in quimb v1.9)") library. +This module provides a time-evolution backend similar to the TEBD-based one provided by the [`quimb_tebd`](backends-quimb-tebd#module-qiskit_addon_mpf.backends.quimb_tebd "qiskit_addon_mpf.backends.quimb_tebd") module. The main difference is that this module gives the user full flexibility for defining their product formulas, thereby not limiting them to the options built into the [`quimb`](https://quimb.readthedocs.io/en/latest/autoapi/quimb/index.html#module-quimb "(in quimb v1.10)") library. At its core, the algorithm provided by this module is still a TEBD \[1] algorithm. However, rather than enforcing the alternating updates to the even and odd bonds of the time-evolution state (see also [`quimb_tebd.TEBDEvolver.sweep()`](backends-quimb-tebd-tebd-evolver#sweep "qiskit_addon_mpf.backends.quimb_tebd.TEBDEvolver.sweep")) this implementation outsources the responsibility of updating bonds in alternating fashion to the definition of multiple time-evolution **layers**. @@ -61,7 +61,7 @@ Let us now inspect the time-evolution circuit of this Hamiltonian using a second
``` -![../\_images/qiskit\_addon\_mpf-backends-quimb\_layers-2.png](/images/api/qiskit-addon-mpf/qiskit_addon_mpf-backends-quimb_layers-2.png) +![Output from the previous code.](/images/api/qiskit-addon-mpf/qiskit_addon_mpf-backends-quimb_layers-2.png) In the circuit above, we can clearly identify its layer-wise structure. We can emphasize this further, by splitting the circuit into multiple layers as shown below (we recombine the `layers` into a single circuit with barriers between them to ease the visualization). @@ -72,10 +72,10 @@ In the circuit above, we can clearly identify its layer-wise structure. We can e
``` -![../\_images/qiskit\_addon\_mpf-backends-quimb\_layers-3.png](/images/api/qiskit-addon-mpf/qiskit_addon_mpf-backends-quimb_layers-3.png) +![Output from the previous code.](/images/api/qiskit-addon-mpf/qiskit_addon_mpf-backends-quimb_layers-3.png) - The asymmetry of the central layers is a result of the implementation of Qiskit’s [`SuzukiTrotter`](/api/qiskit/qiskit.synthesis.SuzukiTrotter "(in Qiskit v1.2)") formula. In its second-order form, it combines the two half-time evolutions of the final term in the Hamiltonian into a single one of twice the length. We could transpile this circuit to collapse all such subequent gates in the central two layers (just like the last one), but for the sake of simplicity of this example, we will not do that here. + The asymmetry of the central layers is a result of the implementation of Qiskit’s [`SuzukiTrotter`](/api/qiskit/qiskit.synthesis.SuzukiTrotter "(in Qiskit v1.3)") formula. In its second-order form, it combines the two half-time evolutions of the final term in the Hamiltonian into a single one of twice the length. We could transpile this circuit to collapse all such subequent gates in the central two layers (just like the last one), but for the sake of simplicity of this example, we will not do that here. It is not possible to instruct Quimb’s TEBD algorithm to simulate the exact structure of the circuit shown above. The reason for that is a limitation in its interface, as it only accepts the full Hamiltonian to be provided which is then time-evolved using pre-defined Trotter formulas. However, in doing so it does not treat the order of the Pauli terms in a Hamiltonian with any significance (like we do here). diff --git a/docs/api/qiskit-addon-mpf/backends-quimb-tebd-mpo-state.mdx b/docs/api/qiskit-addon-mpf/backends-quimb-tebd-mpo-state.mdx index ab8a9e21d1a..ab4dc67c851 100644 --- a/docs/api/qiskit-addon-mpf/backends-quimb-tebd-mpo-state.mdx +++ b/docs/api/qiskit-addon-mpf/backends-quimb-tebd-mpo-state.mdx @@ -9,29 +9,29 @@ python_api_name: qiskit_addon_mpf.backends.quimb_tebd.MPOState # MPOState - Bases: [`MatrixProductOperator`](https://quimb.readthedocs.io/en/latest/autoapi/quimb/tensor/tensor_1d/index.html#quimb.tensor.tensor_1d.MatrixProductOperator "(in quimb v1.9)"), [`State`](backends#state "qiskit_addon_mpf.backends.interface.State") + Bases: [`MatrixProductOperator`](https://quimb.readthedocs.io/en/latest/autoapi/quimb/tensor/tensor_1d/index.html#quimb.tensor.tensor_1d.MatrixProductOperator "(in quimb v1.10)"), [`State`](backends#state "qiskit_addon_mpf.backends.interface.State") An MPO enforcing the Vidal gauge. - This specialization of quimb’s existing [`quimb.tensor.MatrixProductOperator`](https://quimb.readthedocs.io/en/latest/autoapi/quimb/tensor/index.html#quimb.tensor.MatrixProductOperator "(in quimb v1.9)") enforces the Vidal gauge throughout its existence. This ensures a stable behavior of the [`DynamicMPF`](dynamic#dynamicmpf "qiskit_addon_mpf.dynamic.DynamicMPF") algorithm when using the [`TEBDEvolver`](backends-quimb-tebd-tebd-evolver "qiskit_addon_mpf.backends.quimb_tebd.TEBDEvolver"). + This specialization of quimb’s existing [`quimb.tensor.MatrixProductOperator`](https://quimb.readthedocs.io/en/latest/autoapi/quimb/tensor/index.html#quimb.tensor.MatrixProductOperator "(in quimb v1.10)") enforces the Vidal gauge throughout its existence. This ensures a stable behavior of the [`DynamicMPF`](dynamic#dynamicmpf "qiskit_addon_mpf.dynamic.DynamicMPF") algorithm when using the [`TEBDEvolver`](backends-quimb-tebd-tebd-evolver "qiskit_addon_mpf.backends.quimb_tebd.TEBDEvolver"). Initialize a [`MPOState`](#qiskit_addon_mpf.backends.quimb_tebd.MPOState "qiskit_addon_mpf.backends.quimb_tebd.MPOState") instance. - All arguments (positional and keyword) are simply forwarded to the [`quimb.tensor.MatrixProductOperator`](https://quimb.readthedocs.io/en/latest/autoapi/quimb/tensor/index.html#quimb.tensor.MatrixProductOperator "(in quimb v1.9)") constructor. Additionally, the [`vidal_singular_values`](#qiskit_addon_mpf.backends.quimb_tebd.MPOState.vidal_singular_values "qiskit_addon_mpf.backends.quimb_tebd.MPOState.vidal_singular_values") attribute gets initialized to a list of empty lists of length equal to the number of sites in this MPO. + All arguments (positional and keyword) are simply forwarded to the [`quimb.tensor.MatrixProductOperator`](https://quimb.readthedocs.io/en/latest/autoapi/quimb/tensor/index.html#quimb.tensor.MatrixProductOperator "(in quimb v1.10)") constructor. Additionally, the [`vidal_singular_values`](#qiskit_addon_mpf.backends.quimb_tebd.MPOState.vidal_singular_values "qiskit_addon_mpf.backends.quimb_tebd.MPOState.vidal_singular_values") attribute gets initialized to a list of empty lists of length equal to the number of sites in this MPO. **Parameters** - * **args** – all positional arguments will be forwarded to the [`quimb.tensor.MatrixProductState`](https://quimb.readthedocs.io/en/latest/autoapi/quimb/tensor/index.html#quimb.tensor.MatrixProductState "(in quimb v1.9)") constructor. - * **kwargs** – all keyword arguments will be forwarded to the [`quimb.tensor.MatrixProductState`](https://quimb.readthedocs.io/en/latest/autoapi/quimb/tensor/index.html#quimb.tensor.MatrixProductState "(in quimb v1.9)") constructor. + * **args** – all positional arguments will be forwarded to the [`quimb.tensor.MatrixProductState`](https://quimb.readthedocs.io/en/latest/autoapi/quimb/tensor/index.html#quimb.tensor.MatrixProductState "(in quimb v1.10)") constructor. + * **kwargs** – all keyword arguments will be forwarded to the [`quimb.tensor.MatrixProductState`](https://quimb.readthedocs.io/en/latest/autoapi/quimb/tensor/index.html#quimb.tensor.MatrixProductState "(in quimb v1.10)") constructor. ## Attributes ### vidal\_singular\_values - A nested list of singular values. The outer list is of equal length as this MPO itself ([`quimb.tensor.TensorNetwork1D.L`](https://quimb.readthedocs.io/en/latest/autoapi/quimb/tensor/index.html#quimb.tensor.TensorNetwork1D.L "(in quimb v1.9)")). Every item is another list of all the singular values for determining the Vidal gauge at that site. + A nested list of singular values. The outer list is of equal length as this MPO itself ([`quimb.tensor.TensorNetwork1D.L`](https://quimb.readthedocs.io/en/latest/autoapi/quimb/tensor/index.html#quimb.tensor.TensorNetwork1D.L "(in quimb v1.10)")). Every item is another list of all the singular values for determining the Vidal gauge at that site. ## Methods @@ -41,11 +41,11 @@ python_api_name: qiskit_addon_mpf.backends.quimb_tebd.MPOState Apply a two-site gate and contract it back into the MPO. - The basic principle of this method is the same as that of [`quimb.tensor.MatrixProductState.gate_split()`](https://quimb.readthedocs.io/en/latest/autoapi/quimb/tensor/index.html#quimb.tensor.MatrixProductState.gate_split "(in quimb v1.9)"). However, the implementation ensures that the Vidal gauge is conserved. + The basic principle of this method is the same as that of [`quimb.tensor.MatrixProductState.gate_split()`](https://quimb.readthedocs.io/en/latest/autoapi/quimb/tensor/index.html#quimb.tensor.MatrixProductState.gate_split "(in quimb v1.10)"). However, the implementation ensures that the Vidal gauge is conserved. **Parameters** - * **gate** ([*ndarray*](https://numpy.org/doc/stable/reference/generated/numpy.ndarray.html#numpy.ndarray "(in NumPy v2.1)")) – the gate to be applied to the MPO. Its shape should be either `(d**2, d**2)` for a physical dimension of `d`, or a reshaped version thereof. + * **gate** ([*ndarray*](https://numpy.org/doc/stable/reference/generated/numpy.ndarray.html#numpy.ndarray "(in NumPy v2.2)")) – the gate to be applied to the MPO. Its shape should be either `(d**2, d**2)` for a physical dimension of `d`, or a reshaped version thereof. * **where** ([*tuple*](https://docs.python.org/3/library/stdtypes.html#tuple "(in Python v3.13)")*\[*[*int*](https://docs.python.org/3/library/functions.html#int "(in Python v3.13)")*,* [*int*](https://docs.python.org/3/library/functions.html#int "(in Python v3.13)")*]*) – the indices of the sites where the gate should be applied. @@ -53,13 +53,13 @@ python_api_name: qiskit_addon_mpf.backends.quimb_tebd.MPOState * **conj** ([*bool*](https://docs.python.org/3/library/functions.html#bool "(in Python v3.13)")) – - whether the gate should be applied to the lower (`conj=False`, the default, [`lower_ind()`](https://quimb.readthedocs.io/en/latest/autoapi/quimb/tensor/tensor_arbgeom/index.html#quimb.tensor.tensor_arbgeom.TensorNetworkGenOperator.lower_ind "(in quimb v1.9)")) or upper (`conj=True`, [`upper_ind()`](https://quimb.readthedocs.io/en/latest/autoapi/quimb/tensor/tensor_arbgeom/index.html#quimb.tensor.tensor_arbgeom.TensorNetworkGenOperator.upper_ind "(in quimb v1.9)")) indices of the underlying MPO. + whether the gate should be applied to the lower (`conj=False`, the default, [`lower_ind()`](https://quimb.readthedocs.io/en/latest/autoapi/quimb/tensor/tensor_arbgeom/index.html#quimb.tensor.tensor_arbgeom.TensorNetworkGenOperator.lower_ind "(in quimb v1.10)")) or upper (`conj=True`, [`upper_ind()`](https://quimb.readthedocs.io/en/latest/autoapi/quimb/tensor/tensor_arbgeom/index.html#quimb.tensor.tensor_arbgeom.TensorNetworkGenOperator.upper_ind "(in quimb v1.10)")) indices of the underlying MPO. This is essentially how the LHS and RHS of the [`DynamicMPF`](dynamic#dynamicmpf "qiskit_addon_mpf.dynamic.DynamicMPF") are differentiated, by passing their [`Evolver.conjugate`](backends#conjugate "qiskit_addon_mpf.backends.Evolver.conjugate") property to this argument. - * **split\_opts** – additional keyword arguments that will be forwarded to the [`quimb.tensor.tensor_split()`](https://quimb.readthedocs.io/en/latest/autoapi/quimb/tensor/index.html#quimb.tensor.tensor_split "(in quimb v1.9)") function. These can be used to affect the truncation of the tensor before it gets contracted back into the MPO. + * **split\_opts** – additional keyword arguments that will be forwarded to the [`quimb.tensor.tensor_split()`](https://quimb.readthedocs.io/en/latest/autoapi/quimb/tensor/index.html#quimb.tensor.tensor_split "(in quimb v1.10)") function. These can be used to affect the truncation of the tensor before it gets contracted back into the MPO. **Returns** @@ -91,7 +91,7 @@ python_api_name: qiskit_addon_mpf.backends.quimb_tebd.MPOState Compute the overlap of this state with the provided initial state. - This implementation only supports instances of [`quimb.tensor.MatrixProductState`](https://quimb.readthedocs.io/en/latest/autoapi/quimb/tensor/index.html#quimb.tensor.MatrixProductState "(in quimb v1.9)") for `initial_state`. + This implementation only supports instances of [`quimb.tensor.MatrixProductState`](https://quimb.readthedocs.io/en/latest/autoapi/quimb/tensor/index.html#quimb.tensor.MatrixProductState "(in quimb v1.10)") for `initial_state`. **Parameters** diff --git a/docs/api/qiskit-addon-mpf/backends-quimb-tebd-tebd-evolver.mdx b/docs/api/qiskit-addon-mpf/backends-quimb-tebd-tebd-evolver.mdx index bf7d4c5bfbf..6f050a91293 100644 --- a/docs/api/qiskit-addon-mpf/backends-quimb-tebd-tebd-evolver.mdx +++ b/docs/api/qiskit-addon-mpf/backends-quimb-tebd-tebd-evolver.mdx @@ -9,16 +9,16 @@ python_api_name: qiskit_addon_mpf.backends.quimb_tebd.TEBDEvolver # TEBDEvolver - Bases: [`TEBD`](https://quimb.readthedocs.io/en/latest/autoapi/quimb/tensor/tensor_1d_tebd/index.html#quimb.tensor.tensor_1d_tebd.TEBD "(in quimb v1.9)"), [`Evolver`](backends#evolver "qiskit_addon_mpf.backends.interface.Evolver") + Bases: [`TEBD`](https://quimb.readthedocs.io/en/latest/autoapi/quimb/tensor/tensor_1d_tebd/index.html#quimb.tensor.tensor_1d_tebd.TEBD "(in quimb v1.10)"), [`Evolver`](backends#evolver "qiskit_addon_mpf.backends.interface.Evolver") A TEBD algorithm for evolving an internal MPO. - As discussed in more detail in [`quimb_tebd`](backends-quimb-tebd#module-qiskit_addon_mpf.backends.quimb_tebd "qiskit_addon_mpf.backends.quimb_tebd"), this extension of `quimb`’s existing [`quimb.tensor.TEBD`](https://quimb.readthedocs.io/en/latest/autoapi/quimb/tensor/index.html#quimb.tensor.TEBD "(in quimb v1.9)") implementation time-evolves an internal matrix product operator (MPO) rather than the conventional matrix product state (MPS). + As discussed in more detail in [`quimb_tebd`](backends-quimb-tebd#module-qiskit_addon_mpf.backends.quimb_tebd "qiskit_addon_mpf.backends.quimb_tebd"), this extension of `quimb`’s existing [`quimb.tensor.TEBD`](https://quimb.readthedocs.io/en/latest/autoapi/quimb/tensor/index.html#quimb.tensor.TEBD "(in quimb v1.10)") implementation time-evolves an internal matrix product operator (MPO) rather than the conventional matrix product state (MPS). More concretely, the internal object is expected to be an [`MPOState`](backends-quimb-tebd-mpo-state "qiskit_addon_mpf.backends.quimb_tebd.MPOState"). - The API of this class is actually much larger than shown here, because it inherits additional methods from the [`quimb.tensor.TEBD`](https://quimb.readthedocs.io/en/latest/autoapi/quimb/tensor/index.html#quimb.tensor.TEBD "(in quimb v1.9)") base class. However, we do not duplicate that API here. + The API of this class is actually much larger than shown here, because it inherits additional methods from the [`quimb.tensor.TEBD`](https://quimb.readthedocs.io/en/latest/autoapi/quimb/tensor/index.html#quimb.tensor.TEBD "(in quimb v1.10)") base class. However, we do not duplicate that API here. Initialize a [`TEBDEvolver`](#qiskit_addon_mpf.backends.quimb_tebd.TEBDEvolver "qiskit_addon_mpf.backends.quimb_tebd.TEBDEvolver") instance. @@ -27,17 +27,17 @@ python_api_name: qiskit_addon_mpf.backends.quimb_tebd.TEBDEvolver * **evolution\_state** ([*MPOState*](backends-quimb-tebd-mpo-state "qiskit_addon_mpf.backends.quimb_tebd.MPOState")) – - a reference to the time-evolution state. This overwrites the `p0` argument of the underlying [`quimb.tensor.TEBD`](https://quimb.readthedocs.io/en/latest/autoapi/quimb/tensor/index.html#quimb.tensor.TEBD "(in quimb v1.9)") class. + a reference to the time-evolution state. This overwrites the `p0` argument of the underlying [`quimb.tensor.TEBD`](https://quimb.readthedocs.io/en/latest/autoapi/quimb/tensor/index.html#quimb.tensor.TEBD "(in quimb v1.10)") class. In contrast to the default behavior, this state will **NOT** be canonicalized. Instead, it is taken as is and is kept **by reference** (i.e. no copy is created). This ensures that the same object can be shared between two instances of this class, as required by the [`DynamicMPF`](dynamic#dynamicmpf "qiskit_addon_mpf.dynamic.DynamicMPF") algorithm. - * **args** – any further positional arguments will be forwarded to the [`quimb.tensor.TEBD`](https://quimb.readthedocs.io/en/latest/autoapi/quimb/tensor/index.html#quimb.tensor.TEBD "(in quimb v1.9)") constructor. + * **args** – any further positional arguments will be forwarded to the [`quimb.tensor.TEBD`](https://quimb.readthedocs.io/en/latest/autoapi/quimb/tensor/index.html#quimb.tensor.TEBD "(in quimb v1.10)") constructor. - * **order** ([*int*](https://docs.python.org/3/library/functions.html#int "(in Python v3.13)")) – the order of the builtin Suzuki-Trotter formula to use during time evolution. This will be the value forwarded to the [`quimb.tensor.TEBD.step()`](https://quimb.readthedocs.io/en/latest/autoapi/quimb/tensor/index.html#quimb.tensor.TEBD.step "(in quimb v1.9)") method. + * **order** ([*int*](https://docs.python.org/3/library/functions.html#int "(in Python v3.13)")) – the order of the builtin Suzuki-Trotter formula to use during time evolution. This will be the value forwarded to the [`quimb.tensor.TEBD.step()`](https://quimb.readthedocs.io/en/latest/autoapi/quimb/tensor/index.html#quimb.tensor.TEBD.step "(in quimb v1.10)") method. - * **kwargs** – any further keyword arguments will be forwarded to the [`quimb.tensor.TEBD`](https://quimb.readthedocs.io/en/latest/autoapi/quimb/tensor/index.html#quimb.tensor.TEBD "(in quimb v1.9)") constructor. + * **kwargs** – any further keyword arguments will be forwarded to the [`quimb.tensor.TEBD`](https://quimb.readthedocs.io/en/latest/autoapi/quimb/tensor/index.html#quimb.tensor.TEBD "(in quimb v1.10)") constructor. ## Attributes @@ -60,7 +60,7 @@ python_api_name: qiskit_addon_mpf.backends.quimb_tebd.TEBDEvolver Perform a single time step of TEBD. - This essentially calls [`quimb.tensor.TEBD.step()`](https://quimb.readthedocs.io/en/latest/autoapi/quimb/tensor/index.html#quimb.tensor.TEBD.step "(in quimb v1.9)") and forwards the value of the `order` attribute that was provided upon construction. + This essentially calls [`quimb.tensor.TEBD.step()`](https://quimb.readthedocs.io/en/latest/autoapi/quimb/tensor/index.html#quimb.tensor.TEBD.step "(in quimb v1.10)") and forwards the value of the `order` attribute that was provided upon construction. **Return type** @@ -72,7 +72,7 @@ python_api_name: qiskit_addon_mpf.backends.quimb_tebd.TEBDEvolver Perform a single sweep of the TEBD algorithm \[1]. - The TEBD algorithm updates the even and odd bonds of the underlying tensor network in alternating fashion. In the implementation of the [`quimb.tensor.TEBD`](https://quimb.readthedocs.io/en/latest/autoapi/quimb/tensor/index.html#quimb.tensor.TEBD "(in quimb v1.9)") base class, this is realized in the form of alternating “sweeps” in left and right directions over the internal state. + The TEBD algorithm updates the even and odd bonds of the underlying tensor network in alternating fashion. In the implementation of the [`quimb.tensor.TEBD`](https://quimb.readthedocs.io/en/latest/autoapi/quimb/tensor/index.html#quimb.tensor.TEBD "(in quimb v1.10)") base class, this is realized in the form of alternating “sweeps” in left and right directions over the internal state. We are overwriting the behavior of this method in this subclass, in order to call the specialized [`gate_split()`](backends-quimb-tebd-mpo-state#gate_split "qiskit_addon_mpf.backends.quimb_tebd.MPOState.gate_split") method. @@ -86,8 +86,8 @@ python_api_name: qiskit_addon_mpf.backends.quimb_tebd.TEBDEvolver **Raises** * [**NotImplementedError**](https://docs.python.org/3/library/exceptions.html#NotImplementedError "(in Python v3.13)") – if `queue=True`. - * [**NotImplementedError**](https://docs.python.org/3/library/exceptions.html#NotImplementedError "(in Python v3.13)") – if [`cyclic`](https://quimb.readthedocs.io/en/latest/autoapi/quimb/tensor/index.html#quimb.tensor.TEBD.cyclic "(in quimb v1.9)") is `True`. - * [**NotImplementedError**](https://docs.python.org/3/library/exceptions.html#NotImplementedError "(in Python v3.13)") – if [`imag`](https://quimb.readthedocs.io/en/latest/autoapi/quimb/tensor/index.html#quimb.tensor.TEBD.imag "(in quimb v1.9)") is `True`. + * [**NotImplementedError**](https://docs.python.org/3/library/exceptions.html#NotImplementedError "(in Python v3.13)") – if [`cyclic`](https://quimb.readthedocs.io/en/latest/autoapi/quimb/tensor/index.html#quimb.tensor.TEBD.cyclic "(in quimb v1.10)") is `True`. + * [**NotImplementedError**](https://docs.python.org/3/library/exceptions.html#NotImplementedError "(in Python v3.13)") – if [`imag`](https://quimb.readthedocs.io/en/latest/autoapi/quimb/tensor/index.html#quimb.tensor.TEBD.imag "(in quimb v1.10)") is `True`. * [**RuntimeError**](https://docs.python.org/3/library/exceptions.html#RuntimeError "(in Python v3.13)") – if an invalid `direction` is provided. **Return type** diff --git a/docs/api/qiskit-addon-mpf/backends-quimb-tebd.mdx b/docs/api/qiskit-addon-mpf/backends-quimb-tebd.mdx index 78d7a1dc51c..7681110b06b 100644 --- a/docs/api/qiskit-addon-mpf/backends-quimb-tebd.mdx +++ b/docs/api/qiskit-addon-mpf/backends-quimb-tebd.mdx @@ -14,7 +14,7 @@ python_api_name: qiskit_addon_mpf.backends.quimb_tebd `qiskit_addon_mpf.backends.quimb_tebd` -A [`quimb`](https://quimb.readthedocs.io/en/latest/autoapi/quimb/index.html#module-quimb "(in quimb v1.9)")-based TEBD backend. +A [`quimb`](https://quimb.readthedocs.io/en/latest/autoapi/quimb/index.html#module-quimb "(in quimb v1.10)")-based TEBD backend. This backend is only available if the optional dependencies have been installed: @@ -31,20 +31,20 @@ A [`quimb`](https://quimb.readthedocs.io/en/latest/autoapi/quimb/index.html#modu ## Underlying method -This module provides a time-evolution backend for computing dynamic MPF coefficients based on the time-evolving block decimation (TEBD) algorithm \[1] implemented in the [`quimb`](https://quimb.readthedocs.io/en/latest/autoapi/quimb/index.html#module-quimb "(in quimb v1.9)") tensor network library. +This module provides a time-evolution backend for computing dynamic MPF coefficients based on the time-evolving block decimation (TEBD) algorithm \[1] implemented in the [`quimb`](https://quimb.readthedocs.io/en/latest/autoapi/quimb/index.html#module-quimb "(in quimb v1.10)") tensor network library. The classes provided by this module serve two purposes: -1. Connecting [`quimb`](https://quimb.readthedocs.io/en/latest/autoapi/quimb/index.html#module-quimb "(in quimb v1.9)")’s implementation to the interface set out by [`qiskit_addon_mpf.backends`](backends#module-qiskit_addon_mpf.backends "qiskit_addon_mpf.backends"). -2. Extending [`quimb`](https://quimb.readthedocs.io/en/latest/autoapi/quimb/index.html#module-quimb "(in quimb v1.9)")’s TEBD implementation to handle an internal MPO (rather than MPS) state (see also [`State`](backends#state "qiskit_addon_mpf.backends.State") for more details). +1. Connecting [`quimb`](https://quimb.readthedocs.io/en/latest/autoapi/quimb/index.html#module-quimb "(in quimb v1.10)")’s implementation to the interface set out by [`qiskit_addon_mpf.backends`](backends#module-qiskit_addon_mpf.backends "qiskit_addon_mpf.backends"). +2. Extending [`quimb`](https://quimb.readthedocs.io/en/latest/autoapi/quimb/index.html#module-quimb "(in quimb v1.10)")’s TEBD implementation to handle an internal MPO (rather than MPS) state (see also [`State`](backends#state "qiskit_addon_mpf.backends.State") for more details). -In the simplest sense, this module provides a straight-forward extension of the TEBD algorithm to evolve an internal MPO state. As such, if you wish to use this backend for your dynamic MPF algorithm, you must encode the Hamiltonian that you wish to time-evolve, in a [`quimb`](https://quimb.readthedocs.io/en/latest/autoapi/quimb/index.html#module-quimb "(in quimb v1.9)")-native form. To be more concrete, the [`TEBDEvolver`](backends-quimb-tebd-tebd-evolver "qiskit_addon_mpf.backends.quimb_tebd.TEBDEvolver") class (which is a subclass of [`quimb.tensor.TEBD`](https://quimb.readthedocs.io/en/latest/autoapi/quimb/tensor/index.html#quimb.tensor.TEBD "(in quimb v1.9)")) works with a Hamiltonian in the form of a [`quimb.tensor.LocalHam1D`](https://quimb.readthedocs.io/en/latest/autoapi/quimb/tensor/index.html#quimb.tensor.LocalHam1D "(in quimb v1.9)"). Quimb provides a number of convenience methods for constructing such Hamiltonians in its [`quimb.tensor.tensor_builder`](https://quimb.readthedocs.io/en/latest/autoapi/quimb/tensor/tensor_builder/index.html#module-quimb.tensor.tensor_builder "(in quimb v1.9)") module. If none of those fulfill your needs, you can consider using the [`LayerModel`](backends-quimb-layers-layer-model "qiskit_addon_mpf.backends.quimb_layers.LayerModel") class which implements some conversion methods from Qiskit-native objects. +In the simplest sense, this module provides a straight-forward extension of the TEBD algorithm to evolve an internal MPO state. As such, if you wish to use this backend for your dynamic MPF algorithm, you must encode the Hamiltonian that you wish to time-evolve, in a [`quimb`](https://quimb.readthedocs.io/en/latest/autoapi/quimb/index.html#module-quimb "(in quimb v1.10)")-native form. To be more concrete, the [`TEBDEvolver`](backends-quimb-tebd-tebd-evolver "qiskit_addon_mpf.backends.quimb_tebd.TEBDEvolver") class (which is a subclass of [`quimb.tensor.TEBD`](https://quimb.readthedocs.io/en/latest/autoapi/quimb/tensor/index.html#quimb.tensor.TEBD "(in quimb v1.10)")) works with a Hamiltonian in the form of a [`quimb.tensor.LocalHam1D`](https://quimb.readthedocs.io/en/latest/autoapi/quimb/tensor/index.html#quimb.tensor.LocalHam1D "(in quimb v1.10)"). Quimb provides a number of convenience methods for constructing such Hamiltonians in its [`quimb.tensor.tensor_builder`](https://quimb.readthedocs.io/en/latest/autoapi/quimb/tensor/tensor_builder/index.html#module-quimb.tensor.tensor_builder "(in quimb v1.10)") module. If none of those fulfill your needs, you can consider using the [`LayerModel`](backends-quimb-layers-layer-model "qiskit_addon_mpf.backends.quimb_layers.LayerModel") class which implements some conversion methods from Qiskit-native objects. ## Code example This section shows a simple example to get you started with using this backend. The example shows how to create the three factory functions required for the [`setup_dynamic_lse()`](dynamic#setup_dynamic_lse "qiskit_addon_mpf.dynamic.setup_dynamic_lse"). -First, we create the `identity_factory` which has to match the [`IdentityStateFactory`](dynamic#identitystatefactory "qiskit_addon_mpf.dynamic.IdentityStateFactory") protocol. We do so simply by using the [`quimb.tensor.MPO_identity()`](https://quimb.readthedocs.io/en/latest/autoapi/quimb/tensor/index.html#quimb.tensor.MPO_identity "(in quimb v1.9)") function and wrapping the resulting [`quimb.tensor.MatrixProductOperator`](https://quimb.readthedocs.io/en/latest/autoapi/quimb/tensor/index.html#quimb.tensor.MatrixProductOperator "(in quimb v1.9)") with our custom [`MPOState`](backends-quimb-tebd-mpo-state "qiskit_addon_mpf.backends.quimb_tebd.MPOState") interface. +First, we create the `identity_factory` which has to match the [`IdentityStateFactory`](dynamic#identitystatefactory "qiskit_addon_mpf.dynamic.IdentityStateFactory") protocol. We do so simply by using the [`quimb.tensor.MPO_identity()`](https://quimb.readthedocs.io/en/latest/autoapi/quimb/tensor/index.html#quimb.tensor.MPO_identity "(in quimb v1.10)") function and wrapping the resulting [`quimb.tensor.MatrixProductOperator`](https://quimb.readthedocs.io/en/latest/autoapi/quimb/tensor/index.html#quimb.tensor.MatrixProductOperator "(in quimb v1.10)") with our custom [`MPOState`](backends-quimb-tebd-mpo-state "qiskit_addon_mpf.backends.quimb_tebd.MPOState") interface. ```python >>> from qiskit_addon_mpf.backends.quimb_tebd import MPOState @@ -53,7 +53,7 @@ First, we create the `identity_factory` which has to match the [`IdentityStateFa >>> identity_factory = lambda: MPOState(MPO_identity(num_qubits)) ``` -Next, before being able to define the [`ExactEvolverFactory`](dynamic#exactevolverfactory "qiskit_addon_mpf.dynamic.ExactEvolverFactory") and [`ApproxEvolverFactory`](dynamic#approxevolverfactory "qiskit_addon_mpf.dynamic.ApproxEvolverFactory") protocols, we must define the Hamiltonian which we would like to time-evolve. Here, we simply choose one of [`quimb`](https://quimb.readthedocs.io/en/latest/autoapi/quimb/index.html#module-quimb "(in quimb v1.9)")’s convenience methods. +Next, before being able to define the [`ExactEvolverFactory`](dynamic#exactevolverfactory "qiskit_addon_mpf.dynamic.ExactEvolverFactory") and [`ApproxEvolverFactory`](dynamic#approxevolverfactory "qiskit_addon_mpf.dynamic.ApproxEvolverFactory") protocols, we must define the Hamiltonian which we would like to time-evolve. Here, we simply choose one of [`quimb`](https://quimb.readthedocs.io/en/latest/autoapi/quimb/index.html#module-quimb "(in quimb v1.10)")’s convenience methods. ```python >>> from quimb.tensor import ham_1d_heis @@ -86,7 +86,7 @@ Below, we do not fix the `dt` value and use only a second-order Suzuki-Trotter f ... ) ``` -Of course, you are not limited to the examples shown here, and we encourage you to play around with the other settings provided by the [`quimb.tensor.TEBD`](https://quimb.readthedocs.io/en/latest/autoapi/quimb/tensor/index.html#quimb.tensor.TEBD "(in quimb v1.9)") implementation. +Of course, you are not limited to the examples shown here, and we encourage you to play around with the other settings provided by the [`quimb.tensor.TEBD`](https://quimb.readthedocs.io/en/latest/autoapi/quimb/tensor/index.html#quimb.tensor.TEBD "(in quimb v1.10)") implementation. ## Limitations diff --git a/docs/api/qiskit-addon-mpf/backends-tenpy-layers-layer-model.mdx b/docs/api/qiskit-addon-mpf/backends-tenpy-layers-layer-model.mdx index 6e49d2550e4..3efb908ff4f 100644 --- a/docs/api/qiskit-addon-mpf/backends-tenpy-layers-layer-model.mdx +++ b/docs/api/qiskit-addon-mpf/backends-tenpy-layers-layer-model.mdx @@ -40,13 +40,13 @@ python_api_name: qiskit_addon_mpf.backends.tenpy_layers.LayerModel ### from\_quantum\_circuit - Construct a [`LayerModel`](#qiskit_addon_mpf.backends.tenpy_layers.LayerModel "qiskit_addon_mpf.backends.tenpy_layers.LayerModel") from a [`QuantumCircuit`](/api/qiskit/qiskit.circuit.QuantumCircuit "(in Qiskit v1.2)"). + Construct a [`LayerModel`](#qiskit_addon_mpf.backends.tenpy_layers.LayerModel "qiskit_addon_mpf.backends.tenpy_layers.LayerModel") from a [`QuantumCircuit`](/api/qiskit/qiskit.circuit.QuantumCircuit "(in Qiskit v1.3)"). You can see an example of this function in action in the docs of `tenpy_layers`. **Parameters** - * **circuit** ([*QuantumCircuit*](/api/qiskit/qiskit.circuit.QuantumCircuit "(in Qiskit v1.2)")) – the quantum circuit to parse. + * **circuit** ([*QuantumCircuit*](/api/qiskit/qiskit.circuit.QuantumCircuit "(in Qiskit v1.3)")) – the quantum circuit to parse. * **scaling\_factor** ([*float*](https://docs.python.org/3/library/functions.html#float "(in Python v3.13)")) – a factor with which to scale the term strengths. This can be used to apply (for example) a time step scaling factor. It may also be used (e.g.) to split onsite terms into two layers (even and odd) with \$0.5\$ of the strength, each. * **kwargs** – any additional keyword arguments to pass to the [`LayerModel`](#qiskit_addon_mpf.backends.tenpy_layers.LayerModel "qiskit_addon_mpf.backends.tenpy_layers.LayerModel") constructor. diff --git a/docs/api/qiskit-addon-mpf/backends-tenpy-layers.mdx b/docs/api/qiskit-addon-mpf/backends-tenpy-layers.mdx index 33c35d9dcf4..e967a652ee7 100644 --- a/docs/api/qiskit-addon-mpf/backends-tenpy-layers.mdx +++ b/docs/api/qiskit-addon-mpf/backends-tenpy-layers.mdx @@ -65,7 +65,7 @@ Let us now inspect the time-evolution circuit of this Hamiltonian using a second
``` -![../\_images/qiskit\_addon\_mpf-backends-tenpy\_layers-2.png](/images/api/qiskit-addon-mpf/qiskit_addon_mpf-backends-tenpy_layers-2.png) +![Output from the previous code.](/images/api/qiskit-addon-mpf/qiskit_addon_mpf-backends-tenpy_layers-2.png) In the circuit above, we can clearly identify its layer-wise structure. We can emphasize this further, by splitting the circuit into multiple layers as shown below (we recombine the `layers` into a single circuit with barriers between them to ease the visualization). @@ -76,10 +76,10 @@ In the circuit above, we can clearly identify its layer-wise structure. We can e
``` -![../\_images/qiskit\_addon\_mpf-backends-tenpy\_layers-3.png](/images/api/qiskit-addon-mpf/qiskit_addon_mpf-backends-tenpy_layers-3.png) +![Output from the previous code.](/images/api/qiskit-addon-mpf/qiskit_addon_mpf-backends-tenpy_layers-3.png) - The asymmetry of the central layers is a result of the implementation of Qiskit’s [`SuzukiTrotter`](/api/qiskit/qiskit.synthesis.SuzukiTrotter "(in Qiskit v1.2)") formula. In its second-order form, it combines the two half-time evolutions of the final term in the Hamiltonian into a single one of twice the length. We could transpile this circuit to collapse all such subequent gates in the central two layers (just like the last one), but for the sake of simplicity of this example, we will not do that here. + The asymmetry of the central layers is a result of the implementation of Qiskit’s [`SuzukiTrotter`](/api/qiskit/qiskit.synthesis.SuzukiTrotter "(in Qiskit v1.3)") formula. In its second-order form, it combines the two half-time evolutions of the final term in the Hamiltonian into a single one of twice the length. We could transpile this circuit to collapse all such subequent gates in the central two layers (just like the last one), but for the sake of simplicity of this example, we will not do that here. It is not possible to instruct TeNPy’s TEBD algorithm to simulate the exact structure of the circuit shown above. The reason for that is a limitation in its interface, as it only accepts the full Hamiltonian to be provided which is then time-evolved using pre-defined Trotter formulas. However, in doing so it does not treat the order of the Pauli terms in a Hamiltonian with any significance (like we do here). diff --git a/docs/api/qiskit-addon-mpf/backends.mdx b/docs/api/qiskit-addon-mpf/backends.mdx index a397199a6e9..f806d031e77 100644 --- a/docs/api/qiskit-addon-mpf/backends.mdx +++ b/docs/api/qiskit-addon-mpf/backends.mdx @@ -23,7 +23,7 @@ Whether a certain backend can be used depends on the availability of the underly ### HAS\_QUIMB - Indicates whether the optional [`quimb`](https://quimb.readthedocs.io/en/latest/autoapi/quimb/index.html#module-quimb "(in quimb v1.9)") dependency is installed. + Indicates whether the optional [`quimb`](https://quimb.readthedocs.io/en/latest/autoapi/quimb/index.html#module-quimb "(in quimb v1.10)") dependency is installed. ### HAS\_TENPY @@ -36,13 +36,13 @@ Whether a certain backend can be used depends on the availability of the underly Depending on the availability (see above), the following backends are available: -| | | -| ---------------------------------------------------------------------------------------------------------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------- | -| [`quimb_tebd`](backends-quimb-tebd#module-qiskit_addon_mpf.backends.quimb_tebd "qiskit_addon_mpf.backends.quimb_tebd") | A [`quimb`](https://quimb.readthedocs.io/en/latest/autoapi/quimb/index.html#module-quimb "(in quimb v1.9)")-based TEBD backend. | -| [`quimb_layers`](backends-quimb-layers#module-qiskit_addon_mpf.backends.quimb_layers "qiskit_addon_mpf.backends.quimb_layers") | A layer-wise time-evolution backend using [`quimb`](https://quimb.readthedocs.io/en/latest/autoapi/quimb/index.html#module-quimb "(in quimb v1.9)"). | -| [`quimb_circuit`](backends-quimb-circuit#module-qiskit_addon_mpf.backends.quimb_circuit "qiskit_addon_mpf.backends.quimb_circuit") | A circuit-based time-evolution backend using [`quimb`](https://quimb.readthedocs.io/en/latest/autoapi/quimb/index.html#module-quimb "(in quimb v1.9)"). | -| [`tenpy_tebd`](backends-tenpy-tebd#module-qiskit_addon_mpf.backends.tenpy_tebd "qiskit_addon_mpf.backends.tenpy_tebd") | A [`tenpy`](https://tenpy.readthedocs.io/en/latest/main.html#module-tenpy "(in TeNPy v1.0.4)")-based TEBD backend. | -| [`tenpy_layers`](backends-tenpy-layers#module-qiskit_addon_mpf.backends.tenpy_layers "qiskit_addon_mpf.backends.tenpy_layers") | A layer-wise time-evolution backend using [`tenpy`](https://tenpy.readthedocs.io/en/latest/main.html#module-tenpy "(in TeNPy v1.0.4)"). | +| | | +| ---------------------------------------------------------------------------------------------------------------------------------- | -------------------------------------------------------------------------------------------------------------------------------------------------------- | +| [`quimb_tebd`](backends-quimb-tebd#module-qiskit_addon_mpf.backends.quimb_tebd "qiskit_addon_mpf.backends.quimb_tebd") | A [`quimb`](https://quimb.readthedocs.io/en/latest/autoapi/quimb/index.html#module-quimb "(in quimb v1.10)")-based TEBD backend. | +| [`quimb_layers`](backends-quimb-layers#module-qiskit_addon_mpf.backends.quimb_layers "qiskit_addon_mpf.backends.quimb_layers") | A layer-wise time-evolution backend using [`quimb`](https://quimb.readthedocs.io/en/latest/autoapi/quimb/index.html#module-quimb "(in quimb v1.10)"). | +| [`quimb_circuit`](backends-quimb-circuit#module-qiskit_addon_mpf.backends.quimb_circuit "qiskit_addon_mpf.backends.quimb_circuit") | A circuit-based time-evolution backend using [`quimb`](https://quimb.readthedocs.io/en/latest/autoapi/quimb/index.html#module-quimb "(in quimb v1.10)"). | +| [`tenpy_tebd`](backends-tenpy-tebd#module-qiskit_addon_mpf.backends.tenpy_tebd "qiskit_addon_mpf.backends.tenpy_tebd") | A [`tenpy`](https://tenpy.readthedocs.io/en/latest/main.html#module-tenpy "(in TeNPy v1.0.4)")-based TEBD backend. | +| [`tenpy_layers`](backends-tenpy-layers#module-qiskit_addon_mpf.backends.tenpy_layers "qiskit_addon_mpf.backends.tenpy_layers") | A layer-wise time-evolution backend using [`tenpy`](https://tenpy.readthedocs.io/en/latest/main.html#module-tenpy "(in TeNPy v1.0.4)"). | ## Interface diff --git a/docs/api/qiskit-addon-mpf/costs.mdx b/docs/api/qiskit-addon-mpf/costs.mdx index bcb21fc7eca..0e04d882ebc 100644 --- a/docs/api/qiskit-addon-mpf/costs.mdx +++ b/docs/api/qiskit-addon-mpf/costs.mdx @@ -33,8 +33,8 @@ $$ **Parameters** - * **A** ([*ndarray*](https://numpy.org/doc/stable/reference/generated/numpy.ndarray.html#numpy.ndarray "(in NumPy v2.1)")) - * **b** ([*ndarray*](https://numpy.org/doc/stable/reference/generated/numpy.ndarray.html#numpy.ndarray "(in NumPy v2.1)")) + * **A** ([*ndarray*](https://numpy.org/doc/stable/reference/generated/numpy.ndarray.html#numpy.ndarray "(in NumPy v2.2)")) + * **b** ([*ndarray*](https://numpy.org/doc/stable/reference/generated/numpy.ndarray.html#numpy.ndarray "(in NumPy v2.2)")) #### A @@ -78,7 +78,7 @@ $$ **Return type** - [*ndarray*](https://numpy.org/doc/stable/reference/generated/numpy.ndarray.html#numpy.ndarray "(in NumPy v2.1)") + [*ndarray*](https://numpy.org/doc/stable/reference/generated/numpy.ndarray.html#numpy.ndarray "(in NumPy v2.2)") #### x diff --git a/docs/api/qiskit-addon-mpf/dynamic.mdx b/docs/api/qiskit-addon-mpf/dynamic.mdx index 40fc71927f4..13f75a78217 100644 --- a/docs/api/qiskit-addon-mpf/dynamic.mdx +++ b/docs/api/qiskit-addon-mpf/dynamic.mdx @@ -40,7 +40,7 @@ $$ Below, we provide an example using the [`quimb_tebd`](backends-quimb-tebd#module-qiskit_addon_mpf.backends.quimb_tebd "qiskit_addon_mpf.backends.quimb_tebd") backend. We briefly explain each element. - First, we initialize a simple Heisenberg Hamiltonian which we would like to time-evolve. Since we are using a time-evolver based on [`quimb`](https://quimb.readthedocs.io/en/latest/autoapi/quimb/index.html#module-quimb "(in quimb v1.9)"), we also initialize the Hamiltonian using that library. + First, we initialize a simple Heisenberg Hamiltonian which we would like to time-evolve. Since we are using a time-evolver based on [`quimb`](https://quimb.readthedocs.io/en/latest/autoapi/quimb/index.html#module-quimb "(in quimb v1.10)"), we also initialize the Hamiltonian using that library. ```python >>> from quimb.tensor import ham_1d_heis @@ -48,7 +48,7 @@ $$ >>> hamil = ham_1d_heis(num_qubits, 0.8, 0.3, cyclic=False) ``` - Next, we define the number of Trotter steps to make up our MPF, the target evolution time as well as the initial state ($\psi_{in}$ in \[1] and $\psi_0$ in \[2], resp.) with respect to which we compute the overlap between the time-evolution states. Here, we simply use the Néel state which we also construct using [`quimb`](https://quimb.readthedocs.io/en/latest/autoapi/quimb/index.html#module-quimb "(in quimb v1.9)"): + Next, we define the number of Trotter steps to make up our MPF, the target evolution time as well as the initial state ($\psi_{in}$ in \[1] and $\psi_0$ in \[2], resp.) with respect to which we compute the overlap between the time-evolution states. Here, we simply use the Néel state which we also construct using [`quimb`](https://quimb.readthedocs.io/en/latest/autoapi/quimb/index.html#module-quimb "(in quimb v1.10)"): ```python >>> trotter_steps = [3, 4] @@ -78,7 +78,7 @@ $$ The [`ExactEvolverFactory`](#qiskit_addon_mpf.dynamic.ExactEvolverFactory "qiskit_addon_mpf.dynamic.ExactEvolverFactory") function should take a [`State`](backends#state "qiskit_addon_mpf.backends.State") object as its only positional argument and should return a [`Evolver`](backends#evolver "qiskit_addon_mpf.backends.Evolver") object, which will be used for computing the LHS of the $L_i$ elements (i.e. it should produce the exact time-evolution state, $\rho(t)$). - Here, we approximate the exact time-evolved state with a fourth-order Suzuki-Trotter formula using a small time step of 0.05. We also specify some [`quimb`](https://quimb.readthedocs.io/en/latest/autoapi/quimb/index.html#module-quimb "(in quimb v1.9)")-specific truncation options to bound the maximum bond dimension of the underlying tensor network as well as the minimum singular values of the split tensor network bonds. + Here, we approximate the exact time-evolved state with a fourth-order Suzuki-Trotter formula using a small time step of 0.05. We also specify some [`quimb`](https://quimb.readthedocs.io/en/latest/autoapi/quimb/index.html#module-quimb "(in quimb v1.10)")-specific truncation options to bound the maximum bond dimension of the underlying tensor network as well as the minimum singular values of the split tensor network bonds. ```python >>> from qiskit_addon_mpf.backends.quimb_tebd import TEBDEvolver diff --git a/docs/api/qiskit-addon-obp/qiskit-addon-obp.mdx b/docs/api/qiskit-addon-obp/qiskit-addon-obp.mdx index a3d1ff0befb..5764be36d23 100644 --- a/docs/api/qiskit-addon-obp/qiskit-addon-obp.mdx +++ b/docs/api/qiskit-addon-obp/qiskit-addon-obp.mdx @@ -33,8 +33,8 @@ Main operator backpropagation functionality. **Parameters** - * **observables** ([*SparsePauliOp*](/api/qiskit/qiskit.quantum_info.SparsePauliOp "(in Qiskit v1.2)") *|*[*list*](https://docs.python.org/3/library/stdtypes.html#list "(in Python v3.13)")*\[*[*SparsePauliOp*](/api/qiskit/qiskit.quantum_info.SparsePauliOp "(in Qiskit v1.2)")*]*) – The observable(s) onto which the circuit is backpropagated. - * **slices** ([*Sequence*](https://docs.python.org/3/library/collections.abc.html#collections.abc.Sequence "(in Python v3.13)")*\[*[*QuantumCircuit*](/api/qiskit/qiskit.circuit.QuantumCircuit "(in Qiskit v1.2)")*]*) – A sequence of `QuantumCircuit` objects representing a single circuit which has been separated into partitions spanning all qubits. **These “slices” will be backpropagated in reverse order.** Each slice must span all qubits. One may use the tools provided in [`qiskit_addon_utils.slicing`](https://qiskit.github.io/qiskit-addon-utils/apidocs/qiskit_addon_utils.slicing.html#module-qiskit_addon_utils.slicing "(in Qiskit addon utilities)") to slice a single [`QuantumCircuit`](/api/qiskit/qiskit.circuit.QuantumCircuit "(in Qiskit v1.2)"). + * **observables** ([*SparsePauliOp*](/api/qiskit/qiskit.quantum_info.SparsePauliOp "(in Qiskit v1.3)") *|*[*list*](https://docs.python.org/3/library/stdtypes.html#list "(in Python v3.13)")*\[*[*SparsePauliOp*](/api/qiskit/qiskit.quantum_info.SparsePauliOp "(in Qiskit v1.3)")*]*) – The observable(s) onto which the circuit is backpropagated. + * **slices** ([*Sequence*](https://docs.python.org/3/library/collections.abc.html#collections.abc.Sequence "(in Python v3.13)")*\[*[*QuantumCircuit*](/api/qiskit/qiskit.circuit.QuantumCircuit "(in Qiskit v1.3)")*]*) – A sequence of `QuantumCircuit` objects representing a single circuit which has been separated into partitions spanning all qubits. **These “slices” will be backpropagated in reverse order.** Each slice must span all qubits. One may use the tools provided in [`qiskit_addon_utils.slicing`](https://qiskit.github.io/qiskit-addon-utils/apidocs/qiskit_addon_utils.slicing.html#module-qiskit_addon_utils.slicing "(in Qiskit addon utilities)") to slice a single [`QuantumCircuit`](/api/qiskit/qiskit.circuit.QuantumCircuit "(in Qiskit v1.3)"). * **truncation\_error\_budget** ([*TruncationErrorBudget*](utils-truncating#truncationerrorbudget "qiskit_addon_obp.utils.truncating.TruncationErrorBudget") *| None*) – The error budget used for truncating Pauli terms. Refer to the [how-to guide](https://qiskit.github.io/qiskit-addon-obp/how_tos/truncate_operator_terms.html) for a detailed discussion on truncating terms from the output operator and bounding the incurred error. * **operator\_budget** ([*OperatorBudget*](utils-simplify#operatorbudget "qiskit_addon_obp.utils.simplify.OperatorBudget") *| None*) – Constraints on how large the operator may grow during backpropagation. If `None`, a default instance of [`OperatorBudget`](utils-simplify#operatorbudget "qiskit_addon_obp.utils.simplify.OperatorBudget") will be used, and no constraints will be placed on the output operator size. * **max\_seconds** ([*int*](https://docs.python.org/3/library/functions.html#int "(in Python v3.13)") *| None*) – The maximum number of seconds to run the backpropagation. If this timeout is triggered before the function returns, the metadata of that moment will be returned. Note, that this metadata may contain only partial information for the last slice being backpropagated. @@ -54,6 +54,6 @@ Main operator backpropagation functionality. **Return type** - [tuple](https://docs.python.org/3/library/stdtypes.html#tuple "(in Python v3.13)")\[[list](https://docs.python.org/3/library/stdtypes.html#list "(in Python v3.13)")\[[*SparsePauliOp*](/api/qiskit/qiskit.quantum_info.SparsePauliOp "(in Qiskit v1.2)")], [*Sequence*](https://docs.python.org/3/library/collections.abc.html#collections.abc.Sequence "(in Python v3.13)")\[[*QuantumCircuit*](/api/qiskit/qiskit.circuit.QuantumCircuit "(in Qiskit v1.2)")], [*OBPMetadata*](utils-metadata-obp-metadata "qiskit_addon_obp.utils.metadata.OBPMetadata")] + [tuple](https://docs.python.org/3/library/stdtypes.html#tuple "(in Python v3.13)")\[[list](https://docs.python.org/3/library/stdtypes.html#list "(in Python v3.13)")\[[*SparsePauliOp*](/api/qiskit/qiskit.quantum_info.SparsePauliOp "(in Qiskit v1.3)")], [*Sequence*](https://docs.python.org/3/library/collections.abc.html#collections.abc.Sequence "(in Python v3.13)")\[[*QuantumCircuit*](/api/qiskit/qiskit.circuit.QuantumCircuit "(in Qiskit v1.3)")], [*OBPMetadata*](utils-metadata-obp-metadata "qiskit_addon_obp.utils.metadata.OBPMetadata")] diff --git a/docs/api/qiskit-addon-obp/utils-operations.mdx b/docs/api/qiskit-addon-obp/utils-operations.mdx index e8f2152de88..8ff0a9756d1 100644 --- a/docs/api/qiskit-addon-obp/utils-operations.mdx +++ b/docs/api/qiskit-addon-obp/utils-operations.mdx @@ -33,9 +33,9 @@ Utility functions for operator backpropagation. **Parameters** - * **op1** ([*SparsePauliOp*](/api/qiskit/qiskit.quantum_info.SparsePauliOp "(in Qiskit v1.2)")) – The operator on which `op2` will be applied. + * **op1** ([*SparsePauliOp*](/api/qiskit/qiskit.quantum_info.SparsePauliOp "(in Qiskit v1.3)")) – The operator on which `op2` will be applied. * **op1\_qargs** ([*list*](https://docs.python.org/3/library/stdtypes.html#list "(in Python v3.13)")*\[*[*int*](https://docs.python.org/3/library/functions.html#int "(in Python v3.13)")*]*) – The qubit indices for `op1`. - * **op2** ([*SparsePauliOp*](/api/qiskit/qiskit.quantum_info.SparsePauliOp "(in Qiskit v1.2)")) – The operator to apply to `op1`. + * **op2** ([*SparsePauliOp*](/api/qiskit/qiskit.quantum_info.SparsePauliOp "(in Qiskit v1.3)")) – The operator to apply to `op1`. * **op2\_qargs** ([*list*](https://docs.python.org/3/library/stdtypes.html#list "(in Python v3.13)")*\[*[*int*](https://docs.python.org/3/library/functions.html#int "(in Python v3.13)")*]*) – The qubit indices for `op2`. * **apply\_as\_transform** ([*bool*](https://docs.python.org/3/library/functions.html#bool "(in Python v3.13)")) – Whether to apply `op2` to `op1` as a transformation. @@ -51,7 +51,7 @@ Utility functions for operator backpropagation. **Return type** - [tuple](https://docs.python.org/3/library/stdtypes.html#tuple "(in Python v3.13)")\[[*SparsePauliOp*](/api/qiskit/qiskit.quantum_info.SparsePauliOp "(in Qiskit v1.2)"), [list](https://docs.python.org/3/library/stdtypes.html#list "(in Python v3.13)")\[[int](https://docs.python.org/3/library/functions.html#int "(in Python v3.13)")]] + [tuple](https://docs.python.org/3/library/stdtypes.html#tuple "(in Python v3.13)")\[[*SparsePauliOp*](/api/qiskit/qiskit.quantum_info.SparsePauliOp "(in Qiskit v1.3)"), [list](https://docs.python.org/3/library/stdtypes.html#list "(in Python v3.13)")\[[int](https://docs.python.org/3/library/functions.html#int "(in Python v3.13)")]] ### apply\_reset\_to @@ -67,7 +67,7 @@ Utility functions for operator backpropagation. **Parameters** - * **op** ([*SparsePauliOp*](/api/qiskit/qiskit.quantum_info.SparsePauliOp "(in Qiskit v1.2)")) – The operator to which the reset will be applied. + * **op** ([*SparsePauliOp*](/api/qiskit/qiskit.quantum_info.SparsePauliOp "(in Qiskit v1.3)")) – The operator to which the reset will be applied. * **qubit\_id** ([*int*](https://docs.python.org/3/library/functions.html#int "(in Python v3.13)")) – The index of the qubit on which to apply the reset. * **inplace** ([*bool*](https://docs.python.org/3/library/functions.html#bool "(in Python v3.13)")) – Whether to modify the operator in-place. @@ -77,7 +77,7 @@ Utility functions for operator backpropagation. **Return type** - [*SparsePauliOp*](/api/qiskit/qiskit.quantum_info.SparsePauliOp "(in Qiskit v1.2)") + [*SparsePauliOp*](/api/qiskit/qiskit.quantum_info.SparsePauliOp "(in Qiskit v1.3)") ### to\_global\_op @@ -87,7 +87,7 @@ Utility functions for operator backpropagation. **Parameters** - * **op** ([*SparsePauliOp*](/api/qiskit/qiskit.quantum_info.SparsePauliOp "(in Qiskit v1.2)")) – Local operator to expand. + * **op** ([*SparsePauliOp*](/api/qiskit/qiskit.quantum_info.SparsePauliOp "(in Qiskit v1.3)")) – Local operator to expand. * **qargs** ([*list*](https://docs.python.org/3/library/stdtypes.html#list "(in Python v3.13)")*\[*[*int*](https://docs.python.org/3/library/functions.html#int "(in Python v3.13)")*]*) – Qubit indices for local operator. * **n\_qubits** ([*int*](https://docs.python.org/3/library/functions.html#int "(in Python v3.13)")) – Number of qubits in the global system. @@ -101,7 +101,7 @@ Utility functions for operator backpropagation. **Return type** - [*SparsePauliOp*](/api/qiskit/qiskit.quantum_info.SparsePauliOp "(in Qiskit v1.2)") + [*SparsePauliOp*](/api/qiskit/qiskit.quantum_info.SparsePauliOp "(in Qiskit v1.3)") ### reduce\_op @@ -125,7 +125,7 @@ Utility functions for operator backpropagation. **Parameters** - **global\_op** ([*SparsePauliOp*](/api/qiskit/qiskit.quantum_info.SparsePauliOp "(in Qiskit v1.2)")) – The global operator for which to generate a lean representation + **global\_op** ([*SparsePauliOp*](/api/qiskit/qiskit.quantum_info.SparsePauliOp "(in Qiskit v1.3)")) – The global operator for which to generate a lean representation **Returns** @@ -138,6 +138,6 @@ Utility functions for operator backpropagation. **Return type** - [tuple](https://docs.python.org/3/library/stdtypes.html#tuple "(in Python v3.13)")\[[*SparsePauliOp*](/api/qiskit/qiskit.quantum_info.SparsePauliOp "(in Qiskit v1.2)"), [list](https://docs.python.org/3/library/stdtypes.html#list "(in Python v3.13)")\[[int](https://docs.python.org/3/library/functions.html#int "(in Python v3.13)")]] + [tuple](https://docs.python.org/3/library/stdtypes.html#tuple "(in Python v3.13)")\[[*SparsePauliOp*](/api/qiskit/qiskit.quantum_info.SparsePauliOp "(in Qiskit v1.3)"), [list](https://docs.python.org/3/library/stdtypes.html#list "(in Python v3.13)")\[[int](https://docs.python.org/3/library/functions.html#int "(in Python v3.13)")]] diff --git a/docs/api/qiskit-addon-obp/utils-simplify.mdx b/docs/api/qiskit-addon-obp/utils-simplify.mdx index 265b8b57771..f2f00754251 100644 --- a/docs/api/qiskit-addon-obp/utils-simplify.mdx +++ b/docs/api/qiskit-addon-obp/utils-simplify.mdx @@ -107,7 +107,7 @@ Functions for simplifying Pauli operators. **Parameters** - * **operator** ([*SparsePauliOp*](/api/qiskit/qiskit.quantum_info.SparsePauliOp "(in Qiskit v1.2)")) – the `SparsePauliOp` to simplify. + * **operator** ([*SparsePauliOp*](/api/qiskit/qiskit.quantum_info.SparsePauliOp "(in Qiskit v1.3)")) – the `SparsePauliOp` to simplify. * **atol** ([*float*](https://docs.python.org/3/library/functions.html#float "(in Python v3.13)") *| None*) – the absolute tolerance for checking if coefficients are zero. If `None`, this will fallback to using `SparsePauliOp.atol`. * **rtol** ([*float*](https://docs.python.org/3/library/functions.html#float "(in Python v3.13)") *| None*) – the relative tolerance for checking if coefficients are zero. If `None`, this will fallback to using `SparsePauliOp.rtol`. @@ -117,6 +117,6 @@ Functions for simplifying Pauli operators. **Return type** - [tuple](https://docs.python.org/3/library/stdtypes.html#tuple "(in Python v3.13)")\[[*SparsePauliOp*](/api/qiskit/qiskit.quantum_info.SparsePauliOp "(in Qiskit v1.2)"), [*SimplifyMetadata*](#qiskit_addon_obp.utils.simplify.SimplifyMetadata "qiskit_addon_obp.utils.simplify.SimplifyMetadata")] + [tuple](https://docs.python.org/3/library/stdtypes.html#tuple "(in Python v3.13)")\[[*SparsePauliOp*](/api/qiskit/qiskit.quantum_info.SparsePauliOp "(in Qiskit v1.3)"), [*SimplifyMetadata*](#qiskit_addon_obp.utils.simplify.SimplifyMetadata "qiskit_addon_obp.utils.simplify.SimplifyMetadata")] diff --git a/docs/api/qiskit-addon-obp/utils-truncating.mdx b/docs/api/qiskit-addon-obp/utils-truncating.mdx index 2b9c5d38a90..d6c54dbfee6 100644 --- a/docs/api/qiskit-addon-obp/utils-truncating.mdx +++ b/docs/api/qiskit-addon-obp/utils-truncating.mdx @@ -42,7 +42,7 @@ Functions for truncating Pauli operators within given error budgets. #### max\_error\_total - The maximum total truncation error to allow for each observable during the entire backpropagation. This value may be [`numpy.inf`](https://numpy.org/doc/stable/reference/constants.html#numpy.inf "(in NumPy v2.1)"), for example when the maximum error was left unspecified during `setup_budget()`. + The maximum total truncation error to allow for each observable during the entire backpropagation. This value may be [`numpy.inf`](https://numpy.org/doc/stable/reference/constants.html#numpy.inf "(in NumPy v2.2)"), for example when the maximum error was left unspecified during `setup_budget()`. #### p\_norm @@ -109,7 +109,7 @@ Functions for truncating Pauli operators within given error budgets. **Parameters** - * **observable** ([*SparsePauliOp*](/api/qiskit/qiskit.quantum_info.SparsePauliOp "(in Qiskit v1.2)")) – the `SparsePauliOp` to truncate terms from. + * **observable** ([*SparsePauliOp*](/api/qiskit/qiskit.quantum_info.SparsePauliOp "(in Qiskit v1.3)")) – the `SparsePauliOp` to truncate terms from. * **budget** ([*float*](https://docs.python.org/3/library/functions.html#float "(in Python v3.13)")) – the maximum permissable truncation error. * **p\_norm** ([*int*](https://docs.python.org/3/library/functions.html#int "(in Python v3.13)")) – an integer specifying what p-norm to use. @@ -123,6 +123,6 @@ Functions for truncating Pauli operators within given error budgets. **Return type** - [tuple](https://docs.python.org/3/library/stdtypes.html#tuple "(in Python v3.13)")\[[*SparsePauliOp*](/api/qiskit/qiskit.quantum_info.SparsePauliOp "(in Qiskit v1.2)"), [float](https://docs.python.org/3/library/functions.html#float "(in Python v3.13)")] + [tuple](https://docs.python.org/3/library/stdtypes.html#tuple "(in Python v3.13)")\[[*SparsePauliOp*](/api/qiskit/qiskit.quantum_info.SparsePauliOp "(in Qiskit v1.3)"), [float](https://docs.python.org/3/library/functions.html#float "(in Python v3.13)")] diff --git a/docs/api/qiskit-addon-obp/utils-visualization.mdx b/docs/api/qiskit-addon-obp/utils-visualization.mdx index 350b2999d06..61c57d1674f 100644 --- a/docs/api/qiskit-addon-obp/utils-visualization.mdx +++ b/docs/api/qiskit-addon-obp/utils-visualization.mdx @@ -18,7 +18,7 @@ Various visualization utilities. ### plot\_accumulated\_error - + Plot the accumulated error. This method populates the provided figure axes with a line-plot of the [`OBPMetadata.accumulated_error()`](utils-metadata-obp-metadata#accumulated_error "qiskit_addon_obp.utils.metadata.OBPMetadata.accumulated_error"). Below is an example where we plot some `metadata` which exists within our context. @@ -30,9 +30,9 @@ Various visualization utilities. >>> plot_accumulated_error(metadata, axes) ``` - ![../\_images/qiskit\_addon\_obp-utils-visualization-2.png](/images/api/qiskit-addon-obp/qiskit_addon_obp-utils-visualization-2.png) + ![Output from the previous code.](/images/api/qiskit-addon-obp/qiskit_addon_obp-utils-visualization-2.png) - As you can see in the figure above, the number of backpropagated slices is displayed along the x-axis. You can think of this as the “time” of the backpropagation algorithm. The accumulated error due to truncated Pauli terms is displayed along the y-axis. If `OBPMetadata.truncation_error_budget.max_error_total` is not [`numpy.inf`](https://numpy.org/doc/stable/reference/constants.html#numpy.inf "(in NumPy v2.1)"), it is displayed as a red horizontal line. Each observable that was backpropagated, gets its own line. + As you can see in the figure above, the number of backpropagated slices is displayed along the x-axis. You can think of this as the “time” of the backpropagation algorithm. The accumulated error due to truncated Pauli terms is displayed along the y-axis. If `OBPMetadata.truncation_error_budget.max_error_total` is not [`numpy.inf`](https://numpy.org/doc/stable/reference/constants.html#numpy.inf "(in NumPy v2.2)"), it is displayed as a red horizontal line. Each observable that was backpropagated, gets its own line. This data is related to the one visualized by [`plot_slice_errors()`](#qiskit_addon_obp.utils.visualization.plot_slice_errors "qiskit_addon_obp.utils.visualization.plot_slice_errors"). This method plots the cumulative sum of the slice errors along the x-axis. @@ -48,7 +48,7 @@ Various visualization utilities. ### plot\_left\_over\_error\_budget - + Plot the left-over error budget. This method populates the provided figure axes with a line-plot of the [`OBPMetadata.left_over_error_budget()`](utils-metadata-obp-metadata#left_over_error_budget "qiskit_addon_obp.utils.metadata.OBPMetadata.left_over_error_budget"). Below is an example where we plot some `metadata` which exists within our context. @@ -60,7 +60,7 @@ Various visualization utilities. >>> plot_left_over_error_budget(metadata, axes) ``` - ![../\_images/qiskit\_addon\_obp-utils-visualization-4.png](/images/api/qiskit-addon-obp/qiskit_addon_obp-utils-visualization-4.png) + ![Output from the previous code.](/images/api/qiskit-addon-obp/qiskit_addon_obp-utils-visualization-4.png) As you can see in the figure above, the number of backpropagated slices is displayed along the x-axis. You can think of this as the “time” of the backpropagation algorithm. The left-over error budget available at each backpropagation step is displayed along the y-axis. Since each observable that was backpropagated has its own budget, they are plotted as separate lines. @@ -76,7 +76,7 @@ Various visualization utilities. ### plot\_slice\_errors - + Plot the slice errors. This method populates the provided figure axes with a bar-plot of the truncation error incurred at each backpropagated slice. Below is an example where we plot some `metadata` which exists within our context. @@ -88,7 +88,7 @@ Various visualization utilities. >>> plot_slice_errors(metadata, axes) ``` - ![../\_images/qiskit\_addon\_obp-utils-visualization-6.png](/images/api/qiskit-addon-obp/qiskit_addon_obp-utils-visualization-6.png) + ![Output from the previous code.](/images/api/qiskit-addon-obp/qiskit_addon_obp-utils-visualization-6.png) As you can see in the figure above, the number of backpropagated slices is displayed along the x-axis. You can think of this as the “time” of the backpropagation algorithm. The truncation error incurred at each backpropagation step is displayed along the y-axis. Since each observable is treated individually, they are plotted separately. @@ -106,7 +106,7 @@ Various visualization utilities. ### plot\_num\_paulis - + Plot the number of Pauli terms. This method populates the provided figure axes with a line-plot of the number of Pauli terms at each backpropagated slice. Below is an example where we plot some `metadata` which exists within our context. @@ -118,7 +118,7 @@ Various visualization utilities. >>> plot_num_paulis(metadata, axes) ``` - ![../\_images/qiskit\_addon\_obp-utils-visualization-8.png](/images/api/qiskit-addon-obp/qiskit_addon_obp-utils-visualization-8.png) + ![Output from the previous code.](/images/api/qiskit-addon-obp/qiskit_addon_obp-utils-visualization-8.png) As you can see in the figure above, the number of backpropagated slices is displayed along the x-axis. You can think of this as the “time” of the backpropagation algorithm. The number of Pauli terms at each backpropagation step is displayed along the y-axis. Since each observable is treated individually, they are plotted separately. @@ -136,7 +136,7 @@ Various visualization utilities. ### plot\_num\_truncated\_paulis - + Plot the number of truncated Pauli terms. This method populates the provided figure axes with a bar-plot of the number of the truncated Pauli terms at each backpropagated slice. Below is an example where we plot some `metadata` which exists within our context. @@ -148,7 +148,7 @@ Various visualization utilities. >>> plot_num_truncated_paulis(metadata, axes) ``` - ![../\_images/qiskit\_addon\_obp-utils-visualization-10.png](/images/api/qiskit-addon-obp/qiskit_addon_obp-utils-visualization-10.png) + ![Output from the previous code.](/images/api/qiskit-addon-obp/qiskit_addon_obp-utils-visualization-10.png) As you can see in the figure above, the number of backpropagated slices is displayed along the x-axis. You can think of this as the “time” of the backpropagation algorithm. The number of truncated Pauli terms at each backpropagation step is displayed along the y-axis. Since each observable is treated individually, they are plotted separately. @@ -166,7 +166,7 @@ Various visualization utilities. ### plot\_sum\_paulis - + Plot the total number of all Pauli terms. This method populates the provided figure axes with a line-plot of the total number of all Pauli terms at each backpropagated slice. Below is an example where we plot some `metadata` which exists within our context. @@ -178,7 +178,7 @@ Various visualization utilities. >>> plot_sum_paulis(metadata, axes) ``` - ![../\_images/qiskit\_addon\_obp-utils-visualization-12.png](/images/api/qiskit-addon-obp/qiskit_addon_obp-utils-visualization-12.png) + ![Output from the previous code.](/images/api/qiskit-addon-obp/qiskit_addon_obp-utils-visualization-12.png) As you can see in the figure above, the number of backpropagated slices is displayed along the x-axis. You can think of this as the “time” of the backpropagation algorithm. The total number of all Pauli terms at each backpropagation step is displayed along the y-axis. If `OBPMetadata.operator_budget.max_paulis` is not None, it is displayed as a red horizontal line. @@ -196,7 +196,7 @@ Various visualization utilities. ### plot\_num\_qwc\_groups - + Plot the number of qubit-wise commuting Pauli groups. This method populates the provided figure axes with a line-plot of the number of qubit-wise commuting Pauli groups at each backpropagated slice. Below is an example where we plot some `metadata` which exists within our context. @@ -208,7 +208,7 @@ Various visualization utilities. >>> plot_num_qwc_groups(metadata, axes) ``` - ![../\_images/qiskit\_addon\_obp-utils-visualization-14.png](/images/api/qiskit-addon-obp/qiskit_addon_obp-utils-visualization-14.png) + ![Output from the previous code.](/images/api/qiskit-addon-obp/qiskit_addon_obp-utils-visualization-14.png) As you can see in the figure above, the number of backpropagated slices is displayed along the x-axis. You can think of this as the “time” of the backpropagation algorithm. The number of qubit-wise commuting Pauli groups at each backpropagation step is displayed along the y-axis. If `OBPMetadata.operator_budget.max_qwc_groups` is not None, it is displayed as a red horizontal line. diff --git a/docs/api/qiskit-addon-utils/problem-generators.mdx b/docs/api/qiskit-addon-utils/problem-generators.mdx index db19722751b..e77d6ca885b 100644 --- a/docs/api/qiskit-addon-utils/problem-generators.mdx +++ b/docs/api/qiskit-addon-utils/problem-generators.mdx @@ -61,7 +61,7 @@ $$ **Parameters** - * **coupling** ([*CouplingMap*](/api/qiskit/qiskit.transpiler.CouplingMap "(in Qiskit v1.2)") *|*[*PyGraph*](https://www.rustworkx.org/apiref/rustworkx.PyGraph.html#rustworkx.PyGraph "(in rustworkx v0.15)") *|*[*PyDiGraph*](https://www.rustworkx.org/apiref/rustworkx.PyDiGraph.html#rustworkx.PyDiGraph "(in rustworkx v0.15)")) – The qubit subgraph on which to map the Hamiltonian. Directionality of graph edges will be ignored, and parallel edges will be treated as a single edge during generation of the operator. + * **coupling** ([*CouplingMap*](/api/qiskit/qiskit.transpiler.CouplingMap "(in Qiskit v1.3)") *|*[*PyGraph*](https://www.rustworkx.org/apiref/rustworkx.PyGraph.html#rustworkx.PyGraph "(in rustworkx v0.15)") *|*[*PyDiGraph*](https://www.rustworkx.org/apiref/rustworkx.PyDiGraph.html#rustworkx.PyDiGraph "(in rustworkx v0.15)")) – The qubit subgraph on which to map the Hamiltonian. Directionality of graph edges will be ignored, and parallel edges will be treated as a single edge during generation of the operator. * **coupling\_constants** ([*Sequence*](https://docs.python.org/3/library/collections.abc.html#collections.abc.Sequence "(in Python v3.13)")*\[*[*float*](https://docs.python.org/3/library/functions.html#float "(in Python v3.13)")*]*) – The real-valued coupling constants, $J_i$, in each Cartesian axis. * **ext\_magnetic\_field** ([*Sequence*](https://docs.python.org/3/library/collections.abc.html#collections.abc.Sequence "(in Python v3.13)")*\[*[*float*](https://docs.python.org/3/library/functions.html#float "(in Python v3.13)")*]*) – The coefficients, $h_i$, representing a magnetic field along each Cartesian axis. * **pauli\_order\_strategy** ([*PauliOrderStrategy*](#qiskit_addon_utils.problem_generators.PauliOrderStrategy "qiskit_addon_utils.problem_generators.generate_xyz_hamiltonian.PauliOrderStrategy")) – Indicates the iteration strategy in which the Pauli terms will be generated. See [`PauliOrderStrategy`](#qiskit_addon_utils.problem_generators.PauliOrderStrategy "qiskit_addon_utils.problem_generators.PauliOrderStrategy") for more details. @@ -78,12 +78,12 @@ $$ **Return type** - [*SparsePauliOp*](/api/qiskit/qiskit.quantum_info.SparsePauliOp "(in Qiskit v1.2)") + [*SparsePauliOp*](/api/qiskit/qiskit.quantum_info.SparsePauliOp "(in Qiskit v1.3)") ### generate\_time\_evolution\_circuit - + Model the time evolution of an operator. ```python @@ -114,21 +114,21 @@ $$ >>> _ = circ.draw("mpl", fold=-1) ``` - ![../\_images/qiskit\_addon\_utils-problem\_generators-1.png](/images/api/qiskit-addon-utils/qiskit_addon_utils-problem_generators-1.png) + ![Output from the previous code.](/images/api/qiskit-addon-utils/qiskit_addon_utils-problem_generators-1.png) **Parameters** - * **operator** ([*SparsePauliOp*](/api/qiskit/qiskit.quantum_info.SparsePauliOp "(in Qiskit v1.2)")) – The operator for which to model the time evolution. - * **synthesis** ([*EvolutionSynthesis*](/api/qiskit/qiskit.synthesis.EvolutionSynthesis "(in Qiskit v1.2)") *| None*) – A synthesis strategy. If `None`, the default synthesis is the Lie-Trotter product formula with a single repetition. + * **operator** ([*SparsePauliOp*](/api/qiskit/qiskit.quantum_info.SparsePauliOp "(in Qiskit v1.3)")) – The operator for which to model the time evolution. + * **synthesis** ([*EvolutionSynthesis*](/api/qiskit/qiskit.synthesis.EvolutionSynthesis "(in Qiskit v1.3)") *| None*) – A synthesis strategy. If `None`, the default synthesis is the Lie-Trotter product formula with a single repetition. * **time** ([*float*](https://docs.python.org/3/library/functions.html#float "(in Python v3.13)")) – The evolution time. **Returns** - A [`QuantumCircuit`](/api/qiskit/qiskit.circuit.QuantumCircuit "(in Qiskit v1.2)") implementing a time-evolved operator. + A [`QuantumCircuit`](/api/qiskit/qiskit.circuit.QuantumCircuit "(in Qiskit v1.3)") implementing a time-evolved operator. **Return type** - [*QuantumCircuit*](/api/qiskit/qiskit.circuit.QuantumCircuit "(in Qiskit v1.2)") + [*QuantumCircuit*](/api/qiskit/qiskit.circuit.QuantumCircuit "(in Qiskit v1.3)") ### PauliOrderStrategy diff --git a/docs/api/qiskit-addon-utils/slicing-transpiler-passes-collect-op-color.mdx b/docs/api/qiskit-addon-utils/slicing-transpiler-passes-collect-op-color.mdx index 9ac4350f74f..8f495b618de 100644 --- a/docs/api/qiskit-addon-utils/slicing-transpiler-passes-collect-op-color.mdx +++ b/docs/api/qiskit-addon-utils/slicing-transpiler-passes-collect-op-color.mdx @@ -9,7 +9,7 @@ python_api_name: qiskit_addon_utils.slicing.transpiler.passes.CollectOpColor # CollectOpColor - Bases: [`CollectAndCollapse`](/api/qiskit/qiskit.transpiler.passes.CollectAndCollapse "(in Qiskit v1.2)") + Bases: [`CollectAndCollapse`](/api/qiskit/qiskit.transpiler.passes.CollectAndCollapse "(in Qiskit v1.3)") Collects blocks of operations which act on the provided edges. @@ -55,7 +55,7 @@ python_api_name: qiskit_addon_utils.slicing.transpiler.passes.CollectOpColor **Parameters** * **passmanager\_ir** ([*Any*](https://docs.python.org/3/library/typing.html#typing.Any "(in Python v3.13)")) – Qiskit IR to optimize. - * **state** ([*PassManagerState*](/api/qiskit/qiskit.passmanager.PassManagerState "(in Qiskit v1.2)")) – State associated with workflow execution by the pass manager itself. + * **state** ([*PassManagerState*](/api/qiskit/qiskit.passmanager.PassManagerState "(in Qiskit v1.3)")) – State associated with workflow execution by the pass manager itself. * **callback** ([*Callable*](https://docs.python.org/3/library/collections.abc.html#collections.abc.Callable "(in Python v3.13)") *| None*) – A callback function which is caller per execution of optimization task. **Returns** @@ -64,7 +64,7 @@ python_api_name: qiskit_addon_utils.slicing.transpiler.passes.CollectOpColor **Return type** - [tuple](https://docs.python.org/3/library/stdtypes.html#tuple "(in Python v3.13)")\[[*Any*](https://docs.python.org/3/library/typing.html#typing.Any "(in Python v3.13)"), [*PassManagerState*](/api/qiskit/qiskit.passmanager.PassManagerState "(in Qiskit v1.2)")] + [tuple](https://docs.python.org/3/library/stdtypes.html#tuple "(in Python v3.13)")\[[*Any*](https://docs.python.org/3/library/typing.html#typing.Any "(in Python v3.13)"), [*PassManagerState*](/api/qiskit/qiskit.passmanager.PassManagerState "(in Qiskit v1.3)")] ### name @@ -98,7 +98,7 @@ python_api_name: qiskit_addon_utils.slicing.transpiler.passes.CollectOpColor **Parameters** - * **state** ([*PassManagerState*](/api/qiskit/qiskit.passmanager.PassManagerState "(in Qiskit v1.2)")) – Pass manager state to update. + * **state** ([*PassManagerState*](/api/qiskit/qiskit.passmanager.PassManagerState "(in Qiskit v1.3)")) – Pass manager state to update. * **run\_state** (*RunState*) – Completion status of current task. **Returns** @@ -107,7 +107,7 @@ python_api_name: qiskit_addon_utils.slicing.transpiler.passes.CollectOpColor **Return type** - [*PassManagerState*](/api/qiskit/qiskit.passmanager.PassManagerState "(in Qiskit v1.2)") + [*PassManagerState*](/api/qiskit/qiskit.passmanager.PassManagerState "(in Qiskit v1.3)") diff --git a/docs/api/qiskit-addon-utils/slicing-transpiler-passes-collect-op-size.mdx b/docs/api/qiskit-addon-utils/slicing-transpiler-passes-collect-op-size.mdx index c391527326e..0fb49df9306 100644 --- a/docs/api/qiskit-addon-utils/slicing-transpiler-passes-collect-op-size.mdx +++ b/docs/api/qiskit-addon-utils/slicing-transpiler-passes-collect-op-size.mdx @@ -9,7 +9,7 @@ python_api_name: qiskit_addon_utils.slicing.transpiler.passes.CollectOpSize # CollectOpSize - Bases: [`CollectAndCollapse`](/api/qiskit/qiskit.transpiler.passes.CollectAndCollapse "(in Qiskit v1.2)") + Bases: [`CollectAndCollapse`](/api/qiskit/qiskit.transpiler.passes.CollectAndCollapse "(in Qiskit v1.3)") Collects blocks of the specified size and replaces them by a single block instruction. @@ -52,7 +52,7 @@ python_api_name: qiskit_addon_utils.slicing.transpiler.passes.CollectOpSize **Parameters** * **passmanager\_ir** ([*Any*](https://docs.python.org/3/library/typing.html#typing.Any "(in Python v3.13)")) – Qiskit IR to optimize. - * **state** ([*PassManagerState*](/api/qiskit/qiskit.passmanager.PassManagerState "(in Qiskit v1.2)")) – State associated with workflow execution by the pass manager itself. + * **state** ([*PassManagerState*](/api/qiskit/qiskit.passmanager.PassManagerState "(in Qiskit v1.3)")) – State associated with workflow execution by the pass manager itself. * **callback** ([*Callable*](https://docs.python.org/3/library/collections.abc.html#collections.abc.Callable "(in Python v3.13)") *| None*) – A callback function which is caller per execution of optimization task. **Returns** @@ -61,7 +61,7 @@ python_api_name: qiskit_addon_utils.slicing.transpiler.passes.CollectOpSize **Return type** - [tuple](https://docs.python.org/3/library/stdtypes.html#tuple "(in Python v3.13)")\[[*Any*](https://docs.python.org/3/library/typing.html#typing.Any "(in Python v3.13)"), [*PassManagerState*](/api/qiskit/qiskit.passmanager.PassManagerState "(in Qiskit v1.2)")] + [tuple](https://docs.python.org/3/library/stdtypes.html#tuple "(in Python v3.13)")\[[*Any*](https://docs.python.org/3/library/typing.html#typing.Any "(in Python v3.13)"), [*PassManagerState*](/api/qiskit/qiskit.passmanager.PassManagerState "(in Qiskit v1.3)")] ### name @@ -95,7 +95,7 @@ python_api_name: qiskit_addon_utils.slicing.transpiler.passes.CollectOpSize **Parameters** - * **state** ([*PassManagerState*](/api/qiskit/qiskit.passmanager.PassManagerState "(in Qiskit v1.2)")) – Pass manager state to update. + * **state** ([*PassManagerState*](/api/qiskit/qiskit.passmanager.PassManagerState "(in Qiskit v1.3)")) – Pass manager state to update. * **run\_state** (*RunState*) – Completion status of current task. **Returns** @@ -104,7 +104,7 @@ python_api_name: qiskit_addon_utils.slicing.transpiler.passes.CollectOpSize **Return type** - [*PassManagerState*](/api/qiskit/qiskit.passmanager.PassManagerState "(in Qiskit v1.2)") + [*PassManagerState*](/api/qiskit/qiskit.passmanager.PassManagerState "(in Qiskit v1.3)") diff --git a/docs/api/qiskit-addon-utils/slicing-transpiler-passes-collect-op-type.mdx b/docs/api/qiskit-addon-utils/slicing-transpiler-passes-collect-op-type.mdx index 10ec0150c70..38c5a34960e 100644 --- a/docs/api/qiskit-addon-utils/slicing-transpiler-passes-collect-op-type.mdx +++ b/docs/api/qiskit-addon-utils/slicing-transpiler-passes-collect-op-type.mdx @@ -9,7 +9,7 @@ python_api_name: qiskit_addon_utils.slicing.transpiler.passes.CollectOpType # CollectOpType - Bases: [`CollectAndCollapse`](/api/qiskit/qiskit.transpiler.passes.CollectAndCollapse "(in Qiskit v1.2)") + Bases: [`CollectAndCollapse`](/api/qiskit/qiskit.transpiler.passes.CollectAndCollapse "(in Qiskit v1.3)") Collects blocks of the specified operation and replaces them by a single block instruction. @@ -52,7 +52,7 @@ python_api_name: qiskit_addon_utils.slicing.transpiler.passes.CollectOpType **Parameters** * **passmanager\_ir** ([*Any*](https://docs.python.org/3/library/typing.html#typing.Any "(in Python v3.13)")) – Qiskit IR to optimize. - * **state** ([*PassManagerState*](/api/qiskit/qiskit.passmanager.PassManagerState "(in Qiskit v1.2)")) – State associated with workflow execution by the pass manager itself. + * **state** ([*PassManagerState*](/api/qiskit/qiskit.passmanager.PassManagerState "(in Qiskit v1.3)")) – State associated with workflow execution by the pass manager itself. * **callback** ([*Callable*](https://docs.python.org/3/library/collections.abc.html#collections.abc.Callable "(in Python v3.13)") *| None*) – A callback function which is caller per execution of optimization task. **Returns** @@ -61,7 +61,7 @@ python_api_name: qiskit_addon_utils.slicing.transpiler.passes.CollectOpType **Return type** - [tuple](https://docs.python.org/3/library/stdtypes.html#tuple "(in Python v3.13)")\[[*Any*](https://docs.python.org/3/library/typing.html#typing.Any "(in Python v3.13)"), [*PassManagerState*](/api/qiskit/qiskit.passmanager.PassManagerState "(in Qiskit v1.2)")] + [tuple](https://docs.python.org/3/library/stdtypes.html#tuple "(in Python v3.13)")\[[*Any*](https://docs.python.org/3/library/typing.html#typing.Any "(in Python v3.13)"), [*PassManagerState*](/api/qiskit/qiskit.passmanager.PassManagerState "(in Qiskit v1.3)")] ### name @@ -95,7 +95,7 @@ python_api_name: qiskit_addon_utils.slicing.transpiler.passes.CollectOpType **Parameters** - * **state** ([*PassManagerState*](/api/qiskit/qiskit.passmanager.PassManagerState "(in Qiskit v1.2)")) – Pass manager state to update. + * **state** ([*PassManagerState*](/api/qiskit/qiskit.passmanager.PassManagerState "(in Qiskit v1.3)")) – Pass manager state to update. * **run\_state** (*RunState*) – Completion status of current task. **Returns** @@ -104,7 +104,7 @@ python_api_name: qiskit_addon_utils.slicing.transpiler.passes.CollectOpType **Return type** - [*PassManagerState*](/api/qiskit/qiskit.passmanager.PassManagerState "(in Qiskit v1.2)") + [*PassManagerState*](/api/qiskit/qiskit.passmanager.PassManagerState "(in Qiskit v1.3)") diff --git a/docs/api/qiskit-addon-utils/slicing.mdx b/docs/api/qiskit-addon-utils/slicing.mdx index a9c3243515f..1901f09be72 100644 --- a/docs/api/qiskit-addon-utils/slicing.mdx +++ b/docs/api/qiskit-addon-utils/slicing.mdx @@ -25,12 +25,12 @@ For more information, check out the [how-to guide](https://qiskit.github.io/qisk **Parameters** - * **slices** ([*Sequence*](https://docs.python.org/3/library/collections.abc.html#collections.abc.Sequence "(in Python v3.13)")*\[*[*QuantumCircuit*](/api/qiskit/qiskit.circuit.QuantumCircuit "(in Qiskit v1.2)")*]*) – The N-qubit circuit slices. + * **slices** ([*Sequence*](https://docs.python.org/3/library/collections.abc.html#collections.abc.Sequence "(in Python v3.13)")*\[*[*QuantumCircuit*](/api/qiskit/qiskit.circuit.QuantumCircuit "(in Qiskit v1.3)")*]*) – The N-qubit circuit slices. * **include\_barriers** ([*bool*](https://docs.python.org/3/library/functions.html#bool "(in Python v3.13)")) – If `True`, place barriers between each slice. **Returns** - A [`QuantumCircuit`](/api/qiskit/qiskit.circuit.QuantumCircuit "(in Qiskit v1.2)") with the slices appended in sequential order. + A [`QuantumCircuit`](/api/qiskit/qiskit.circuit.QuantumCircuit "(in Qiskit v1.3)") with the slices appended in sequential order. **Raises** @@ -38,7 +38,7 @@ For more information, check out the [how-to guide](https://qiskit.github.io/qisk **Return type** - [*QuantumCircuit*](/api/qiskit/qiskit.circuit.QuantumCircuit "(in Qiskit v1.2)") | None + [*QuantumCircuit*](/api/qiskit/qiskit.circuit.QuantumCircuit "(in Qiskit v1.3)") | None ### slice\_by\_barriers @@ -50,15 +50,15 @@ For more information, check out the [how-to guide](https://qiskit.github.io/qisk **Parameters** - **circuit** ([*QuantumCircuit*](/api/qiskit/qiskit.circuit.QuantumCircuit "(in Qiskit v1.2)")) – The circuit to be split. + **circuit** ([*QuantumCircuit*](/api/qiskit/qiskit.circuit.QuantumCircuit "(in Qiskit v1.3)")) – The circuit to be split. **Returns** - A sequence of [`QuantumCircuit`](/api/qiskit/qiskit.circuit.QuantumCircuit "(in Qiskit v1.2)") objects, one for each slice. + A sequence of [`QuantumCircuit`](/api/qiskit/qiskit.circuit.QuantumCircuit "(in Qiskit v1.3)") objects, one for each slice. **Return type** - [list](https://docs.python.org/3/library/stdtypes.html#list "(in Python v3.13)")\[[*QuantumCircuit*](/api/qiskit/qiskit.circuit.QuantumCircuit "(in Qiskit v1.2)")] + [list](https://docs.python.org/3/library/stdtypes.html#list "(in Python v3.13)")\[[*QuantumCircuit*](/api/qiskit/qiskit.circuit.QuantumCircuit "(in Qiskit v1.3)")] ### slice\_by\_coloring @@ -118,12 +118,12 @@ For more information, check out the [how-to guide](https://qiskit.github.io/qisk **Parameters** - * **circuit** ([*QuantumCircuit*](/api/qiskit/qiskit.circuit.QuantumCircuit "(in Qiskit v1.2)")) – The circuit to be split. + * **circuit** ([*QuantumCircuit*](/api/qiskit/qiskit.circuit.QuantumCircuit "(in Qiskit v1.3)")) – The circuit to be split. * **coloring** ([*dict*](https://docs.python.org/3/library/stdtypes.html#dict "(in Python v3.13)")*\[*[*tuple*](https://docs.python.org/3/library/stdtypes.html#tuple "(in Python v3.13)")*\[*[*int*](https://docs.python.org/3/library/functions.html#int "(in Python v3.13)")*,* [*int*](https://docs.python.org/3/library/functions.html#int "(in Python v3.13)")*],* [*int*](https://docs.python.org/3/library/functions.html#int "(in Python v3.13)")*]*) – A dictionary mapping edges (pairs of integers) to color values. **Returns** - A sequence of [`QuantumCircuit`](/api/qiskit/qiskit.circuit.QuantumCircuit "(in Qiskit v1.2)") objects, one for each slice. + A sequence of [`QuantumCircuit`](/api/qiskit/qiskit.circuit.QuantumCircuit "(in Qiskit v1.3)") objects, one for each slice. **Raises** @@ -132,7 +132,7 @@ For more information, check out the [how-to guide](https://qiskit.github.io/qisk **Return type** - [list](https://docs.python.org/3/library/stdtypes.html#list "(in Python v3.13)")\[[*QuantumCircuit*](/api/qiskit/qiskit.circuit.QuantumCircuit "(in Qiskit v1.2)")] + [list](https://docs.python.org/3/library/stdtypes.html#list "(in Python v3.13)")\[[*QuantumCircuit*](/api/qiskit/qiskit.circuit.QuantumCircuit "(in Qiskit v1.3)")] ### slice\_by\_depth @@ -140,20 +140,20 @@ For more information, check out the [how-to guide](https://qiskit.github.io/qisk Split a `QuantumCircuit` into slices based on depth. - This function transforms the input circuit into a [`DAGCircuit`](/api/qiskit/qiskit.dagcircuit.DAGCircuit "(in Qiskit v1.2)") and batches the sequence of depth-1 layers output from [`layers()`](/api/qiskit/qiskit.dagcircuit.DAGCircuit#layers "(in Qiskit v1.2)") into slices of depth not exceeding `max_slice_depth`. This is achieved by composing layers into slices until the max slice depth is reached and then starting a new slice with the next layer. The final slice may be composed of fewer than `max_slice_depth` layers. + This function transforms the input circuit into a [`DAGCircuit`](/api/qiskit/qiskit.dagcircuit.DAGCircuit "(in Qiskit v1.3)") and batches the sequence of depth-1 layers output from [`layers()`](/api/qiskit/qiskit.dagcircuit.DAGCircuit#layers "(in Qiskit v1.3)") into slices of depth not exceeding `max_slice_depth`. This is achieved by composing layers into slices until the max slice depth is reached and then starting a new slice with the next layer. The final slice may be composed of fewer than `max_slice_depth` layers. **Parameters** - * **circuit** ([*QuantumCircuit*](/api/qiskit/qiskit.circuit.QuantumCircuit "(in Qiskit v1.2)")) – The circuit to be split. + * **circuit** ([*QuantumCircuit*](/api/qiskit/qiskit.circuit.QuantumCircuit "(in Qiskit v1.3)")) – The circuit to be split. * **max\_slice\_depth** ([*int*](https://docs.python.org/3/library/functions.html#int "(in Python v3.13)")) – The maximum depth of a given slice. **Returns** - A sequence of [`QuantumCircuit`](/api/qiskit/qiskit.circuit.QuantumCircuit "(in Qiskit v1.2)") objects, one for each slice. + A sequence of [`QuantumCircuit`](/api/qiskit/qiskit.circuit.QuantumCircuit "(in Qiskit v1.3)") objects, one for each slice. **Return type** - [list](https://docs.python.org/3/library/stdtypes.html#list "(in Python v3.13)")\[[*QuantumCircuit*](/api/qiskit/qiskit.circuit.QuantumCircuit "(in Qiskit v1.2)")] + [list](https://docs.python.org/3/library/stdtypes.html#list "(in Python v3.13)")\[[*QuantumCircuit*](/api/qiskit/qiskit.circuit.QuantumCircuit "(in Qiskit v1.3)")] ### slice\_by\_gate\_types @@ -167,14 +167,14 @@ For more information, check out the [how-to guide](https://qiskit.github.io/qisk **Parameters** - **circuit** ([*QuantumCircuit*](/api/qiskit/qiskit.circuit.QuantumCircuit "(in Qiskit v1.2)")) – The circuit to be split. + **circuit** ([*QuantumCircuit*](/api/qiskit/qiskit.circuit.QuantumCircuit "(in Qiskit v1.3)")) – The circuit to be split. **Returns** - A sequence of [`QuantumCircuit`](/api/qiskit/qiskit.circuit.QuantumCircuit "(in Qiskit v1.2)") objects, one for each slice. + A sequence of [`QuantumCircuit`](/api/qiskit/qiskit.circuit.QuantumCircuit "(in Qiskit v1.3)") objects, one for each slice. **Return type** - [list](https://docs.python.org/3/library/stdtypes.html#list "(in Python v3.13)")\[[*QuantumCircuit*](/api/qiskit/qiskit.circuit.QuantumCircuit "(in Qiskit v1.2)")] + [list](https://docs.python.org/3/library/stdtypes.html#list "(in Python v3.13)")\[[*QuantumCircuit*](/api/qiskit/qiskit.circuit.QuantumCircuit "(in Qiskit v1.3)")] diff --git a/public/api/qiskit-addon-mpf/0.1/objects.inv b/public/api/qiskit-addon-mpf/0.1/objects.inv index 51ccd43abced02bee49dd88202351a12fda2bc01..f06c814c5e483eace89b4853d5893568afda17e2 100644 GIT binary patch delta 1419 zcmV;61$6qL45kc_t$#DSo2qQBcRh1E^SV$K4 znco{Ps#ML_TCt-i9r0Ta_^n6$GNDUl>&VnrVLAP^hqK+u8GbT-TW03@hz#N~p6FS6`~+fKG~Du1}bo*i^f!($zyyWja?*TJys zXxR1nVcm8a3hgYTd+_-Z+)^Eq;4k8lo&0^ zle$ncRl|VyeOqc(HKhq!uqTz_(iNdZ@?C{{sU2Vh=fk?d{XA9IIMdQ0Kv#fUmqkF6 zk2^$)UcS=>wSnGf&4rdk)j}y&lZ@Ay<`Y^ng@0?=VW7dl4~Kyklb~ArX4;Yu2(Tk*b9LSAQEAtYNhRY&ctlA(Fg$9GL-@$iRu2PMGSY{a&ioP8r|prwhN z64)f{#i6Mm#@aGnbBQaDOqUelxNj_AEpW6XX+sE6g0wNWAL0_MDxvNKl`eJy>4lrR zs()F9BOBXE=$f4D2~pLjzKga5umo(Ho1mdTrlr_@vdiN<{aInG!LA?J#Cm4a3FL=> z-!;!!$hYm#XA6iheE<&dYKf9hla$yrwJyXz`MR~X89urhJ01X<%pxi1EZfrZxm|)X zQNFSI*<2LhH*P;$QRH%xuq48V24kgr7=Jio()Hs2GT~lU|4tR^c|J5BfFH@B#m<{H z!31DbLy+R3Ew!_+%L39>X}cTliA^$aTF|06Ocxepd1wu=2j7q?ubC&hSsqUZ_9U63 zY?qoQ6BDd4-51HSCM&-{gO9R#y3cEHJmt2lh-;a5uC^p+8;Y}mG&&|uw^Y)l!++Tt zxM~?3G&pE+sdZ8BjJ~vS&+LE^t{;v0yvA>Wlbmnty)ib8xpb(fNgZVQX;)ebodKNT zDt@{Cw>`#!J;vSvCiIG%>5}VAnQX~q_!7Qg!t~W6!j-Iak3BY9IK58q*&nHZpb+cu#QXbru_vmdq2 zn(GPAx7Xl=d$1sD1fCdARMz!|G=*eSiyf&B6%PlD;Qy-JBiLOV8;lJWhkwOmFy?Ka zLt@Hu`fk;W8un=7-hPO?wAOxPoKhq<SOwT1K5Pw)pb0BiyTJ4~#?~BB Zbr05&Ngkcj4aIGI#>Qvo{{+Lh!nYf*$}Io@ delta 1412 zcmV-~1$+9Y44@2$=Q*!el_=&)V@)#P%B!d*TPcWAtQ;Gd)i1 z!^S9^T1BW_r7y9dInUIk?XtO48kEj&7+yCKuE6!A3xsSSREYv^7mpxGK_sa&5+Ip< z_CQ!rwD$T7w_tO15FCG+p8*u)fL_hO-9l2s#kBpO|pcy5#Rv`&V zezylqr~G;G06r#7q#Z$%scudMSAW=(gU)eytV4A7J3Z_=7?nK3#%aszVa|MLe>TpDw{|-609iGMW#ZE+O0k@!FqQ^PxRI*bW2O ziQMN9?B^20Qhii1-#O$BEnEldsQ<+!*$Rehx7-hc_lkx{W`6M)V;>x$uSBs@ z8n2s;X@57TVpp#t+|6#hN5ii=CsJu#=d|8{E^VgJ+IV4inek{dTw}KTkJcNcOM)a( zhG~_mVZi&gE48ZH(gZDvXx(rbfiP0E5{w`_z>tu9%}AB3Yn*B65MTsga0qDgafe9J zODn^$4fKvB5?KGx2*-N1rC-ZZ6*Ienxige`6(_cxJ1~Upwh)oAU$(a3rPf) zO@BLaBhk^G5LJEbyXZ=Q8wobeP0-LE(~4JL?D9BIe^xZsVAl_9Vm))y3Fw8xPeXGO z^6ffwV*wGSPrw0QqiDT3PEumi)Vd)50#aQVc1`e2X{ePTWC9kXBQ-yk-ckKtfu6`$n=9M>Xf(gK= zh9JdVS88Y9J_|@!W$bRaMK;OMG{cPTrV9(Q+;s-nf^SHb*Ul5uE|13pdy>piwsTFB zi3!%2?z3cBla-&L!AIFV-KRA;XYbuA;#%f|>JsIoz=mnm>X%k_Wk zF&6AG_691$G;O9!ZZh3uOHGEa;M?=!;k!pP%XsY`du+CFe4XC2-+3QCNlt_$nN8%8 z;EZOw5LE#6<4^<(ThycFnW;#voqs*V*aQ6VzkD8AD~%Z&r0Lloy$_#+(Tvn8_~g); zp4{)n;QNK&C#dU_;~YBlkTLA~wSM0}d8klq&-(BFZ{u#;CNu)Aq1Sl!Lz=9;p74Bo z4UVV>3$jMwiSf9wu2-lnM1|xP5<5Y|0VDXog?j|M>0(1;gT-#~7>s${=Y3Gz$m4gb zUevHh8~6HC+@-blBMV7TY{ diff --git a/public/api/qiskit-addon-mpf/objects.inv b/public/api/qiskit-addon-mpf/objects.inv index 4c171bea93d343f2c733f990ff74123a6b5436f9..ca89b6cff529af18d44ba2b997c34b5587f0ba66 100644 GIT binary patch delta 4293 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 delta 4289 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 jjTl`!v(ddKjY7FUUmS`woG diff --git a/public/images/api/qiskit-addon-mpf/qiskit_addon_mpf-backends-tenpy_layers-2.png b/public/images/api/qiskit-addon-mpf/qiskit_addon_mpf-backends-tenpy_layers-2.png index ae87629f51567ba0708e23f1b8e373e17fb42f74..25e6df98b0da7feb79e975d6d411648a2a3bc2bb 100644 GIT binary patch delta 51 zcmey;!1T3&X@Ux))kIZAMMDEU1098ol9GaAD}DXk#FB!X{F0o^B)$Bibp0ts5k(u* G_!S`woG diff --git a/public/images/api/qiskit-addon-obp/qiskit_addon_obp-utils-visualization-10.png b/public/images/api/qiskit-addon-obp/qiskit_addon_obp-utils-visualization-10.png index 2e9743e1693a8e1dcc9ca62355bd73cba938b7e3..de8b83252badd18c506d322457ab1ca5d337161b 100644 GIT binary patch delta 49 zcmeyE{V98b3ZvCTRYgTZ13d#Bg^ZGtf?_Lu{oKTof}H%4oXjM>{GxRIDMb-Q8`HW? E0k(}1`v3p{ delta 48 zcmeyA{V{uj3ZvyjRYe6$JtG~3jFOUqVk>?9+{BWCocxlU%p|@1qI7*lKjxbo)4NRp Dr-uN17#