qiskit 1.3.0rc1__cp39-abi3-win32.whl → 1.3.1__cp39-abi3-win32.whl

qiskit/VERSION.txt

@@ -1 +1 @@
-1.3.0rc1
+1.3.1

qiskit/circuit/add_control.py

@@ -13,6 +13,7 @@
 """Add control to operation if supported."""
 from __future__ import annotations
 
+from math import pi
 from qiskit.circuit.exceptions import CircuitError
 from qiskit.circuit.library import UnitaryGate
 from qiskit.transpiler import PassManager
@@ -92,7 +93,6 @@ def control(
     Raises:
         CircuitError: gate contains non-gate in definition
     """
-    from math import pi
 
     # pylint: disable=cyclic-import
     from qiskit.circuit import controlledgate
@@ -101,22 +101,23 @@ def control(
 
     q_control = QuantumRegister(num_ctrl_qubits, name="control")
     q_target = QuantumRegister(operation.num_qubits, name="target")
-    q_ancillae = None  # TODO: add
     controlled_circ = QuantumCircuit(q_control, q_target, name=f"c_{operation.name}")
     if isinstance(operation, controlledgate.ControlledGate):
         original_ctrl_state = operation.ctrl_state
+        operation = operation.to_mutable()
+        operation.ctrl_state = None
+
     global_phase = 0
-    if operation.name == "x" or (
-        isinstance(operation, controlledgate.ControlledGate) and operation.base_gate.name == "x"
-    ):
-        controlled_circ.mcx(q_control[:] + q_target[:-1], q_target[-1], q_ancillae)
-        if operation.definition is not None and operation.definition.global_phase:
-            global_phase += operation.definition.global_phase
+
+    basis = ["p", "u", "x", "z", "rx", "ry", "rz", "cx"]
+
+    if operation.name in basis:
+        apply_basic_controlled_gate(controlled_circ, operation, q_control, q_target[0])
     else:
-        basis = ["p", "u", "x", "z", "rx", "ry", "rz", "cx"]
         if isinstance(operation, controlledgate.ControlledGate):
             operation = operation.to_mutable()
             operation.ctrl_state = None
+
         unrolled_gate = _unroll_gate(operation, basis_gates=basis)
         if unrolled_gate.definition.global_phase:
             global_phase += unrolled_gate.definition.global_phase
@@ -130,87 +131,17 @@ def control(
 
         for instruction in definition.data:
             gate, qargs = instruction.operation, instruction.qubits
-            if gate.name == "x":
-                controlled_circ.mcx(q_control, q_target[bit_indices[qargs[0]]], q_ancillae)
-            elif gate.name == "rx":
-                controlled_circ.mcrx(
-                    gate.definition.data[0].operation.params[0],
-                    q_control,
-                    q_target[bit_indices[qargs[0]]],
-                    use_basis_gates=False,
-                )
-            elif gate.name == "ry":
-                controlled_circ.mcry(
-                    gate.definition.data[0].operation.params[0],
-                    q_control,
-                    q_target[bit_indices[qargs[0]]],
-                    q_ancillae,
-                    mode="noancilla",
-                    use_basis_gates=False,
-                )
-            elif gate.name == "rz":
-                controlled_circ.mcrz(
-                    gate.definition.data[0].operation.params[0],
-                    q_control,
-                    q_target[bit_indices[qargs[0]]],
-                    use_basis_gates=False,
-                )
-                continue
-            elif gate.name == "p":
-                from qiskit.circuit.library import MCPhaseGate
 
-                controlled_circ.append(
-                    MCPhaseGate(gate.params[0], num_ctrl_qubits),
-                    q_control[:] + [q_target[bit_indices[qargs[0]]]],
-                )
-            elif gate.name == "cx":
-                controlled_circ.mcx(
-                    q_control[:] + [q_target[bit_indices[qargs[0]]]],
-                    q_target[bit_indices[qargs[1]]],
-                    q_ancillae,
-                )
-            elif gate.name == "u":
-                theta, phi, lamb = gate.params
-                if num_ctrl_qubits == 1:
-                    if theta == 0 and phi == 0:
-                        controlled_circ.cp(lamb, q_control[0], q_target[bit_indices[qargs[0]]])
-                    else:
-                        controlled_circ.cu(
-                            theta, phi, lamb, 0, q_control[0], q_target[bit_indices[qargs[0]]]
-                        )
-                else:
-                    if phi == -pi / 2 and lamb == pi / 2:
-                        controlled_circ.mcrx(
-                            theta, q_control, q_target[bit_indices[qargs[0]]], use_basis_gates=True
-                        )
-                    elif phi == 0 and lamb == 0:
-                        controlled_circ.mcry(
-                            theta,
-                            q_control,
-                            q_target[bit_indices[qargs[0]]],
-                            q_ancillae,
-                            use_basis_gates=True,
-                        )
-                    elif theta == 0 and phi == 0:
-                        controlled_circ.mcp(lamb, q_control, q_target[bit_indices[qargs[0]]])
-                    else:
-                        controlled_circ.mcp(lamb, q_control, q_target[bit_indices[qargs[0]]])
-                        controlled_circ.mcry(
-                            theta,
-                            q_control,
-                            q_target[bit_indices[qargs[0]]],
-                            q_ancillae,
-                            use_basis_gates=True,
-                        )
-                        controlled_circ.mcp(phi, q_control, q_target[bit_indices[qargs[0]]])
-            elif gate.name == "z":
-                controlled_circ.h(q_target[bit_indices[qargs[0]]])
-                controlled_circ.mcx(q_control, q_target[bit_indices[qargs[0]]], q_ancillae)
-                controlled_circ.h(q_target[bit_indices[qargs[0]]])
+            if len(qargs) == 1:
+                target = q_target[bit_indices[qargs[0]]]
             else:
-                raise CircuitError(f"gate contains non-controllable instructions: {gate.name}")
-            if gate.definition is not None and gate.definition.global_phase:
+                target = [q_target[bit_indices[qarg]] for qarg in qargs]
+
+            apply_basic_controlled_gate(controlled_circ, gate, q_control, target)
+
+            if gate.definition is not None and gate.definition.global_phase and gate.name != "rz":
                 global_phase += gate.definition.global_phase
+
     # apply controlled global phase
     if global_phase:
         if len(q_control) < 2:
@@ -228,6 +159,7 @@ def control(
         new_ctrl_state = ctrl_state
         base_name = operation.name
         base_gate = operation
+
     # In order to maintain some backward compatibility with gate names this
     # uses a naming convention where if the number of controls is <=2 the gate
     # is named like "cc<base_gate.name>", else it is named like
@@ -250,15 +182,101 @@ def control(
     return cgate
 
 
+def apply_basic_controlled_gate(circuit, gate, controls, target):
+    """Apply a controlled version of ``gate`` to the circuit.
+
+    This implements multi-control operations for the following basis gates:
+
+        ["p", "u", "x", "z", "rx", "ry", "rz", "cx"]
+
+    """
+    num_ctrl_qubits = len(controls)
+
+    if gate.name == "x":
+        circuit.mcx(controls, target)
+
+    elif gate.name == "rx":
+        circuit.mcrx(
+            gate.definition.data[0].operation.params[0],
+            controls,
+            target,
+            use_basis_gates=False,
+        )
+    elif gate.name == "ry":
+        circuit.mcry(
+            gate.definition.data[0].operation.params[0],
+            controls,
+            target,
+            mode="noancilla",
+            use_basis_gates=False,
+        )
+    elif gate.name == "rz":
+        circuit.mcrz(
+            gate.definition.data[0].operation.params[0],
+            controls,
+            target,
+            use_basis_gates=False,
+        )
+        # continue
+    elif gate.name == "p":
+        from qiskit.circuit.library import MCPhaseGate
+
+        circuit.append(
+            MCPhaseGate(gate.params[0], num_ctrl_qubits),
+            controls[:] + [target],
+        )
+    elif gate.name == "cx":
+        circuit.mcx(
+            controls[:] + [target[0]],  # CX has two targets
+            target[1],
+        )
+    elif gate.name == "u":
+        theta, phi, lamb = gate.params
+        if num_ctrl_qubits == 1:
+            if theta == 0 and phi == 0:
+                circuit.cp(lamb, controls[0], target)
+            else:
+                circuit.cu(theta, phi, lamb, 0, controls[0], target)
+        else:
+            if phi == -pi / 2 and lamb == pi / 2:
+                circuit.mcrx(theta, controls, target, use_basis_gates=True)
+            elif phi == 0 and lamb == 0:
+                circuit.mcry(
+                    theta,
+                    controls,
+                    target,
+                    use_basis_gates=True,
+                )
+            elif theta == 0 and phi == 0:
+                circuit.mcp(lamb, controls, target)
+            else:
+                circuit.mcp(lamb, controls, target)
+                circuit.mcry(
+                    theta,
+                    controls,
+                    target,
+                    use_basis_gates=True,
+                )
+                circuit.mcp(phi, controls, target)
+
+    elif gate.name == "z":
+        circuit.h(target)
+        circuit.mcx(controls, target)
+        circuit.h(target)
+
+    else:
+        raise CircuitError(f"Gate {gate} not in supported basis.")
+
+
 def _gate_to_circuit(operation):
     """Converts a gate instance to a QuantumCircuit"""
     if hasattr(operation, "definition") and operation.definition is not None:
         return operation.definition
-    else:
-        qr = QuantumRegister(operation.num_qubits)
-        qc = QuantumCircuit(qr, name=operation.name)
-        qc.append(operation, qr)
-        return qc
+
+    qr = QuantumRegister(operation.num_qubits)
+    qc = QuantumCircuit(qr, name=operation.name)
+    qc.append(operation, qr)
+    return qc
 
 
 def _unroll_gate(operation, basis_gates):

qiskit/circuit/library/__init__.py

@@ -36,7 +36,7 @@ For example, to append a multi-controlled CNOT:
    circuit.append(gate, [0, 1, 4, 2, 3])
    circuit.draw('mpl')
 
-The library is organized in several sections. The function 
+The library is organized in several sections. The function
 :func:`.get_standard_gate_name_mapping` allows you to see the available standard gates and operations.
 
 .. autofunction:: get_standard_gate_name_mapping
@@ -221,10 +221,10 @@ or of a set of qubit states.
    OrGate
    XOR
    BitwiseXorGate
+   random_bitwise_xor
    InnerProduct
    InnerProductGate
 
-.. autofunction:: random_bitwise_xor
 
 Basis Change Circuits
 =====================
@@ -280,6 +280,9 @@ Adders
    CDKMRippleCarryAdder
    VBERippleCarryAdder
    WeightedAdder
+   ModularAdderGate
+   HalfAdderGate
+   FullAdderGate
 
 Multipliers
 -----------
@@ -290,6 +293,7 @@ Multipliers
 
    HRSCumulativeMultiplier
    RGQFTMultiplier
+   MultiplierGate
 
 Comparators
 -----------
@@ -321,29 +325,40 @@ Other arithmetic functions
 Particular Quantum Circuits
 ===========================
 
+The following gates and quantum circuits define specific
+quantum circuits of interest:
+
 .. autosummary::
    :toctree: ../stubs/
    :template: autosummary/class_no_inherited_members.rst
 
    FourierChecking
-   fourier_checking
    GraphState
    GraphStateGate
    HiddenLinearFunction
-   hidden_linear_function
    IQP
-   iqp
-   random_iqp
    QuantumVolume
-   quantum_volume
    PhaseEstimation
-   phase_estimation
    GroverOperator
-   grover_operator
    PhaseOracle
    PauliEvolutionGate
    HamiltonianGate
    UnitaryOverlap
+
+For circuits that have a well-defined structure it is preferrable
+to use the following functions to construct them:
+
+.. autosummary::
+   :toctree: ../stubs/
+   :template: autosummary/class_no_inherited_members.rst
+
+   fourier_checking
+   hidden_linear_function
+   iqp
+   random_iqp
+   quantum_volume
+   phase_estimation
+   grover_operator
    unitary_overlap
 
 
@@ -362,6 +377,7 @@ a broad set of variational quantum algorithms:
    real_amplitudes
    pauli_two_design
    excitation_preserving
+   qaoa_ansatz
    hamiltonian_variational_ansatz
    evolved_operator_ansatz
 
@@ -386,7 +402,7 @@ They are heavily used in near-term algorithms in e.g. Chemistry, Physics or Opti
 Data encoding circuits
 ======================
 
-The following functions return a parameterized :class:`.QuantumCircuit` to use as data 
+The following functions return a parameterized :class:`.QuantumCircuit` to use as data
 encoding circuits in a series of variational quantum algorithms:
 
 .. autosummary::
@@ -407,6 +423,17 @@ data in quantum states and are used as feature maps for classification.
    PauliFeatureMap
    ZFeatureMap
    ZZFeatureMap
+
+
+Data preparation circuits
+=========================
+
+The following operations are used for state preparation:
+
+.. autosummary::
+   :toctree: ../stubs/
+   :template: autosummary/class_no_inherited_members.rst
+
    StatePreparation
    Initialize
 

qiskit/circuit/library/arithmetic/adders/adder.py

@@ -21,7 +21,7 @@ from qiskit.utils.deprecation import deprecate_func
 class Adder(QuantumCircuit):
     r"""Compute the sum of two equally sized qubit registers.
 
-    For two registers :math:`|a\rangle_n` and :math:|b\rangle_n` with :math:`n` qubits each, an
+    For two registers :math:`|a\rangle_n` and :math:`|b\rangle_n` with :math:`n` qubits each, an
     adder performs the following operation
 
     .. math::
@@ -74,7 +74,7 @@ class Adder(QuantumCircuit):
 class HalfAdderGate(Gate):
     r"""Compute the sum of two equally-sized qubit registers, including a carry-out bit.
 
-    For two registers :math:`|a\rangle_n` and :math:|b\rangle_n` with :math:`n` qubits each, an
+    For two registers :math:`|a\rangle_n` and :math:`|b\rangle_n` with :math:`n` qubits each, an
     adder performs the following operation
 
     .. math::
@@ -116,11 +116,20 @@ class HalfAdderGate(Gate):
         """
         return self._num_state_qubits
 
+    def _define(self):
+        """Populates self.definition with some decomposition of this gate."""
+        from qiskit.synthesis.arithmetic import adder_qft_d00
+
+        # This particular decomposition does not use any ancilla qubits.
+        # Note that the transpiler may choose a different decomposition
+        # based on the number of ancilla qubits available.
+        self.definition = adder_qft_d00(self.num_state_qubits, kind="half")
+
 
 class ModularAdderGate(Gate):
     r"""Compute the sum modulo :math:`2^n` of two :math:`n`-sized qubit registers.
 
-    For two registers :math:`|a\rangle_n` and :math:|b\rangle_n` with :math:`n` qubits each, an
+    For two registers :math:`|a\rangle_n` and :math:`|b\rangle_n` with :math:`n` qubits each, an
     adder performs the following operation
 
     .. math::
@@ -162,16 +171,25 @@ class ModularAdderGate(Gate):
         """
         return self._num_state_qubits
 
+    def _define(self):
+        """Populates self.definition with some decomposition of this gate."""
+        from qiskit.synthesis.arithmetic import adder_qft_d00
+
+        # This particular decomposition does not use any ancilla qubits.
+        # Note that the transpiler may choose a different decomposition
+        # based on the number of ancilla qubits available.
+        self.definition = adder_qft_d00(self.num_state_qubits, kind="fixed")
+
 
 class FullAdderGate(Gate):
     r"""Compute the sum of two :math:`n`-sized qubit registers, including carry-in and -out bits.
 
-    For two registers :math:`|a\rangle_n` and :math:|b\rangle_n` with :math:`n` qubits each, an
+    For two registers :math:`|a\rangle_n` and :math:`|b\rangle_n` with :math:`n` qubits each, an
     adder performs the following operation
 
     .. math::
 
-        |c_{\text{in}\rangle_1 |a\rangle_n |b\rangle_n
+        |c_{\text{in}}\rangle_1 |a\rangle_n |b\rangle_n
         \mapsto |a\rangle_n |c_{\text{in}} + a + b \rangle_{n + 1}.
 
     The quantum register :math:`|a\rangle_n` (and analogously :math:`|b\rangle_n`)
@@ -208,3 +226,10 @@ class FullAdderGate(Gate):
             The number of state qubits.
         """
         return self._num_state_qubits
+
+    def _define(self):
+        """Populates self.definition with a decomposition of this gate."""
+        from qiskit.synthesis.arithmetic import adder_ripple_c04
+
+        # In the case of a full adder, this method does not use any ancilla qubits
+        self.definition = adder_ripple_c04(self.num_state_qubits, kind="full")

qiskit/circuit/library/arithmetic/adders/cdkm_ripple_carry_adder.py

@@ -84,7 +84,7 @@ class CDKMRippleCarryAdder(Adder):
         :class:`.ModularAdderGate`: A generic inplace adder, modulo :math:`2^n`. This
             is functionally equivalent to ``kind="fixed"``.
 
-        :class:`.AdderGate`: A generic inplace adder. This
+        :class:`.HalfAdderGate`: A generic inplace adder. This
             is functionally equivalent to ``kind="half"``.
 
         :class:`.FullAdderGate`: A generic inplace adder, with a carry-in bit. This

qiskit/circuit/library/arithmetic/adders/draper_qft_adder.py

@@ -54,7 +54,7 @@ class DraperQFTAdder(Adder):
         :class:`.ModularAdderGate`: A generic inplace adder, modulo :math:`2^n`. This
             is functionally equivalent to ``kind="fixed"``.
 
-        :class:`.AdderGate`: A generic inplace adder. This
+        :class:`.HalfAdderGate`: A generic inplace adder. This
             is functionally equivalent to ``kind="half"``.
 
     **References:**

qiskit/circuit/library/arithmetic/adders/vbe_ripple_carry_adder.py

@@ -60,7 +60,7 @@ class VBERippleCarryAdder(Adder):
         :class:`.ModularAdderGate`: A generic inplace adder, modulo :math:`2^n`. This
             is functionally equivalent to ``kind="fixed"``.
 
-        :class:`.AdderGate`: A generic inplace adder. This
+        :class:`.HalfAdderGate`: A generic inplace adder. This
             is functionally equivalent to ``kind="half"``.
 
         :class:`.FullAdderGate`: A generic inplace adder, with a carry-in bit. This

qiskit/circuit/library/arithmetic/multipliers/multiplier.py

@@ -190,3 +190,12 @@ class MultiplierGate(Gate):
             The number of result qubits.
         """
         return self._num_result_qubits
+
+    def _define(self):
+        """Populates self.definition with some decomposition of this gate."""
+        from qiskit.synthesis.arithmetic import multiplier_qft_r17
+
+        # This particular decomposition does not use any ancilla qubits.
+        # Note that the transpiler may choose a different decomposition
+        # based on the number of ancilla qubits available.
+        self.definition = multiplier_qft_r17(self.num_state_qubits)

qiskit/primitives/utils.py

@@ -82,7 +82,7 @@ def init_observable(observable: BaseOperator | str) -> SparsePauliOp:
     since="1.2",
     additional_msg="Use ``QuantumCircuit.layout`` and ``SparsePauliOp.apply_layout`` "
     + "to adjust an operator for a layout. Otherwise, use ``mthree.utils.final_measurement_mapping``. "
-    + "See https://qiskit-extensions.github.io/mthree/apidocs/utils.html for details.",
+    + "See <https://qiskit.github.io/qiskit-addon-mthree/apidocs/utils> for details.",
 )
 def final_measurement_mapping(circuit: QuantumCircuit) -> dict[int, int]:
     """Return the final measurement mapping for the circuit.

qiskit/providers/__init__.py

@@ -160,7 +160,7 @@ steps for writing a provider are:
    interacting with a running job.
 
 For a simple example of a provider, see the
-`qiskit-aqt-provider <https://github.com/Qiskit-Partners/qiskit-aqt-provider>`__
+`qiskit-aqt-provider <https://github.com/qiskit-community/qiskit-aqt-provider>`__
 
 Provider
 --------
@@ -664,7 +664,7 @@ that abstract away the mechanics of getting the best result efficiently, to
 concentrate on higher level applications using these outputs.
 
 For example, if your backends were well suited to leverage
-`mthree <https://github.com/Qiskit-Partners/mthree/>`__ measurement
+`mthree <https://github.com/Qiskit/qiskit-addon-mthree>`__ measurement
 mitigation to improve the quality of the results, you could implement a
 provider-specific :class:`~.Sampler` implementation that leverages the
 ``M3Mitigation`` class internally to run the circuits and return

qiskit/qpy/__init__.py

@@ -447,10 +447,10 @@ characters:
    * - ``u``
      - substitution
 
-If the type value is ``f`` ,``c`` or ``i``, the corresponding ``lhs`` or `rhs``
+If the type value is ``f``, ``c``, or ``i``, the corresponding ``lhs`` or ``rhs``
 field widths are 128 bits each. In the case of floats, the literal value is encoded as a double
 with 0 padding, while complex numbers are encoded as real part followed by imaginary part,
-taking up 64 bits each. For ``i`, the value is encoded as a 64 bit signed integer with 0 padding
+taking up 64 bits each. For ``i``, the value is encoded as a 64 bit signed integer with 0 padding
 for the full 128 bit width. ``n`` is used to represent a ``None`` and typically isn't directly used
 as it indicates an argument that's not used. For ``p`` the data is the UUID for the
 :class:`.Parameter` which can be looked up in the symbol map described in the
@@ -546,7 +546,7 @@ Type code  Meaning
 Changes to EXPR_VAR
 ~~~~~~~~~~~~~~~~~~~
 
-The EXPR_VAR variable has gained a new type code and payload, in addition to the pre-existing ones:
+The ``EXPR_VAR`` variable has gained a new type code and payload, in addition to the pre-existing ones:
 
 ===========================  =========  ============================================================
 Python class                 Type code  Payload
@@ -693,9 +693,9 @@ Each of these are described in the following table:
 ======================  =========  =======================================================  ========
 Qiskit class            Type code  Payload                                                  Children
 ======================  =========  =======================================================  ========
-:class:`~.expr.Var`     ``x``      One EXPR_VAR.                                            0
+:class:`~.expr.Var`     ``x``      One ``EXPR_VAR``.                                        0
 
-:class:`~.expr.Value`   ``v``      One EXPR_VALUE.                                          0
+:class:`~.expr.Value`   ``v``      One ``EXPR_VALUE``.                                      0
 
 :class:`~.expr.Cast`    ``c``      One ``_Bool``  that corresponds to the value of          1
                                    ``implicit``.

qiskit/quantum_info/operators/channel/chi.py

@@ -18,6 +18,8 @@ Chi-matrix representation of a Quantum Channel.
 from __future__ import annotations
 import copy as _copy
 import math
+from typing import TYPE_CHECKING
+
 import numpy as np
 
 from qiskit import _numpy_compat
@@ -31,6 +33,9 @@ from qiskit.quantum_info.operators.channel.transformations import _to_chi
 from qiskit.quantum_info.operators.mixins import generate_apidocs
 from qiskit.quantum_info.operators.base_operator import BaseOperator
 
+if TYPE_CHECKING:
+    from qiskit import circuit
+
 
 class Chi(QuantumChannel):
     r"""Pauli basis Chi-matrix representation of a quantum channel.
@@ -59,21 +64,16 @@ class Chi(QuantumChannel):
 
     def __init__(
         self,
-        data: QuantumCircuit | Instruction | BaseOperator | np.ndarray,
+        data: QuantumCircuit | circuit.instruction.Instruction | BaseOperator | np.ndarray,
         input_dims: int | tuple | None = None,
         output_dims: int | tuple | None = None,
     ):
         """Initialize a quantum channel Chi-matrix operator.
 
         Args:
-            data (QuantumCircuit or
-                  Instruction or
-                  BaseOperator or
-                  matrix): data to initialize superoperator.
-            input_dims (tuple): the input subsystem dimensions.
-                                [Default: None]
-            output_dims (tuple): the output subsystem dimensions.
-                                 [Default: None]
+            data: data to initialize superoperator.
+            input_dims: the input subsystem dimensions.
+            output_dims: the output subsystem dimensions.
 
         Raises:
             QiskitError: if input data is not an N-qubit channel or

qiskit/quantum_info/operators/channel/choi.py

@@ -18,6 +18,8 @@ Choi-matrix representation of a Quantum Channel.
 from __future__ import annotations
 import copy as _copy
 import math
+from typing import TYPE_CHECKING
+
 import numpy as np
 
 from qiskit import _numpy_compat
@@ -32,6 +34,9 @@ from qiskit.quantum_info.operators.channel.transformations import _bipartite_ten
 from qiskit.quantum_info.operators.mixins import generate_apidocs
 from qiskit.quantum_info.operators.base_operator import BaseOperator
 
+if TYPE_CHECKING:
+    from qiskit import circuit
+
 
 class Choi(QuantumChannel):
     r"""Choi-matrix representation of a Quantum Channel.
@@ -64,21 +69,16 @@ class Choi(QuantumChannel):
 
     def __init__(
         self,
-        data: QuantumCircuit | Instruction | BaseOperator | np.ndarray,
+        data: QuantumCircuit | circuit.instruction.Instruction | BaseOperator | np.ndarray,
         input_dims: int | tuple | None = None,
         output_dims: int | tuple | None = None,
     ):
         """Initialize a quantum channel Choi matrix operator.
 
         Args:
-            data (QuantumCircuit or
-                  Instruction or
-                  BaseOperator or
-                  matrix): data to initialize superoperator.
-            input_dims (tuple): the input subsystem dimensions.
-                                [Default: None]
-            output_dims (tuple): the output subsystem dimensions.
-                                 [Default: None]
+            data: data to initialize superoperator.
+            input_dims: the input subsystem dimensions.
+            output_dims: the output subsystem dimensions.
 
         Raises:
             QiskitError: if input data cannot be initialized as a