qiskit 1.4.2__cp39-abi3-win_amd64.whl → 2.0.0rc2__cp39-abi3-win_amd64.whl

qiskit/assembler/run_config.py

@@ -1,77 +0,0 @@
-# This code is part of Qiskit.
-#
-# (C) Copyright IBM 2017, 2019.
-#
-# This code is licensed under the Apache License, Version 2.0. You may
-# obtain a copy of this license in the LICENSE.txt file in the root directory
-# of this source tree or at http://www.apache.org/licenses/LICENSE-2.0.
-#
-# Any modifications or derivative works of this code must retain this
-# copyright notice, and modified files need to carry a notice indicating
-# that they have been altered from the originals.
-
-"""Models for RunConfig and its related components."""
-
-from types import SimpleNamespace
-
-
-class RunConfig(SimpleNamespace):
-    """Class for Run Configuration.
-
-    Attributes:
-        shots (int): the number of shots
-        seed_simulator (int): the seed to use in the simulator
-        memory (bool): whether to request memory from backend (per-shot
-            readouts)
-        parameter_binds (list[dict]): List of parameter bindings
-    """
-
-    def __init__(
-        self,
-        shots=None,
-        seed_simulator=None,
-        memory=None,
-        parameter_binds=None,
-        **kwargs,
-    ):
-        """Initialize a RunConfig object
-
-        Args:
-            shots (int): the number of shots
-            seed_simulator (int): the seed to use in the simulator
-            memory (bool): whether to request memory from backend
-                (per-shot readouts)
-            parameter_binds (list[dict]): List of parameter bindings
-            **kwargs: optional fields
-        """
-        if shots is not None:
-            self.shots = shots
-        if seed_simulator is not None:
-            self.seed_simulator = seed_simulator
-        if memory is not None:
-            self.memory = memory
-        if parameter_binds is not None:
-            self.parameter_binds = parameter_binds
-        self.__dict__.update(kwargs)
-
-    @classmethod
-    def from_dict(cls, data):
-        """Create a new RunConfig object from a dictionary.
-
-        Args:
-            data (dict): A dictionary representing the RunConfig to create.
-                         It will be in the same format as output by
-                         :meth:`to_dict`.
-
-        Returns:
-            RunConfig: The RunConfig from the input dictionary.
-        """
-        return cls(**data)
-
-    def to_dict(self):
-        """Return a dictionary format representation of the RunConfig
-
-        Returns:
-            dict: The dictionary form of the RunConfig.
-        """
-        return self.__dict__

qiskit/circuit/bit.py

