qiskit 1.3.0__cp39-abi3-win32.whl → 1.3.0b1__cp39-abi3-win32.whl

qiskit/qpy/binary_io/value.py

@@ -15,23 +15,20 @@
 from __future__ import annotations
 
 import collections.abc
-import io
 import struct
 import uuid
 
 import numpy as np
 import symengine
+from symengine.lib.symengine_wrapper import (  # pylint: disable = no-name-in-module
+    load_basic,
+)
 
 
 from qiskit.circuit import CASE_DEFAULT, Clbit, ClassicalRegister
 from qiskit.circuit.classical import expr, types
 from qiskit.circuit.parameter import Parameter
-from qiskit.circuit.parameterexpression import (
-    ParameterExpression,
-    op_code_to_method,
-    _OPCode,
-    _SUBS,
-)
+from qiskit.circuit.parameterexpression import ParameterExpression
 from qiskit.circuit.parametervector import ParameterVector, ParameterVectorElement
 from qiskit.qpy import common, formats, exceptions, type_keys
 
@@ -56,132 +53,20 @@ def _write_parameter_vec(file_obj, obj):
     file_obj.write(name_bytes)
 
 
-def _encode_replay_entry(inst, file_obj, version, r_side=False):
-    inst_type = None
-    inst_data = None
-    if inst is None:
-        inst_type = "n"
-        inst_data = b"\x00"
-    elif isinstance(inst, Parameter):
-        inst_type = "p"
-        inst_data = inst.uuid.bytes
-    elif isinstance(inst, complex):
-        inst_type = "c"
-        inst_data = struct.pack("!dd", inst.real, inst.imag)
-    elif isinstance(inst, float):
-        inst_type = "f"
-        inst_data = struct.pack("!Qd", 0, inst)
-    elif isinstance(inst, int):
-        inst_type = "i"
-        inst_data = struct.pack("!Qq", 0, inst)
-    elif isinstance(inst, ParameterExpression):
-        if not r_side:
-            entry = struct.pack(
-                formats.PARAM_EXPR_ELEM_V13_PACK,
-                255,
-                "s".encode("utf8"),
-                b"\x00",
-                "n".encode("utf8"),
-                b"\x00",
-            )
-        else:
-            entry = struct.pack(
-                formats.PARAM_EXPR_ELEM_V13_PACK,
-                255,
-                "n".encode("utf8"),
-                b"\x00",
-                "s".encode("utf8"),
-                b"\x00",
-            )
-        file_obj.write(entry)
-        _write_parameter_expression_v13(file_obj, inst, version)
-        if not r_side:
-            entry = struct.pack(
-                formats.PARAM_EXPR_ELEM_V13_PACK,
-                255,
-                "e".encode("utf8"),
-                b"\x00",
-                "n".encode("utf8"),
-                b"\x00",
-            )
-        else:
-            entry = struct.pack(
-                formats.PARAM_EXPR_ELEM_V13_PACK,
-                255,
-                "n".encode("utf8"),
-                b"\x00",
-                "e".encode("utf8"),
-                b"\x00",
-            )
-        file_obj.write(entry)
-        inst_type = "n"
-        inst_data = b"\x00"
+def _write_parameter_expression(file_obj, obj, use_symengine, *, version):
+    if use_symengine:
+        expr_bytes = obj._symbol_expr.__reduce__()[1][0]
     else:
-        raise exceptions.QpyError("Invalid parameter expression type")
-    return inst_type, inst_data
-
+        from sympy import srepr, sympify
 
