qiskit 2.0.3__cp39-abi3-macosx_11_0_arm64.whl → 2.1.0__cp39-abi3-macosx_11_0_arm64.whl

qiskit/qpy/binary_io/schedules.py

@@ -18,12 +18,10 @@ The purpose of the `_read` and `_load` methods below is just to advance
 the file handle while consuming pulse data."""
 import json
 import struct
-import zlib
 
 from io import BytesIO
 
 import numpy as np
-import symengine as sym
 
 from qiskit.exceptions import QiskitError
 from qiskit.qpy import formats, common, type_keys
@@ -87,20 +85,6 @@ def _read_discriminator(file_obj, version) -> None:
     value.read_value(file_obj, version, {})  # read name
 
 
-def _loads_symbolic_expr(expr_bytes, use_symengine=False):
-    if expr_bytes == b"":
-        return None
-    expr_bytes = zlib.decompress(expr_bytes)
-    if use_symengine:
-        return common.load_symengine_payload(expr_bytes)
-    else:
-        from sympy import parse_expr
-
-        expr_txt = expr_bytes.decode(common.ENCODE)
-        expr = parse_expr(expr_txt)
-        return sym.sympify(expr)
-
-
 def _read_symbolic_pulse(file_obj, version) -> None:
     make = formats.SYMBOLIC_PULSE._make
     pack = formats.SYMBOLIC_PULSE_PACK
@@ -113,11 +97,9 @@ def _read_symbolic_pulse(file_obj, version) -> None:
         )
     )
     pulse_type = file_obj.read(header.type_size).decode(common.ENCODE)
-    _loads_symbolic_expr(file_obj.read(header.envelope_size))  # read envelope
-    _loads_symbolic_expr(file_obj.read(header.constraints_size))  # read constraints
-    _loads_symbolic_expr(
-        file_obj.read(header.valid_amp_conditions_size)
-    )  # read valid amp conditions
+    file_obj.read(header.envelope_size)  # read envelope
+    file_obj.read(header.constraints_size)  # read constraints
+    file_obj.read(header.valid_amp_conditions_size)  # read valid amp conditions
     # read parameters
     common.read_mapping(
         file_obj,
@@ -146,7 +128,7 @@ def _read_symbolic_pulse(file_obj, version) -> None:
         raise NotImplementedError(f"Unknown class '{class_name}'")
 
 
-def _read_symbolic_pulse_v6(file_obj, version, use_symengine) -> None:
+def _read_symbolic_pulse_v6(file_obj, version) -> None:
     make = formats.SYMBOLIC_PULSE_V2._make
     pack = formats.SYMBOLIC_PULSE_PACK_V2
     size = formats.SYMBOLIC_PULSE_SIZE_V2
@@ -159,11 +141,9 @@ def _read_symbolic_pulse_v6(file_obj, version, use_symengine) -> None:
     )
     class_name = file_obj.read(header.class_name_size).decode(common.ENCODE)
     file_obj.read(header.type_size).decode(common.ENCODE)  # read pulse type
-    _loads_symbolic_expr(file_obj.read(header.envelope_size), use_symengine)  # read envelope
-    _loads_symbolic_expr(file_obj.read(header.constraints_size), use_symengine)  # read constraints
-    _loads_symbolic_expr(
-        file_obj.read(header.valid_amp_conditions_size), use_symengine
-    )  # read valid_amp_conditions
+    file_obj.read(header.envelope_size)  # read envelope
+    file_obj.read(header.constraints_size)  # read constraints
+    file_obj.read(header.valid_amp_conditions_size)  # read valid_amp_conditions
     # read parameters
     common.read_mapping(
         file_obj,
@@ -191,16 +171,14 @@ def _read_alignment_context(file_obj, version) -> None:
 
 
 # pylint: disable=too-many-return-statements
-def _loads_operand(type_key, data_bytes, version, use_symengine):
+def _loads_operand(type_key, data_bytes, version):
     if type_key == type_keys.ScheduleOperand.WAVEFORM:
         return common.data_from_binary(data_bytes, _read_waveform, version=version)
     if type_key == type_keys.ScheduleOperand.SYMBOLIC_PULSE:
         if version < 6:
             return common.data_from_binary(data_bytes, _read_symbolic_pulse, version=version)
         else:
-            return common.data_from_binary(
-                data_bytes, _read_symbolic_pulse_v6, version=version, use_symengine=use_symengine
-            )
+            return common.data_from_binary(data_bytes, _read_symbolic_pulse_v6, version=version)
     if type_key == type_keys.ScheduleOperand.CHANNEL:
         return common.data_from_binary(data_bytes, _read_channel, version=version)
     if type_key == type_keys.ScheduleOperand.OPERAND_STR:
@@ -229,7 +207,9 @@ def _read_element(file_obj, version, metadata_deserializer, use_symengine) -> No
 
     # read operands
     common.read_sequence(
-        file_obj, deserializer=_loads_operand, version=version, use_symengine=use_symengine
+        file_obj,
+        deserializer=_loads_operand,
+        version=version,
     )
     # read name
     value.read_value(file_obj, version, {})

qiskit/qpy/binary_io/value.py

@@ -20,8 +20,6 @@ import struct
 import uuid
 
 import numpy as np
-import symengine
-
 
 from qiskit.circuit import CASE_DEFAULT, Clbit, ClassicalRegister, Duration
 from qiskit.circuit.classical import expr, types
@@ -124,7 +122,10 @@ def _encode_replay_entry(inst, file_obj, version, r_side=False):
 
 def _encode_replay_subs(subs, file_obj, version):
     with io.BytesIO() as mapping_buf:
-        subs_dict = {k.name: v for k, v in subs.binds.items()}
+        if version < 15:
+            subs_dict = {k.name: v for k, v in subs.binds.items()}
+        else:
+            subs_dict = {k.uuid.bytes: v for k, v in subs.binds.items()}
         common.write_mapping(
             mapping_buf, mapping=subs_dict, serializer=dumps_value, version=version
         )
@@ -459,14 +460,21 @@ def _read_parameter_vec(file_obj, vectors):
             file_obj.read(formats.PARAMETER_VECTOR_ELEMENT_SIZE),
         ),
     )
-    param_uuid = uuid.UUID(bytes=data.uuid)
+    # Starting in version 15, the parameter vector root uuid
+    # is used as a key instead of the parameter name.
+    root_uuid_int = uuid.UUID(bytes=data.uuid).int - data.index
+    root_uuid = uuid.UUID(int=root_uuid_int)
     name = file_obj.read(data.vector_name_size).decode(common.ENCODE)
-    if name not in vectors:
-        vectors[name] = (ParameterVector(name, data.vector_size), set())
-    vector = vectors[name][0]
-    if vector[data.index].uuid != param_uuid:
-        vectors[name][1].add(data.index)
-        vector._params[data.index] = ParameterVectorElement(vector, data.index, uuid=param_uuid)
+
+    if root_uuid not in vectors:
+        vectors[root_uuid] = (ParameterVector(name, data.vector_size), set())
+    vector = vectors[root_uuid][0]
+
+    if vector[data.index].uuid != root_uuid:
+        vectors[root_uuid][1].add(data.index)
+        vector._params[data.index] = ParameterVectorElement(
+            vector, data.index, uuid=uuid.UUID(int=root_uuid_int + data.index)
+        )
     return vector[data.index]
 
 
@@ -476,7 +484,7 @@ def _read_parameter_expression(file_obj):
     )
 
     sympy_str = file_obj.read(data.expr_size).decode(common.ENCODE)
-    expr_ = symengine.sympify(parse_sympy_repr(sympy_str))
+    expr_ = parse_sympy_repr(sympy_str)
     symbol_map = {}
     for _ in range(data.map_elements):
         elem_data = formats.PARAM_EXPR_MAP_ELEM(
@@ -503,7 +511,7 @@ def _read_parameter_expression(file_obj):
             raise exceptions.QpyError(f"Invalid parameter expression map type: {elem_key}")
         symbol_map[symbol] = value
 
-    return ParameterExpression(symbol_map, expr_)
+    return ParameterExpression(symbol_map, str(expr_))
 
 
 def _read_parameter_expression_v3(file_obj, vectors, use_symengine):
@@ -516,7 +524,7 @@ def _read_parameter_expression_v3(file_obj, vectors, use_symengine):
         expr_ = common.load_symengine_payload(payload)
     else:
         sympy_str = payload.decode(common.ENCODE)
-        expr_ = symengine.sympify(parse_sympy_repr(sympy_str))
+        expr_ = parse_sympy_repr(sympy_str)
 
     symbol_map = {}
     for _ in range(data.map_elements):
@@ -556,7 +564,7 @@ def _read_parameter_expression_v3(file_obj, vectors, use_symengine):
             raise exceptions.QpyError(f"Invalid parameter expression map type: {elem_key}")
         symbol_map[symbol] = value
 
-    return ParameterExpression(symbol_map, expr_)
+    return ParameterExpression(symbol_map, str(expr_))
 
 
 def _read_parameter_expression_v13(file_obj, vectors, version):
@@ -641,9 +649,16 @@ def _read_parameter_expr_v13(buf, symbol_map, version, vectors):
             subs_map_data = buf.read(size)
             with io.BytesIO(subs_map_data) as mapping_buf:
                 mapping = common.read_mapping(
-                    mapping_buf, deserializer=loads_value, version=version, vectors=vectors
+                    mapping_buf,
+                    deserializer=loads_value,
+                    version=version,
+                    vectors=vectors,
                 )
-            stack.append({name_map[k]: v for k, v in mapping.items()})
+            # Starting in version 15, the uuid is used instead of the name
+            if version < 15:
+                stack.append({name_map[k]: v for k, v in mapping.items()})
+            else:
+                stack.append({param_uuid_map[k]: v for k, v in mapping.items()})
         else:
             raise exceptions.QpyError(
                 "Unknown ParameterExpression operation type {expression_data.LHS_TYPE}"
@@ -1067,7 +1082,6 @@ def loads_value(
             before setting this option, as it will be required by qpy to deserialize the payload.
         standalone_vars (Sequence[Var]): standalone :class:`.expr.Var` nodes in the order that they
             were declared by the circuit header.
-
     Returns:
         any: Deserialized value object.
 
@@ -1094,7 +1108,11 @@ def loads_value(
     if type_key == type_keys.Value.CASE_DEFAULT:
         return CASE_DEFAULT
     if type_key == type_keys.Value.PARAMETER_VECTOR:
-        return common.data_from_binary(binary_data, _read_parameter_vec, vectors=vectors)
+        return common.data_from_binary(
+            binary_data,
+            _read_parameter_vec,
+            vectors=vectors,
+        )
     if type_key == type_keys.Value.PARAMETER:
         return common.data_from_binary(binary_data, _read_parameter)
     if type_key == type_keys.Value.PARAMETER_EXPRESSION:

qiskit/qpy/common.py

@@ -17,12 +17,13 @@ Common functions across several serialization and deserialization modules.
 
 import io
 import struct
+import uuid
 
 from qiskit.utils.optionals import HAS_SYMENGINE
 
 from qiskit.qpy import formats, exceptions
 
-QPY_VERSION = 14
+QPY_VERSION = 15
 QPY_COMPATIBILITY_VERSION = 13
 ENCODE = "utf8"
 
@@ -95,7 +96,11 @@ def read_mapping(file_obj, deserializer, **kwargs):
         map_header = formats.MAP_ITEM._make(
             struct.unpack(formats.MAP_ITEM_PACK, file_obj.read(formats.MAP_ITEM_SIZE))
         )
-        key = file_obj.read(map_header.key_size).decode(ENCODE)
+        if kwargs.get("version", 15) < 15:
+            key = file_obj.read(map_header.key_size).decode(ENCODE)
+        else:
+            key = uuid.UUID(bytes=file_obj.read(map_header.key_size))
+
         datum = deserializer(map_header.type, file_obj.read(map_header.size), **kwargs)
         mapping[key] = datum
 
@@ -167,7 +172,10 @@ def write_mapping(file_obj, mapping, serializer, **kwargs):
 
     file_obj.write(struct.pack(formats.SEQUENCE_PACK, num_elements))
     for key, datum in mapping.items():
-        key_bytes = key.encode(ENCODE)
+        if kwargs.get("version", 15) < 15:
+            key_bytes = key.encode(ENCODE)
+        else:
+            key_bytes = key
         type_key, datum_bytes = serializer(datum, **kwargs)
         item_header = struct.pack(formats.MAP_ITEM_PACK, len(key_bytes), type_key, len(datum_bytes))
         file_obj.write(item_header)

qiskit/qpy/formats.py

@@ -128,7 +128,7 @@ CIRCUIT_INSTRUCTION_V2 = namedtuple(
         "num_parameters",
         "num_qargs",
         "num_cargs",
-        "conditional_key",
+        "extras_key",
         "condition_register_size",
         "condition_value",
         "num_ctrl_qubits",
@@ -144,6 +144,22 @@ CIRCUIT_INSTRUCTION_ARG = namedtuple("CIRCUIT_INSTRUCTION_ARG", ["type", "size"]
 CIRCUIT_INSTRUCTION_ARG_PACK = "!1cI"
 CIRCUIT_INSTRUCTION_ARG_SIZE = struct.calcsize(CIRCUIT_INSTRUCTION_ARG_PACK)
 
+ANNOTATION_HEADER_STATIC = namedtuple("ANNOTATION_HEADER_STATIC", ["num_namespaces"])
+ANNOTATION_HEADER_STATIC_PACK = "!I"
+ANNOTATION_HEADER_STATIC_SIZE = struct.calcsize(ANNOTATION_HEADER_STATIC_PACK)
+
+ANNOTATION_STATE_HEADER = namedtuple("ANNOTATION_STATE_HEADER", ["namespace_size", "state_size"])
+ANNOTATION_STATE_HEADER_PACK = "!IQ"
+ANNOTATION_STATE_HEADER_SIZE = struct.calcsize(ANNOTATION_STATE_HEADER_PACK)
+
+INSTRUCTION_ANNOTATIONS_HEADER = namedtuple("INSTRUCTION_ANNOTATIONS_HEADER", ["num_annotations"])
+INSTRUCTION_ANNOTATIONS_HEADER_PACK = "!I"
+INSTRUCTION_ANNOTATIONS_HEADER_SIZE = struct.calcsize(INSTRUCTION_ANNOTATIONS_HEADER_PACK)
+
+INSTRUCTION_ANNOTATION = namedtuple("INSTRUCTION_ANNOTATION", ["namespace_index", "payload_size"])
+INSTRUCTION_ANNOTATION_PACK = "!IQ"
+INSTRUCTION_ANNOTATION_SIZE = struct.calcsize(INSTRUCTION_ANNOTATION_PACK)
+
 # SparsePauliOp List
 SPARSE_PAULI_OP_LIST_ELEM = namedtuple("SPARSE_PAULI_OP_LIST_ELEMENT", ["size"])
 SPARSE_PAULI_OP_LIST_ELEM_PACK = "!Q"

qiskit/qpy/interface.py

@@ -15,8 +15,8 @@
 from __future__ import annotations
 
 from json import JSONEncoder, JSONDecoder
-from typing import Union, List, BinaryIO, Type, Optional
-from collections.abc import Iterable
+from typing import Union, List, BinaryIO, Type, Optional, Callable, TYPE_CHECKING
+from collections.abc import Iterable, Mapping
 import struct
 import warnings
 import re
@@ -27,6 +27,9 @@ from qiskit.qpy import formats, common, binary_io, type_keys
 from qiskit.qpy.exceptions import QpyError
 from qiskit.version import __version__
 
+if TYPE_CHECKING:
+    from qiskit.circuit import annotation
+
 
 # pylint: disable=invalid-name
 QPY_SUPPORTED_TYPES = QuantumCircuit
@@ -78,6 +81,7 @@ def dump(
     metadata_serializer: Optional[Type[JSONEncoder]] = None,
     use_symengine: bool = False,
     version: int = common.QPY_VERSION,
+    annotation_factories: Optional[Mapping[str, Callable[[], annotation.QPYSerializer]]] = None,
 ):
     """Write QPY binary data to a file
 