@@ -1,106 +0,0 @@
-# This code is part of Qiskit.
-#
-# (C) Copyright IBM 2019.
-#
-# This code is licensed under the Apache License, Version 2.0. You may
-# obtain a copy of this license in the LICENSE.txt file in the root directory
-# of this source tree or at http://www.apache.org/licenses/LICENSE-2.0.
-#
-# Any modifications or derivative works of this code must retain this
-# copyright notice, and modified files need to carry a notice indicating
-# that they have been altered from the originals.
-
-"""
-Quantum bit and Classical bit objects.
-"""
-import copy
-import warnings
-
-from qiskit.circuit.exceptions import CircuitError
-
-
-class Bit:
-    """Implement a generic bit.
-
-    .. note::
-        This class should not be instantiated directly. This is just a superclass
-        for :class:`~.Clbit` and :class:`~.circuit.Qubit`.
-    """
-
-    __slots__ = {"_register", "_index", "_hash", "_repr"}
-
-    def __init__(self, register=None, index=None):
-        """Create a new generic bit."""
-        if (register, index) == (None, None):
-            self._register = None
-            self._index = None
-            # To sidestep the overridden Bit.__hash__ and use the default hash
-            # algorithm (only new-style Bits), call default object hash method.
-            self._hash = object.__hash__(self)
-        else:
-            try:
-                index = int(index)
-            except Exception as ex:
-                raise CircuitError(
-                    f"index needs to be castable to an int: type {type(index)} was provided"
-                ) from ex
-
-            if index < 0:
-                index += register.size
-
-            if index >= register.size:
-                raise CircuitError(
-                    f"index must be under the size of the register: {index} was provided"
-                )
-
-            self._register = register
-            self._index = index
-            self._hash = hash((self._register, self._index))
-            self._repr = f"{self.__class__.__name__}({self._register}, {self._index})"
-
-    def __init_subclass__(cls):
-        # In Qiskit 2.0, `Bit` and `Register` will move to Rust space, and the allowable types of
-        # them will be fixed, similar to if the classes had been marked as `final`.
-        if cls.__module__.split(".", 2)[0] != __name__.split(".", 2)[0]:
-            warnings.warn(
-                "subclassing 'Bit' is not supported, and may not be possible in Qiskit 2.0",
-                category=DeprecationWarning,
-                stacklevel=2,
-            )
-        return cls
-
-    def __repr__(self):
-        """Return the official string representing the bit."""
-        if (self._register, self._index) == (None, None):
-            # Similar to __hash__, use default repr method for new-style Bits.
-            return object.__repr__(self)
-        return self._repr
-
-    def __hash__(self):
-        return self._hash
-
-    def __eq__(self, other):
-        if (self._register, self._index) == (None, None):
-            return other is self
-
-        try:
-            return self._repr == other._repr
-        except AttributeError:
-            return False
-
-    def __copy__(self):
-        # Bits are immutable.
-        return self
-
-    def __deepcopy__(self, memo=None):
-        if (self._register, self._index) == (None, None):
-            return self
-
-        # Old-style bits need special handling for now, since some code seems
-        # to rely on their registers getting deep-copied.
-        bit = type(self).__new__(type(self))
-        bit._register = copy.deepcopy(self._register, memo)
-        bit._index = self._index
-        bit._hash = self._hash
-        bit._repr = self._repr
-        return bit

qiskit/circuit/classicalfunction/__init__.py