-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()}
-        common.write_mapping(
-            mapping_buf, mapping=subs_dict, serializer=dumps_value, version=version
-        )
-        data = mapping_buf.getvalue()
-    entry = struct.pack(
-        formats.PARAM_EXPR_ELEM_V13_PACK,
-        subs.op,
-        "u".encode("utf8"),
-        struct.pack("!QQ", len(data), 0),
-        "n".encode("utf8"),
-        b"\x00",
-    )
-    file_obj.write(entry)
-    file_obj.write(data)
-    return subs.binds
-
-
-def _write_parameter_expression_v13(file_obj, obj, version):
-    symbol_map = {}
-    for inst in obj._qpy_replay:
-        if isinstance(inst, _SUBS):
-            symbol_map.update(_encode_replay_subs(inst, file_obj, version))
-            continue
-        lhs_type, lhs = _encode_replay_entry(inst.lhs, file_obj, version)
-        rhs_type, rhs = _encode_replay_entry(inst.rhs, file_obj, version, True)
-        entry = struct.pack(
-            formats.PARAM_EXPR_ELEM_V13_PACK,
-            inst.op,
-            lhs_type.encode("utf8"),
-            lhs,
-            rhs_type.encode("utf8"),
-            rhs,
-        )
-        file_obj.write(entry)
-    return symbol_map
+        expr_bytes = srepr(sympify(obj._symbol_expr)).encode(common.ENCODE)
 
-
-def _write_parameter_expression(file_obj, obj, use_symengine, *, version):
-    extra_symbols = None
-    if version < 13:
-        if use_symengine:
-            expr_bytes = obj._symbol_expr.__reduce__()[1][0]
-        else:
-            from sympy import srepr, sympify
-
-            expr_bytes = srepr(sympify(obj._symbol_expr)).encode(common.ENCODE)
-    else:
-        with io.BytesIO() as buf:
-            extra_symbols = _write_parameter_expression_v13(buf, obj, version)
-            expr_bytes = buf.getvalue()
-    symbol_table_len = len(obj._parameter_symbols)
-    if extra_symbols:
-        symbol_table_len += 2 * len(extra_symbols)
     param_expr_header_raw = struct.pack(
-        formats.PARAMETER_EXPR_PACK, symbol_table_len, len(expr_bytes)
+        formats.PARAMETER_EXPR_PACK, len(obj._parameter_symbols), len(expr_bytes)
     )
     file_obj.write(param_expr_header_raw)
     file_obj.write(expr_bytes)
+
     for symbol, value in obj._parameter_symbols.items():
         symbol_key = type_keys.Value.assign(symbol)
 
@@ -207,49 +92,6 @@ def _write_parameter_expression(file_obj, obj, use_symengine, *, version):
         file_obj.write(elem_header)
         file_obj.write(symbol_data)
         file_obj.write(value_data)
-    if extra_symbols:
-        for symbol in extra_symbols:
-            symbol_key = type_keys.Value.assign(symbol)
-            # serialize key
-            if symbol_key == type_keys.Value.PARAMETER_VECTOR:
-                symbol_data = common.data_to_binary(symbol, _write_parameter_vec)
-            else:
-                symbol_data = common.data_to_binary(symbol, _write_parameter)
-            # serialize value
-            value_key, value_data = dumps_value(
-                symbol, version=version, use_symengine=use_symengine
-            )
-
-            elem_header = struct.pack(
-                formats.PARAM_EXPR_MAP_ELEM_V3_PACK,
-                symbol_key,
-                value_key,
-                len(value_data),
-            )
-            file_obj.write(elem_header)
-            file_obj.write(symbol_data)
-            file_obj.write(value_data)
-        for symbol in extra_symbols.values():
-            symbol_key = type_keys.Value.assign(symbol)
-            # serialize key
-            if symbol_key == type_keys.Value.PARAMETER_VECTOR:
-                symbol_data = common.data_to_binary(symbol, _write_parameter_vec)
-            else:
-                symbol_data = common.data_to_binary(symbol, _write_parameter)
-            # serialize value
-            value_key, value_data = dumps_value(
-                symbol, version=version, use_symengine=use_symengine
-            )
-
-            elem_header = struct.pack(
-                formats.PARAM_EXPR_MAP_ELEM_V3_PACK,
-                symbol_key,
-                value_key,
-                len(value_data),
-            )
-            file_obj.write(elem_header)
-            file_obj.write(symbol_data)
-            file_obj.write(value_data)
 
 
 class _ExprWriter(expr.ExprVisitor[None]):