@@ -152,6 +156,11 @@ def dump(
                 QPY files containing ``symengine``-serialized :class:`.ParameterExpression` objects
                 unless the version of ``symengine`` used between the loading and generating
                 environments matches.
+        annotation_factories: Mapping of namespaces to functions that create new instances of
+            :class:`.annotation.QPUSerializer`, for handling the dumping of custom
+            :class:`.Annotation` objects.  The subsequent call to :func:`load` will need to use
+            similar serializer objects, that understand the custom output format of those
+            serializers.
 
 
     Raises:
@@ -166,9 +175,6 @@ def dump(
         if not issubclass(type(program), QuantumCircuit):
             raise TypeError(f"'{type(program)}' is not a supported data type.")
 
-    type_key = type_keys.Program.CIRCUIT
-    writer = binary_io.write_circuit
-
     if version is None:
         version = common.QPY_VERSION
     elif common.QPY_COMPATIBILITY_VERSION > version or version > common.QPY_VERSION:
@@ -192,21 +198,23 @@ def dump(
         encoding,
     )
     file_obj.write(header)
-    common.write_type_key(file_obj, type_key)
+    common.write_type_key(file_obj, type_keys.Program.CIRCUIT)
 
     for program in programs:
-        writer(
+        binary_io.write_circuit(
             file_obj,
             program,
             metadata_serializer=metadata_serializer,
             use_symengine=use_symengine,
             version=version,
+            annotation_factories=annotation_factories,
         )
 
 
 def load(
     file_obj: BinaryIO,
     metadata_deserializer: Optional[Type[JSONDecoder]] = None,
+    annotation_factories: Optional[Mapping[str, Callable[[], annotation.QPYSerializer]]] = None,
 ) -> List[QPY_SUPPORTED_TYPES]:
     """Load a QPY binary file
 
@@ -244,6 +252,9 @@ def load(
             If this is not specified the circuit metadata will
             be parsed as JSON with the stdlib ``json.load()`` function using
             the default ``JSONDecoder`` class.
+        annotation_factories: Mapping of namespaces to functions that create new instances of
+            :class:`.annotation.QPUSerializer`, for handling the loading of custom
+            :class:`.Annotation` objects.
 
     Returns:
         The list of Qiskit programs contained in the QPY data.
@@ -316,14 +327,12 @@ def load(
     else:
         type_key = common.read_type_key(file_obj)
 
-    if type_key == type_keys.Program.CIRCUIT:
-        loader = binary_io.read_circuit
-    elif type_key == type_keys.Program.SCHEDULE_BLOCK:
+    if type_key == type_keys.Program.SCHEDULE_BLOCK:
         raise QpyError(
             "Payloads of type `ScheduleBlock` cannot be loaded as of Qiskit 2.0. "
             "Use an earlier version of Qiskit if you want to load `ScheduleBlock` payloads."
         )
-    else:
+    if type_key != type_keys.Program.CIRCUIT:
         raise TypeError(f"Invalid payload format data kind '{type_key}'.")
 
     if data.qpy_version < 10:
@@ -334,11 +343,42 @@ def load(
     programs = []
     for _ in range(data.num_programs):
         programs.append(
-            loader(
+            binary_io.read_circuit(
                 file_obj,
                 data.qpy_version,
                 metadata_deserializer=metadata_deserializer,
                 use_symengine=use_symengine,
+                annotation_factories=annotation_factories,
             )
         )
     return programs
+
+
+def get_qpy_version(
+    file_obj: BinaryIO,
+) -> int:
+    """This function identifies the QPY version of the file.
+
+    This function will read the header of ``file_obj`` and will
+    return the QPY format version. It will **not** advance the
+    cursor of ``file_obj``. If you are using this for a subsequent
+    read, such as to call :func:`.load`, you can pass ``file_obj``
+    directly. For example::
+
+        from qiskit import qpy
+
+        qpy_version = qpy.get_qpy_version(qpy_file)
+        if qpy_version > 12:
+            qpy.load(qpy_file)
+
+    Args:
+        file_obj: A file like object that contains the QPY binary
+            data for a circuit.
+
+    Returns:
+        The QPY version of the specified file.
+    """
+
+    version = struct.unpack("!6sB", file_obj.read(7))[1]
+    file_obj.seek(-7, 1)
+    return version

qiskit/qpy/type_keys.py

@@ -18,7 +18,7 @@ QPY Type keys for several namespace.
 
 import uuid
 from abc import abstractmethod
-from enum import Enum, IntEnum
+from enum import Enum, IntEnum, IntFlag
 
 import numpy as np
 
@@ -138,6 +138,12 @@ class Condition(IntEnum):
     EXPRESSION = 2
 
 
+class InstructionExtraFlags(IntFlag):
+    """If an instruction has extra payloads associated with it."""
+
+    HAS_ANNOTATIONS = 0b1000_0000
+
+
 class Container(TypeKeyBase):
     """Type key enum for container-like object."""
 

qiskit/quantum_info/__init__.py

@@ -30,9 +30,13 @@ Operators
    ScalarOp
    SparseObservable
    SparsePauliOp
+   PauliLindbladMap
+   QubitSparsePauli
+   QubitSparsePauliList
    CNOTDihedral
    PauliList
    pauli_basis
+   get_clifford_gate_names
 
 .. _quantum_info_states:
 
@@ -115,6 +119,11 @@ Analysis
 
 from __future__ import annotations
 
+from qiskit._accelerate.pauli_lindblad_map import (
+    QubitSparsePauliList,
+    QubitSparsePauli,
+    PauliLindbladMap,
+)
 from qiskit._accelerate.sparse_observable import SparseObservable
 
 from .analysis import hellinger_distance, hellinger_fidelity, Z2Symmetries
@@ -129,6 +138,7 @@ from .operators import (
     commutator,
     double_commutator,
     pauli_basis,
+    get_clifford_gate_names,
 )
 from .operators.channel import PTM, Chi, Choi, Kraus, Stinespring, SuperOp
 from .operators.dihedral import CNOTDihedral

qiskit/quantum_info/operators/__init__.py

@@ -24,5 +24,6 @@ from .symplectic import (
     PauliList,
     SparsePauliOp,
     pauli_basis,
+    get_clifford_gate_names,
 )
 from .utils import anti_commutator, commutator, double_commutator

qiskit/quantum_info/operators/symplectic/__init__.py

@@ -17,6 +17,7 @@ Symplectic Operators
 from __future__ import annotations
 
 from .clifford import Clifford
+from .clifford_circuits import get_clifford_gate_names
 from .pauli import Pauli
 from .pauli_list import PauliList
 from .pauli_utils import pauli_basis

qiskit/quantum_info/operators/symplectic/clifford_circuits.py

@@ -554,5 +554,31 @@ _BASIS_2Q = {
     "ecr": _append_ecr,
     "dcx": _append_dcx,
 }
+
+# Clifford gate names
+_CLIFFORD_GATE_NAMES = [
+    "id",
+    "x",
+    "y",
+    "z",
+    "h",
+    "s",
+    "sdg",
+    "sx",
+    "sxdg",
+    "cx",
+    "cz",
+    "cy",
+    "swap",
+    "iswap",
+    "ecr",
+    "dcx",
+]
+
 # Non-clifford gates
 _NON_CLIFFORD = {"t", "tdg", "ccx", "ccz"}
+
+
+def get_clifford_gate_names() -> list:
+    """Returns the list of Clifford gate names."""
+    return _CLIFFORD_GATE_NAMES

qiskit/quantum_info/operators/symplectic/pauli.py

@@ -708,7 +708,7 @@ class Pauli(BasePauli):
     def apply_layout(
         self, layout: TranspileLayout | list[int] | None, num_qubits: int | None = None
     ) -> Pauli:
-        """Apply a transpiler layout to this :class:`~.Pauli`
+        """Apply a transpiler layout to this :class:`~.quantum_info.Pauli`
 
         Args:
             layout: Either a :class:`~.TranspileLayout`, a list of integers or None.
@@ -722,7 +722,7 @@ class Pauli(BasePauli):
                 None, the operator will be expanded to the given number of qubits.
 
         Returns:
-            A new :class:`.Pauli` with the provided layout applied
+            A new :class:`~.quantum_info.Pauli` with the provided layout applied
         """
         from qiskit.transpiler.layout import TranspileLayout
 

qiskit/result/sampled_expval.py

@@ -23,6 +23,7 @@ from .distributions import QuasiDistribution, ProbDistribution
 OPERS = {"Z", "I", "0", "1"}
 
 
+# pylint: disable=missing-param-doc,missing-type-doc
 def sampled_expectation_value(dist, oper):
     """Computes expectation value from a sampled distribution
 
@@ -30,7 +31,8 @@ def sampled_expectation_value(dist, oper):
 
     Parameters:
         dist (Counts or QuasiDistribution or ProbDistribution or dict): Input sampled distribution
-        oper (str or Pauli or SparsePauliOp): The operator for the observable
+        oper (str or :class:`~.quantum_info.Pauli` or SparsePauliOp): The operator for the
+            observable
 
     Returns:
         float: The expectation value

qiskit/synthesis/__init__.py

@@ -127,6 +127,10 @@ Multi Controlled Synthesis
 ==========================
 
 .. autofunction:: synth_mcmt_vchain
+.. autofunction:: synth_mcx_1_clean_kg24
+.. autofunction:: synth_mcx_1_dirty_kg24
+.. autofunction:: synth_mcx_2_clean_kg24
+.. autofunction:: synth_mcx_2_dirty_kg24
 .. autofunction:: synth_mcx_n_dirty_i15
 .. autofunction:: synth_mcx_n_clean_m15
 .. autofunction:: synth_mcx_1_clean_b95
@@ -144,6 +148,7 @@ Adders
 .. autofunction:: adder_qft_d00
 .. autofunction:: adder_ripple_c04
 .. autofunction:: adder_ripple_v95
+.. autofunction:: adder_ripple_r25
 
 Multipliers
 -----------
@@ -220,6 +225,10 @@ from .two_qubit.two_qubit_decompose import (
 )
 from .multi_controlled import (
     synth_mcmt_vchain,
+    synth_mcx_1_clean_kg24,
+    synth_mcx_1_dirty_kg24,
+    synth_mcx_2_clean_kg24,
+    synth_mcx_2_dirty_kg24,
     synth_mcx_n_dirty_i15,
     synth_mcx_n_clean_m15,
     synth_mcx_1_clean_b95,
@@ -232,6 +241,7 @@ from .arithmetic import (
     adder_qft_d00,
     adder_ripple_c04,
     adder_ripple_v95,
+    adder_ripple_r25,
     multiplier_cumulative_h18,
     multiplier_qft_r17,
     synth_integer_comparator_greedy,

qiskit/synthesis/arithmetic/__init__.py

@@ -13,6 +13,6 @@
 """Synthesis for arithmetic circuits."""
 
 from .comparators import synth_integer_comparator_2s, synth_integer_comparator_greedy
-from .adders import adder_qft_d00, adder_ripple_c04, adder_ripple_v95
+from .adders import adder_qft_d00, adder_ripple_c04, adder_ripple_v95, adder_ripple_r25
 from .multipliers import multiplier_cumulative_h18, multiplier_qft_r17
 from .weighted_sum import synth_weighted_sum_carry

qiskit/synthesis/arithmetic/adders/__init__.py

@@ -15,3 +15,4 @@
 from .cdkm_ripple_carry_adder import adder_ripple_c04
 from .vbe_ripple_carry_adder import adder_ripple_v95
 from .draper_qft_adder import adder_qft_d00
+from .rv_ripple_carry_adder import adder_ripple_r25

qiskit/synthesis/arithmetic/adders/draper_qft_adder.py

@@ -19,7 +19,9 @@ from qiskit.circuit import QuantumRegister
 from qiskit.circuit.library.basis_change import QFTGate
 
 
-def adder_qft_d00(num_state_qubits: int, kind: str = "half") -> QuantumCircuit:
+def adder_qft_d00(
+    num_state_qubits: int, kind: str = "half", annotated: bool = False
+) -> QuantumCircuit:
     r"""A circuit that uses QFT to perform in-place addition on two qubit registers.
 
     For registers with :math:`n` qubits, the QFT adder can perform addition modulo
@@ -51,6 +53,8 @@ def adder_qft_d00(num_state_qubits: int, kind: str = "half") -> QuantumCircuit:
             ``"fixed"`` for a fixed-sized adder. A half adder contains a carry-out to represent
             the most-significant bit, but the fixed-sized adder doesn't and hence performs
             addition modulo ``2 ** num_state_qubits``.
+        annotated: If ``True``, creates appropriate control and inverse operations as
+            ``AnnotatedOperation`` objects.
 
     **References:**
 
@@ -98,6 +102,6 @@ def adder_qft_d00(num_state_qubits: int, kind: str = "half") -> QuantumCircuit:
             # can be elided and cancelled by the compiler
             circuit.cp(lam, qr_a[j], qr_sum[~(j + k)])
 
-    circuit.append(qft.inverse(), qr_sum[:])
+    circuit.append(qft.inverse(annotated=annotated), qr_sum[:])
 
     return circuit