@@ -1,152 +0,0 @@
-# This code is part of Qiskit.
-#
-# (C) Copyright IBM 2020.
-#
-# This code is licensed under the Apache License, Version 2.0. You may
-# obtain a copy of this license in the LICENSE.txt file in the root directory
-# of this source tree or at http://www.apache.org/licenses/LICENSE-2.0.
-#
-# Any modifications or derivative works of this code must retain this
-# copyright notice, and modified files need to carry a notice indicating
-# that they have been altered from the originals.
-
-"""
-====================================================================
-ClassicalFunction compiler (:mod:`qiskit.circuit.classicalfunction`)
-====================================================================
-
-.. currentmodule:: qiskit.circuit.classicalfunction
-
-Overview
-========
-
-.. warning::
-    
-    This module is deprecated as of Qiskit 1.4.0. It will be removed in the Qiskit 2.0 release.
-
-The classical function compiler provides the necessary tools to map a classical
-potentially irreversible functions into quantum circuits.  Below is a simple example of
-how to synthesize a simple boolean function defined using Python into a
-QuantumCircuit:
-
-   .. code-block::
-
-      from qiskit.circuit.classicalfunction import classical_function
-      from qiskit.circuit.classicalfunction.types import Int1
-
-      @classical_function
-      def grover_oracle(a: Int1, b: Int1, c: Int1, d: Int1) -> Int1:
-          return (not a and b and not c and d)
-
-      quantum_circuit = grover_oracle.synth(registerless=False)
-      quantum_circuit.draw('text')
-
-           a: ──o──
-                │
-           b: ──■──
-                │
-           c: ──o──
-                │
-           d: ──■──
-              ┌─┴─┐
-      return: ┤ X ├
-              └───┘
-
-Following Qiskit's little-endian bit ordering convention, the left-most bit (``a``) is the most
-significant bit and the right-most bit (``d``) is the least significant bit.
-
-.. warning::
-
-    The functionality of `qiskit.circuit.classicalfunction` requires `tweedledum`, 
-    which isn't available on all platforms (up to Python version 3.11).
-    See `tweedledum installation guide 
-    <https://github.com/boschmitt/tweedledum/tree/master?tab=readme-ov-file#installation>`_ 
-    for more details.
-
-Supplementary Information
-=========================
-
-Tweedledum
-----------
-
-Tweedledum is a C++-17 header-only library that implements a large set of
-reversible (and quantum) synthesis, optimization, and mapping algorithms.
-The classical function compiler relies on it and its dependencies to both represent logic
-networks and synthesize them into quantum circuits.
-
-ClassicalFunction data types
-----------------------------
-
-At the moment, the only type supported by the classical_function compilers is
-``qiskit.circuit.classicalfunction.types.Int1``. The classical function function
-to parse *must* include type hints (just ``Int1`` for now). The resulting gate
-will be a gate in the size of the sum of all the parameters and the return.
-
-The type ``Int1`` means the classical function will only operate at bit level.
-
-
-ClassicalFunction compiler API
-==============================
-
-classical_function
-------------------
-
-Decorator for a classical function that returns a `ClassicalFunction` object.
-
-.. autofunction:: classical_function
-
-ClassicalFunction
------------------
-
-.. autosummary::
-   :toctree: ../stubs/
-
-   ClassicalFunction
-   BooleanExpression
-
-Exceptions
-----------
-
-.. autosummary::
-   :toctree: ../stubs/
-
-   ClassicalFunctionCompilerTypeError
-   ClassicalFunctionParseError
-   ClassicalFunctionCompilerTypeError
-
-"""
-from qiskit.utils.deprecation import deprecate_func
-from .classicalfunction import ClassicalFunction
-from .exceptions import (
-    ClassicalFunctionParseError,
-    ClassicalFunctionCompilerError,
-    ClassicalFunctionCompilerTypeError,
-)
-from .boolean_expression import BooleanExpression
-
-
-@deprecate_func(
-    since="1.4",
-    removal_timeline="in Qiskit 2.0",
-    additional_msg="Use `PhaseOracle` instead, which can be turned into a "
-    "bit-flip oracle by applying Hadamard gates on the target "
-    "qubit before and after the instruction, and conditioning."
-    "the instruction on the target qubit.",
-)
-def classical_function(func):
-    """
-    Parses and type checks the callable ``func`` to compile it into an ``ClassicalFunction``
-    that can be synthesized into a ``QuantumCircuit``.
-
-    Args:
-        func (callable): A callable (with type hints) to compile into an ``ClassicalFunction``.
-
-    Returns:
-        ClassicalFunction: An object that can synthesis into a QuantumCircuit (via ``synth()``
-        method).
-    """
-    import inspect
-    from textwrap import dedent
-
-    source = dedent(inspect.getsource(func))
-    return ClassicalFunction(source, name=func.__name__)

qiskit/circuit/classicalfunction/boolean_expression.py