@@ -448,7 +290,7 @@ def _read_parameter_expression_v3(file_obj, vectors, use_symengine):
 
     payload = file_obj.read(data.expr_size)
     if use_symengine:
-        expr_ = common.load_symengine_payload(payload)
+        expr_ = load_basic(payload)
     else:
         from sympy.parsing.sympy_parser import parse_expr
 
@@ -495,141 +337,6 @@ def _read_parameter_expression_v3(file_obj, vectors, use_symengine):
     return ParameterExpression(symbol_map, expr_)
 
 
-def _read_parameter_expression_v13(file_obj, vectors, version):
-    data = formats.PARAMETER_EXPR(
-        *struct.unpack(formats.PARAMETER_EXPR_PACK, file_obj.read(formats.PARAMETER_EXPR_SIZE))
-    )
-
-    payload = file_obj.read(data.expr_size)
-
-    symbol_map = {}
-    for _ in range(data.map_elements):
-        elem_data = formats.PARAM_EXPR_MAP_ELEM_V3(
-            *struct.unpack(
-                formats.PARAM_EXPR_MAP_ELEM_V3_PACK,
-                file_obj.read(formats.PARAM_EXPR_MAP_ELEM_V3_SIZE),
-            )
-        )
-        symbol_key = type_keys.Value(elem_data.symbol_type)
-
-        if symbol_key == type_keys.Value.PARAMETER:
-            symbol = _read_parameter(file_obj)
-        elif symbol_key == type_keys.Value.PARAMETER_VECTOR:
-            symbol = _read_parameter_vec(file_obj, vectors)
-        else:
-            raise exceptions.QpyError(f"Invalid parameter expression map type: {symbol_key}")
-
-        elem_key = type_keys.Value(elem_data.type)
-        binary_data = file_obj.read(elem_data.size)
-        if elem_key == type_keys.Value.INTEGER:
-            value = struct.unpack("!q", binary_data)
-        elif elem_key == type_keys.Value.FLOAT:
-            value = struct.unpack("!d", binary_data)
-        elif elem_key == type_keys.Value.COMPLEX:
-            value = complex(*struct.unpack(formats.COMPLEX_PACK, binary_data))
-        elif elem_key in (type_keys.Value.PARAMETER, type_keys.Value.PARAMETER_VECTOR):
-            value = symbol._symbol_expr
-        elif elem_key == type_keys.Value.PARAMETER_EXPRESSION:
-            value = common.data_from_binary(
-                binary_data,
-                _read_parameter_expression_v13,
-                vectors=vectors,
-            )
-        else:
-            raise exceptions.QpyError(f"Invalid parameter expression map type: {elem_key}")
-        symbol_map[symbol] = value
-    with io.BytesIO(payload) as buf:
-        return _read_parameter_expr_v13(buf, symbol_map, version, vectors)
-
-
-def _read_parameter_expr_v13(buf, symbol_map, version, vectors):
-    param_uuid_map = {symbol.uuid: symbol for symbol in symbol_map if isinstance(symbol, Parameter)}
-    name_map = {str(v): k for k, v in symbol_map.items()}
-    data = buf.read(formats.PARAM_EXPR_ELEM_V13_SIZE)
-    stack = []
-    while data:
-        expression_data = formats.PARAM_EXPR_ELEM_V13._make(
-            struct.unpack(formats.PARAM_EXPR_ELEM_V13_PACK, data)
-        )
-        # LHS
-        if expression_data.LHS_TYPE == b"p":
-            stack.append(param_uuid_map[uuid.UUID(bytes=expression_data.LHS)])
-        elif expression_data.LHS_TYPE == b"f":
-            stack.append(struct.unpack("!Qd", expression_data.LHS)[1])
-        elif expression_data.LHS_TYPE == b"n":
-            pass
-        elif expression_data.LHS_TYPE == b"c":
-            stack.append(complex(*struct.unpack("!dd", expression_data.LHS)))
-        elif expression_data.LHS_TYPE == b"i":
-            stack.append(struct.unpack("!Qq", expression_data.LHS)[1])
-        elif expression_data.LHS_TYPE == b"s":
-            data = buf.read(formats.PARAM_EXPR_ELEM_V13_SIZE)
-            continue
-        elif expression_data.LHS_TYPE == b"e":
-            data = buf.read(formats.PARAM_EXPR_ELEM_V13_SIZE)
-            continue
-        elif expression_data.LHS_TYPE == b"u":
-            size = struct.unpack_from("!QQ", expression_data.LHS)[0]
-            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
-                )
-            stack.append({name_map[k]: v for k, v in mapping.items()})
-        else:
-            raise exceptions.QpyError(
-                "Unknown ParameterExpression operation type {expression_data.LHS_TYPE}"
-            )
-        # RHS
-        if expression_data.RHS_TYPE == b"p":
-            stack.append(param_uuid_map[uuid.UUID(bytes=expression_data.RHS)])
-        elif expression_data.RHS_TYPE == b"f":
-            stack.append(struct.unpack("!Qd", expression_data.RHS)[1])
-        elif expression_data.RHS_TYPE == b"n":
-            pass
-        elif expression_data.RHS_TYPE == b"c":
-            stack.append(complex(*struct.unpack("!dd", expression_data.RHS)))
-        elif expression_data.RHS_TYPE == b"i":
-            stack.append(struct.unpack("!Qq", expression_data.RHS)[1])
-        elif expression_data.RHS_TYPE == b"s":
-            data = buf.read(formats.PARAM_EXPR_ELEM_V13_SIZE)
-            continue
-        elif expression_data.RHS_TYPE == b"e":
-            data = buf.read(formats.PARAM_EXPR_ELEM_V13_SIZE)
-            continue
-        else:
-            raise exceptions.QpyError(
-                f"Unknown ParameterExpression operation type {expression_data.RHS_TYPE}"
-            )
-        if expression_data.OP_CODE == 255:
-            continue
-        method_str = op_code_to_method(_OPCode(expression_data.OP_CODE))
-        if expression_data.OP_CODE in {0, 1, 2, 3, 4, 13, 15, 18, 19, 20}:
-            rhs = stack.pop()
-            lhs = stack.pop()
-            # Reverse ops for commutative ops, which are add, mul (0 and 2 respectively)
-            # op codes 13 and 15 can never be reversed and 18, 19, 20
-            # are the reversed versions of non-commuative operations
-            # so 1, 3, 4 and 18, 19, 20 handle this explicitly.
-            if (
-                not isinstance(lhs, ParameterExpression)
-                and isinstance(rhs, ParameterExpression)
-                and expression_data.OP_CODE in {0, 2}
-            ):
-                if expression_data.OP_CODE == 0:
-                    method_str = "__radd__"
-                elif expression_data.OP_CODE == 2:
-                    method_str = "__rmul__"
-                stack.append(getattr(rhs, method_str)(lhs))
-            else:
-                stack.append(getattr(lhs, method_str)(rhs))
-        else:
-            lhs = stack.pop()
-            stack.append(getattr(lhs, method_str)())
-        data = buf.read(formats.PARAM_EXPR_ELEM_V13_SIZE)
-    return stack.pop()
-
-
 def _read_expr(
     file_obj,
     clbits: collections.abc.Sequence[Clbit],
@@ -960,17 +667,13 @@ def loads_value(
     if type_key == type_keys.Value.PARAMETER_EXPRESSION:
         if version < 3:
             return common.data_from_binary(binary_data, _read_parameter_expression)
-        elif version < 13:
+        else:
             return common.data_from_binary(
                 binary_data,
                 _read_parameter_expression_v3,
                 vectors=vectors,
                 use_symengine=use_symengine,
             )
-        else:
-            return common.data_from_binary(
-                binary_data, _read_parameter_expression_v13, vectors=vectors, version=version
-            )
     if type_key == type_keys.Value.EXPRESSION:
         return common.data_from_binary(
             binary_data,

qiskit/qpy/common.py

@@ -18,14 +18,9 @@ Common functions across several serialization and deserialization modules.
 import io
 import struct
 
-import symengine
-from symengine.lib.symengine_wrapper import (  # pylint: disable = no-name-in-module
-    load_basic,
-)
+from qiskit.qpy import formats
 
-from qiskit.qpy import formats, exceptions
-
-QPY_VERSION = 13
+QPY_VERSION = 12
 QPY_COMPATIBILITY_VERSION = 10
 ENCODE = "utf8"
 
@@ -309,42 +304,3 @@ def mapping_from_binary(binary_data, deserializer, **kwargs):
         mapping = read_mapping(container, deserializer, **kwargs)
 
     return mapping
-
-
-def load_symengine_payload(payload: bytes) -> symengine.Expr:
-    """Load a symengine expression from it's serialized cereal payload."""
-    # This is a horrible hack to workaround the symengine version checking
-    # it's deserialization does. There were no changes to the serialization
-    # format between 0.11 and 0.13 but the deserializer checks that it can't
-    # load across a major or minor version boundary. This works around it
-    # by just lying about the generating version.
-    symengine_version = symengine.__version__.split(".")
-    major = payload[2]
-    minor = payload[3]
-    if int(symengine_version[1]) != minor:
-        if major != 0:
-            raise exceptions.QpyError(
-                "Qiskit doesn't support loading a symengine payload generated with symengine >= 1.0"
-            )
-        if minor == 9:
-            raise exceptions.QpyError(
-                "Qiskit doesn't support loading a historical QPY file with `use_symengine=True` "
-                "generated in an environment using symengine 0.9.0. If you need to load this file "
-                "you can do so with Qiskit 0.45.x or 0.46.x and re-export the QPY file using "
-                "`use_symengine=False`."
-            )
-        if minor not in (11, 13):
-            raise exceptions.QpyError(
-                f"Incompatible symengine version {major}.{minor} used to generate the QPY "
-                "payload"
-            )
-        minor_version = int(symengine_version[1])
-        if minor_version not in (11, 13):
-            raise exceptions.QpyError(
-                f"Incompatible installed symengine version {symengine.__version__} to load "
-                "this QPY payload"
-            )
-        payload = bytearray(payload)
-        payload[3] = minor_version
-        payload = bytes(payload)
-    return load_basic(payload)

qiskit/qpy/formats.py

@@ -259,13 +259,6 @@ PARAMETER = namedtuple("PARAMETER", ["name_size", "uuid"])
 PARAMETER_PACK = "!H16s"
 PARAMETER_SIZE = struct.calcsize(PARAMETER_PACK)
 
-# PARAMETEREXPRESSION_ENTRY
-PARAM_EXPR_ELEM_V13 = namedtuple(
-    "PARAM_EXPR_ELEM_V13", ["OP_CODE", "LHS_TYPE", "LHS", "RHS_TYPE", "RHS"]
-)
-PARAM_EXPR_ELEM_V13_PACK = "!Bc16sc16s"
-PARAM_EXPR_ELEM_V13_SIZE = struct.calcsize(PARAM_EXPR_ELEM_V13_PACK)
-
 # COMPLEX
 COMPLEX = namedtuple("COMPLEX", ["real", "imag"])
 COMPLEX_PACK = "!dd"

qiskit/qpy/interface.py

@@ -25,9 +25,8 @@ from qiskit.circuit import QuantumCircuit
 from qiskit.pulse import ScheduleBlock
 from qiskit.exceptions import QiskitError
 from qiskit.qpy import formats, common, binary_io, type_keys
-from qiskit.qpy.exceptions import QPYLoadingDeprecatedFeatureWarning, QpyError
+from qiskit.qpy.exceptions import QpyError
 from qiskit.version import __version__
-from qiskit.utils.deprecate_pulse import deprecate_pulse_arg
 
 
 # pylint: disable=invalid-name
@@ -74,11 +73,6 @@ VERSION_PATTERN = (
 VERSION_PATTERN_REGEX = re.compile(VERSION_PATTERN, re.VERBOSE | re.IGNORECASE)
 
 
-@deprecate_pulse_arg(
-    "programs",
-    deprecation_description="Passing `ScheduleBlock` to `programs`",
-    predicate=lambda p: isinstance(p, ScheduleBlock),
-)
 def dump(
     programs: Union[List[QPY_SUPPORTED_TYPES], QPY_SUPPORTED_TYPES],
     file_obj: BinaryIO,
@@ -126,16 +120,15 @@ def dump(
         programs: QPY supported object(s) to store in the specified file like object.
             QPY supports :class:`.QuantumCircuit` and :class:`.ScheduleBlock`.
             Different data types must be separately serialized.
-            Support for :class:`.ScheduleBlock` is deprecated since Qiskit 1.3.0.
         file_obj: The file like object to write the QPY data too
         metadata_serializer: An optional JSONEncoder class that
             will be passed the ``.metadata`` attribute for each program in ``programs`` and will be
             used as the ``cls`` kwarg on the `json.dump()`` call to JSON serialize that dictionary.
         use_symengine: If True, all objects containing symbolic expressions will be serialized
             using symengine's native mechanism. This is a faster serialization alternative,
-            but not supported in all platforms. This flag only has an effect if the emitted QPY format
-            version is 10, 11, or 12. For QPY format version >= 13 (which is the default starting in
-            Qiskit 1.3.0) this flag is no longer used.
+            but not supported in all platforms. Please check that your target platform is supported
+            by the symengine library before setting this option, as it will be required by qpy to
+            deserialize the payload. For this reason, the option defaults to False.
         version: The QPY format version to emit. By default this defaults to
             the latest supported format of :attr:`~.qpy.QPY_VERSION`, however for
             compatibility reasons if you need to load the generated QPY payload with an older
@@ -151,17 +144,6 @@ def dump(
                 from the QPY format at that version will persist. This should only be used if
                 compatibility with loading the payload with an older version of Qiskit is necessary.
 
-            .. note::
-
-                If serializing a :class:`.QuantumCircuit` or :class:`.ScheduleBlock` that contain
-                :class:`.ParameterExpression` objects with ``version`` set low with the intent to
-                load the payload using a historical release of Qiskit, it is safest to set the
-                ``use_symengine`` flag to ``False``.  Versions of Qiskit prior to 1.2.4 cannot load
-                QPY files containing ``symengine``-serialized :class:`.ParameterExpression` objects
-                unless the version of ``symengine`` used between the loading and generating
-                environments matches.
-
-
     Raises:
         QpyError: When multiple data format is mixed in the output.
         TypeError: When invalid data type is input.
@@ -215,10 +197,7 @@ def dump(
     file_obj.write(header)
     common.write_type_key(file_obj, type_key)
 
-    pulse_gates = False
     for program in programs:
-        if type_key == type_keys.Program.CIRCUIT and program._calibrations_prop:
-            pulse_gates = True
         writer(
             file_obj,
             program,
@@ -227,13 +206,6 @@ def dump(
             version=version,
         )
 
-    if pulse_gates:
-        warnings.warn(
-            category=DeprecationWarning,
-            message="Pulse gates serialization is deprecated as of Qiskit 1.3. "
-            "It will be removed in Qiskit 2.0.",
-        )
-
 
 def load(
     file_obj: BinaryIO,
@@ -348,14 +320,6 @@ def load(
         loader = binary_io.read_circuit
     elif type_key == type_keys.Program.SCHEDULE_BLOCK:
         loader = binary_io.read_schedule_block
-        warnings.warn(
-            category=QPYLoadingDeprecatedFeatureWarning,
-            message="Pulse gates deserialization is deprecated as of Qiskit 1.3 and "
-            "will be removed in Qiskit 2.0. This is part of the deprecation plan for "
-            "the entire Qiskit Pulse package. Once Pulse is removed, `ScheduleBlock` "
-            "sections will be ignored when loading QPY files with pulse data.",
-        )
-
     else:
         raise TypeError(f"Invalid payload format data kind '{type_key}'.")
 

qiskit/quantum_info/__init__.py

@@ -28,7 +28,6 @@ Operators
    Pauli
    Clifford
    ScalarOp
-   SparseObservable
    SparsePauliOp
    CNOTDihedral
    PauliList
@@ -114,9 +113,6 @@ Analysis
 """
 
 from __future__ import annotations
-
-from qiskit._accelerate.sparse_observable import SparseObservable
-
 from .analysis import hellinger_distance, hellinger_fidelity, Z2Symmetries
 from .operators import (
     Clifford,

qiskit/quantum_info/operators/channel/transformations.py

@@ -220,39 +220,32 @@ def _kraus_to_choi(data):
 
 def _choi_to_kraus(data, input_dim, output_dim, atol=ATOL_DEFAULT):
     """Transform Choi representation to Kraus representation."""
-    import scipy.linalg
+    from scipy import linalg as la
 
     # Check if hermitian matrix
     if is_hermitian_matrix(data, atol=atol):
-        # Ideally we'd use `eigh`, but `scipy.linalg.eigh` has stability problems on macOS (at a
-        # minimum from SciPy 1.1 to 1.13 with the bundled OpenBLAS, or ~0.3.6 before they started
-        # bundling one in).  The Schur form of a Hermitian matrix is guaranteed diagonal:
-        #
-        #       H = U T U+   for upper-triangular T.
-        #   => H+ = U T+ U+
-        #   =>  T = T+       because H = H+, and thus T cannot have super-diagonal elements.
-        #
-        # So the eigenvalues are on the diagonal, therefore the basis-transformation matrix must be
-        # a spanning set of the eigenspace.
-        triangular, vecs = scipy.linalg.schur(data)
-        values = triangular.diagonal().real
-        # If we're not a CP map, fall-through back to the generalization handling.  Since we needed
-        # to get the eigenvalues anyway, we can do the CP check manually rather than deferring to a
-        # separate re-calculation.
-        if all(values >= -atol):
-            kraus = [
-                math.sqrt(value) * vec.reshape((output_dim, input_dim), order="F")
-                for value, vec in zip(values, vecs.T)
-                if abs(value) > atol
-            ]
-            # If we are converting a zero matrix, we need to return a Kraus set with a single
-            # zero-element Kraus matrix
+        # Get eigen-decomposition of Choi-matrix
+        # This should be a call to la.eigh, but there is an OpenBlas
+        # threading issue that is causing segfaults.
+        # Need schur here since la.eig does not
+        # guarantee orthogonality in degenerate subspaces
+        w, v = la.schur(data, output="complex")
+        w = w.diagonal().real
+        # Check eigenvalues are non-negative
+        if len(w[w < -atol]) == 0:
+            # CP-map Kraus representation
+            kraus = []
+            for val, vec in zip(w, v.T):
+                if abs(val) > atol:
+                    k = np.sqrt(val) * vec.reshape((output_dim, input_dim), order="F")
+                    kraus.append(k)
+            # If we are converting a zero matrix, we need to return a Kraus set
+            # with a single zero-element Kraus matrix
             if not kraus:
-                kraus = [np.zeros((output_dim, input_dim), dtype=complex)]
+                kraus.append(np.zeros((output_dim, input_dim), dtype=complex))
             return kraus, None
-        # Fall through.
-    # Non-CP-map generalized Kraus representation.
-    mat_u, svals, mat_vh = scipy.linalg.svd(data)
+    # Non-CP-map generalized Kraus representation
+    mat_u, svals, mat_vh = la.svd(data)
     kraus_l = []
     kraus_r = []
     for val, vec_l, vec_r in zip(svals, mat_u.T, mat_vh.conj()):

qiskit/quantum_info/operators/dihedral/dihedral.py

@@ -62,7 +62,7 @@ class CNOTDihedral(BaseOperator, AdjointMixin):
          # Print the CNOTDihedral element
          print(elem)
 
-    .. code-block:: text
+    .. parsed-literal::
 
         phase polynomial =
         0 + 3*x_0 + 3*x_1 + 2*x_0*x_1