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

qiskit/VERSION.txt

@@ -1 +1 @@
-1.3.0rc2
+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/arithmetic/adders/adder.py

@@ -116,6 +116,15 @@ 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.
@@ -162,6 +171,15 @@ 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.
@@ -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/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

qiskit/quantum_info/operators/channel/ptm.py

@@ -18,6 +18,8 @@ Pauli Transfer Matrix (PTM) 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
@@ -30,6 +32,9 @@ from qiskit.quantum_info.operators.channel.transformations import _to_ptm
 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 PTM(QuantumChannel):
     r"""Pauli Transfer Matrix (PTM) representation of a Quantum Channel.
@@ -67,21 +72,16 @@ class PTM(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 PTM quantum channel 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/quantum_channel.py

@@ -53,9 +53,9 @@ class QuantumChannel(LinearOp):
         """Initialize a quantum channel Superoperator operator.
 
         Args:
-            data (array or list): quantum channel data array.
-            op_shape (OpShape): the operator shape of the channel.
-            num_qubits (int): the number of qubits if the channel is N-qubit.
+            data: quantum channel data array.
+            op_shape: the operator shape of the channel.
+            num_qubits: the number of qubits if the channel is N-qubit.
 
         Raises:
             QiskitError: if arguments are invalid.

qiskit/quantum_info/operators/channel/stinespring.py

@@ -17,6 +17,8 @@ from __future__ import annotations
 import copy
 import math
 from numbers import Number
+from typing import TYPE_CHECKING
+
 import numpy as np
 
 from qiskit.circuit.quantumcircuit import QuantumCircuit
@@ -32,6 +34,9 @@ from qiskit.quantum_info.operators.channel.transformations import _to_stinesprin
 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 Stinespring(QuantumChannel):
     r"""Stinespring representation of a quantum channel.
@@ -64,21 +69,16 @@ class Stinespring(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 Stinespring 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

qiskit/quantum_info/operators/channel/superop.py

@@ -33,6 +33,7 @@ from qiskit.quantum_info.operators.op_shape import OpShape
 from qiskit.quantum_info.operators.operator import Operator
 
 if TYPE_CHECKING:
+    from qiskit import circuit
     from qiskit.quantum_info.states.densitymatrix import DensityMatrix
     from qiskit.quantum_info.states.statevector import Statevector
 
@@ -62,21 +63,16 @@ class SuperOp(QuantumChannel):
 
     def __init__(
         self,
-        data: QuantumCircuit | Instruction | BaseOperator | np.ndarray,
+        data: QuantumCircuit | circuit.instruction.Instruction | BaseOperator | np.ndarray,
         input_dims: tuple | None = None,
         output_dims: tuple | None = None,
     ):
         """Initialize a quantum channel Superoperator 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