@@ -1,138 +0,0 @@
-# This code is part of Qiskit.
-#
-# (C) Copyright IBM 2021.
-#
-# This code is licensed under the Apache License, Version 2.0. You may
-# obtain a copy of this license in the LICENSE.txt file in the root directory
-# of this source tree or at http://www.apache.org/licenses/LICENSE-2.0.
-#
-# Any modifications or derivative works of this code must retain this
-# copyright notice, and modified files need to carry a notice indicating
-# that they have been altered from the originals.
-
-"""A quantum oracle constructed from a logical expression or a string in the DIMACS format."""
-
-from os.path import basename, isfile
-from typing import Callable, Optional
-
-from qiskit.utils.deprecation import deprecate_func
-from qiskit.circuit import QuantumCircuit
-from qiskit.utils.optionals import HAS_TWEEDLEDUM
-from .classical_element import ClassicalElement
-
-
-class BooleanExpression(ClassicalElement):
-    """The Boolean Expression gate."""
-
-    @HAS_TWEEDLEDUM.require_in_instance
-    @deprecate_func(
-        since="1.4",
-        removal_timeline="in Qiskit 2.0",
-        additional_msg="Use `PhaseOracle` instead, which can be turned into a "
-        "bit-flip oracle by applying Hadamard gates on the target "
-        "qubit before and after the instruction, and conditioning."
-        "the instruction on the target qubit.",
-    )
-    def __init__(self, expression: str, name: str = None, var_order: list = None) -> None:
-        """
-        Args:
-            expression (str): The logical expression string.
-            name (str): Optional. Instruction gate name. Otherwise part of the expression is
-               going to be used.
-            var_order(list): A list with the order in which variables will be created.
-               (default: by appearance)
-        """
-
-        from tweedledum import BoolFunction  # pylint: disable=import-error
-
-        self._tweedledum_bool_expression = BoolFunction.from_expression(
-            expression, var_order=var_order
-        )
-
-        short_expr_for_name = (expression[:10] + "...") if len(expression) > 13 else expression
-        num_qubits = (
-            self._tweedledum_bool_expression.num_outputs()
-            + self._tweedledum_bool_expression.num_inputs()
-        )
-        super().__init__(name or short_expr_for_name, num_qubits=num_qubits, params=[])
-
-    def simulate(self, bitstring: str) -> bool:
-        """Evaluate the expression on a bitstring.
-
-        This evaluation is done classically.
-
-        Args:
-            bitstring: The bitstring for which to evaluate.
-
-        Returns:
-            bool: result of the evaluation.
-        """
-        from tweedledum import BitVec  # pylint: disable=import-error
-
-        bits = []
-        for bit in bitstring:
-            bits.append(BitVec(1, bit))
-        return bool(self._tweedledum_bool_expression.simulate(*bits))
-
-    def synth(
-        self,
-        registerless: bool = True,
-        synthesizer: Optional[Callable[["BooleanExpression"], QuantumCircuit]] = None,
-    ):
-        """Synthesis the logic network into a :class:`~qiskit.circuit.QuantumCircuit`.
-
-        Args:
-            registerless: Default ``True``. If ``False`` uses the parameter names
-                to create registers with those names. Otherwise, creates a circuit with a flat
-                quantum register.
-            synthesizer: A callable that takes self and returns a Tweedledum
-                circuit.
-        Returns:
-            QuantumCircuit: A circuit implementing the logic network.
-        """
-        if registerless:
-            qregs = None
-        else:
-            qregs = None  # TODO: Probably from self._tweedledum_bool_expression._signature
-
-        if synthesizer is None:
-            from .utils import tweedledum2qiskit  # Avoid an import cycle
-            from tweedledum.synthesis import pkrm_synth  # pylint: disable=import-error
-
-            truth_table = self._tweedledum_bool_expression.truth_table(output_bit=0)
-            return tweedledum2qiskit(pkrm_synth(truth_table), name=self.name, qregs=qregs)
-        return synthesizer(self)
-
-    def _define(self):
-        """The definition of the boolean expression is its synthesis"""
-        self.definition = self.synth()
-
-    @classmethod
-    def from_dimacs_file(cls, filename: str):
-        """Create a BooleanExpression from the string in the DIMACS format.
-        Args:
-            filename: A file in DIMACS format.
-
-        Returns:
-            BooleanExpression: A gate for the input string
-
-        Raises:
-            FileNotFoundError: If filename is not found.
-        """
-        HAS_TWEEDLEDUM.require_now("BooleanExpression")
-
-        from tweedledum import BoolFunction  # pylint: disable=import-error
-
-        expr_obj = cls.__new__(cls)
-        if not isfile(filename):
-            raise FileNotFoundError(f"The file {filename} does not exists.")
-        expr_obj._tweedledum_bool_expression = BoolFunction.from_dimacs_file(filename)
-
-        num_qubits = (
-            expr_obj._tweedledum_bool_expression.num_inputs()
-            + expr_obj._tweedledum_bool_expression.num_outputs()
-        )
-        super(BooleanExpression, expr_obj).__init__(
-            name=basename(filename), num_qubits=num_qubits, params=[]
-        )
-        return expr_obj

qiskit/circuit/classicalfunction/classical_element.py

@@ -1,54 +0,0 @@
-# This code is part of Qiskit.
-#
-# (C) Copyright IBM 2021.
-#
-# This code is licensed under the Apache License, Version 2.0. You may
-# obtain a copy of this license in the LICENSE.txt file in the root directory
-# of this source tree or at http://www.apache.org/licenses/LICENSE-2.0.
-#
-# Any modifications or derivative works of this code must retain this
-# copyright notice, and modified files need to carry a notice indicating
-# that they have been altered from the originals.
-
-"""A quantum oracle constructed from a logical expression or a string in the DIMACS format."""
-
-from abc import ABCMeta, abstractmethod
-
-from qiskit.circuit import Gate
-
-
-class ClassicalElement(Gate, metaclass=ABCMeta):
-    """The classical element gate."""
-
-    @abstractmethod
-    def simulate(self, bitstring: str) -> bool:
-        """Evaluate the expression on a bitstring.
-
-        This evaluation is done classically.
-
-        Args:
-            bitstring: The bitstring for which to evaluate.
-
-        Returns:
-            bool: result of the evaluation.
-        """
-        pass
-
-    @abstractmethod
-    def synth(self, registerless=True, synthesizer=None):
-        """Synthesis the logic network into a :class:`~qiskit.circuit.QuantumCircuit`.
-
-        Args:
-            registerless (bool): Default ``True``. If ``False`` uses the parameter names
-                to create registers with those names. Otherwise, creates a circuit with a flat
-                quantum register.
-            synthesizer (callable): A callable that takes a Logic Network and returns a Tweedledum
-                circuit.
-        Returns:
-            QuantumCircuit: A circuit implementing the logic network.
-        """
-        pass
-
-    def _define(self):
-        """The definition of the boolean expression is its synthesis"""
-        self.definition = self.synth()

qiskit/circuit/classicalfunction/classical_function_visitor.py

@@ -1,155 +0,0 @@
-# This code is part of Qiskit.
-#
-# (C) Copyright IBM 2020.
-#
-# This code is licensed under the Apache License, Version 2.0. You may
-# obtain a copy of this license in the LICENSE.txt file in the root directory
-# of this source tree or at http://www.apache.org/licenses/LICENSE-2.0.
-#
-# Any modifications or derivative works of this code must retain this
-# copyright notice, and modified files need to carry a notice indicating
-# that they have been altered from the originals.
-
-"""Node visitor as defined in https://docs.python.org/3/library/ast.html#ast.NodeVisitor
-This module is used internally by ``qiskit.transpiler.classicalfunction.ClassicalFunction``.
-"""
-
-import ast
-import _ast
-
-from qiskit.utils.optionals import HAS_TWEEDLEDUM
-from .exceptions import ClassicalFunctionParseError, ClassicalFunctionCompilerTypeError
-
-
-@HAS_TWEEDLEDUM.require_in_instance
-class ClassicalFunctionVisitor(ast.NodeVisitor):
-    """Node visitor as defined in https://docs.python.org/3/library/ast.html#ast.NodeVisitor"""
-
-    # pylint: disable=invalid-name
-    bitops = {
-        _ast.BitAnd: "create_and",
-        _ast.BitOr: "create_or",
-        _ast.BitXor: "create_xor",
-        _ast.And: "create_and",
-        _ast.Or: "create_or",
-        _ast.Not: "create_not",
-    }
-
-    def __init__(self):
-        self.scopes = []
-        self.args = []
-        self._network = None
-        self.name = None
-        super().__init__()
-
-    def visit_Module(self, node):
-        """The full snippet should contain a single function"""
-        if len(node.body) != 1 and not isinstance(node.body[0], ast.FunctionDef):
-            raise ClassicalFunctionParseError("just functions, sorry!")
-        self.name = node.body[0].name
-        self.visit(node.body[0])
-
-    def visit_FunctionDef(self, node):
-        """The function definition should have type hints"""
-        if node.returns is None:
-            raise ClassicalFunctionParseError("return type is needed")
-        scope = {"return": (node.returns.id, None), node.returns.id: ("type", None)}
-
-        # Extend scope with the decorator's names
-        scope.update({decorator.id: ("decorator", None) for decorator in node.decorator_list})
-
-        from tweedledum.classical import LogicNetwork  # pylint: disable=import-error
-
-        self.scopes.append(scope)
-        self._network = LogicNetwork()
-        self.extend_scope(node.args)
-        return super().generic_visit(node)
-
-    def visit_Return(self, node):
-        """The return type should match the return type hint."""
-        _type, signal = self.visit(node.value)
-        if _type != self.scopes[-1]["return"][0]:
-            raise ClassicalFunctionParseError("return type error")
-        self._network.create_po(signal)
-
-    def visit_Assign(self, node):
-        """When assign, the scope needs to be updated with the right type"""
-        type_value, signal_value = self.visit(node.value)
-        for target in node.targets:
-            self.scopes[-1][target.id] = (type_value, signal_value)
-        return (type_value, signal_value)
-
-    def bit_binop(self, op, values):
-        """Uses ClassicalFunctionVisitor.bitops to extend self._network"""
-        bitop = ClassicalFunctionVisitor.bitops.get(type(op))
-        if not bitop:
-            raise ClassicalFunctionParseError(f"Unknown binop.op {op}")
-        binop = getattr(self._network, bitop)
-
-        left_type, left_signal = values[0]
-        if left_type != "Int1":
-            raise ClassicalFunctionParseError("binop type error")
-
-        for right_type, right_signal in values[1:]:
-            if right_type != "Int1":
-                raise ClassicalFunctionParseError("binop type error")
-            left_signal = binop(left_signal, right_signal)
-
-        return "Int1", left_signal
-
-    def visit_BoolOp(self, node):
-        """Handles ``and`` and ``or``.
-        node.left=Int1 and node.right=Int1 return Int1"""
-        return self.bit_binop(node.op, [self.visit(value) for value in node.values])
-
-    def visit_BinOp(self, node):
-        """Handles ``&``, ``^``, and ``|``.
-        node.left=Int1 and node.right=Int1 return Int1"""
-        return self.bit_binop(node.op, [self.visit(node.left), self.visit(node.right)])
-
-    def visit_UnaryOp(self, node):
-        """Handles ``~``. Cannot operate on Int1s."""
-        operand_type, operand_signal = self.visit(node.operand)
-        if operand_type != "Int1":
-            raise ClassicalFunctionCompilerTypeError(
-                f"UntaryOp.op {node.op} only support operation on Int1s for now"
-            )
-        bitop = ClassicalFunctionVisitor.bitops.get(type(node.op))
-        if not bitop:
-            raise ClassicalFunctionCompilerTypeError(
-                f"UntaryOp.op {node.op} does not operate with Int1 type "
-            )
-        return "Int1", getattr(self._network, bitop)(operand_signal)
-
-    def visit_Name(self, node):
-        """Reduce variable names."""
-        if node.id not in self.scopes[-1]:
-            raise ClassicalFunctionParseError(f"out of scope: {node.id}")
-        return self.scopes[-1][node.id]
-
-    def generic_visit(self, node):
-        """Catch all for the unhandled nodes."""
-        if isinstance(
-            node,
-            (
-                _ast.arguments,
-                _ast.arg,
-                _ast.Load,
-                _ast.BitAnd,
-                _ast.BitOr,
-                _ast.BitXor,
-                _ast.BoolOp,
-                _ast.Or,
-            ),
-        ):
-            return super().generic_visit(node)
-        raise ClassicalFunctionParseError(f"Unknown node: {type(node)}")
-
-    def extend_scope(self, args_node: _ast.arguments) -> None:
-        """Add the arguments to the scope"""
-        for arg in args_node.args:
-            if arg.annotation is None:
-                raise ClassicalFunctionParseError("argument type is needed")
-            self.args.append(arg.arg)
-            self.scopes[-1][arg.annotation.id] = ("type", None)
-            self.scopes[-1][arg.arg] = (arg.annotation.id, self._network.create_pi())