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

qiskit/circuit/classicalfunction/classicalfunction.py

@@ -1,182 +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 class"""
-
-import ast
-from typing import Callable, Optional
-
-from qiskit.utils.deprecation import deprecate_func
-from qiskit.circuit import QuantumCircuit, QuantumRegister
-from qiskit.exceptions import QiskitError
-from qiskit.utils.optionals import HAS_TWEEDLEDUM
-from .classical_element import ClassicalElement
-from .classical_function_visitor import ClassicalFunctionVisitor
-from .utils import tweedledum2qiskit
-
-
-class ClassicalFunction(ClassicalElement):
-    """Represent a classical function and its logic network."""
-
-    @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, source, name=None):
-        """Creates a ``ClassicalFunction`` from Python source code in ``source``.
-
-        The code should be a single function with types.
-
-        Args:
-            source (str): Python code with type hints.
-            name (str): Optional. Default: "*classicalfunction*". ClassicalFunction name.
-
-        Raises:
-            QiskitError: If source is not a string.
-        """
-        if not isinstance(source, str):
-            raise QiskitError("ClassicalFunction needs a source code as a string.")
-        self._ast = ast.parse(source)
-        self._network = None
-        self._scopes = None
-        self._args = None
-        self._truth_table = None
-        super().__init__(
-            name or "*classicalfunction*",
-            num_qubits=sum(qreg.size for qreg in self.qregs),
-            params=[],
-        )
-
-    def compile(self):
-        """Parses and creates the logical circuit"""
-        _classical_function_visitor = ClassicalFunctionVisitor()
-        _classical_function_visitor.visit(self._ast)
-        self._network = _classical_function_visitor._network
-        self._scopes = _classical_function_visitor.scopes
-        self._args = _classical_function_visitor.args
-        self.name = _classical_function_visitor.name
-
-    @property
-    def network(self):
-        """Returns the logical network"""
-        if self._network is None:
-            self.compile()
-        return self._network
-
-    @property
-    def scopes(self):
-        """Returns the scope dict"""
-        if self._scopes is None:
-            self.compile()
-        return self._scopes
-
-    @property
-    def args(self):
-        """Returns the classicalfunction arguments"""
-        if self._args is None:
-            self.compile()
-        return self._args
-
-    @property
-    def types(self):
-        """Dumps a list of scopes with their variables and types.
-
-        Returns:
-            list(dict): A list of scopes as dicts, where key is the variable name and
-            value is its type.
-        """
-        ret = []
-        for scope in self.scopes:
-            ret.append({k: v[0] for k, v in scope.items()})
-        return ret
-
-    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.classical import simulate  # pylint: disable=import-error
-
-        return simulate(self._network, bitstring)
-
-    def simulate_all(self):
-        """
-        Returns a truth table.
-
-        Returns:
-            str: a bitstring with a truth table
-        """
-        result = []
-        for position in range(2 ** self._network.num_pis()):
-            sim_result = "".join([str(int(tt[position])) for tt in self.truth_table])
-            result.append(sim_result)
-
-        return "".join(reversed(result))
-
-    @property
-    def truth_table(self):
-        """Returns (and computes) the truth table"""
-        from tweedledum.classical import simulate  # pylint: disable=import-error
-
-        if self._truth_table is None:
-            self._truth_table = simulate(self._network)
-        return self._truth_table
-
-    def synth(
-        self,
-        registerless: bool = True,
-        synthesizer: Optional[Callable[[ClassicalElement], QuantumCircuit]] = None,
-    ) -> QuantumCircuit:
-        """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: Optional. If None tweedledum's pkrm_synth is used.
-
-        Returns:
-            QuantumCircuit: A circuit implementing the logic network.
-        """
-        if registerless:
-            qregs = None
-        else:
-            qregs = self.qregs
-
-        if synthesizer:
-            return synthesizer(self)
-
-        from tweedledum.synthesis import pkrm_synth  # pylint: disable=import-error
-
-        return tweedledum2qiskit(pkrm_synth(self.truth_table[0]), name=self.name, qregs=qregs)
-
-    def _define(self):
-        """The definition of the classical function is its synthesis"""
-        self.definition = self.synth()
-
-    @property
-    def qregs(self):
-        """The list of qregs used by the classicalfunction"""
-        qregs = [QuantumRegister(1, name=arg) for arg in self.args if self.types[0][arg] == "Int1"]
-        if self.types[0]["return"] == "Int1":
-            qregs.append(QuantumRegister(1, name="return"))
-        return qregs

qiskit/circuit/classicalfunction/exceptions.py

@@ -1,41 +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.
-
-"""Exceptions for ClassicalFunction compiler
-
-.. warning::
-    
-    This module is deprecated as of qiskit 1.4.0 version. It will be removed in the Qiskit 2.0 release.
-
-"""
-
-from qiskit.exceptions import QiskitError
-
-
-class ClassicalFunctionCompilerError(QiskitError):
-    """ClassicalFunction compiler generic error."""
-
-    pass
-
-
-class ClassicalFunctionParseError(ClassicalFunctionCompilerError):
-    """ClassicalFunction compiler parse error.
-    The classicalfunction function fails at parsing time."""
-
-    pass
-
-
-class ClassicalFunctionCompilerTypeError(ClassicalFunctionCompilerError):
-    """ClassicalFunction compiler type error.
-    The classicalfunction function fails at type checking time."""
-
-    pass

qiskit/circuit/classicalfunction/types.py

@@ -1,18 +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 function types."""
-
-from typing import NewType
-
-Int1 = NewType("Int1", bool)
-Int2 = NewType("Int2", int)

qiskit/circuit/classicalfunction/utils.py

@@ -1,91 +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.
-
-"""Internal utils for Classical Function Compiler"""
-
-from qiskit.utils.optionals import HAS_TWEEDLEDUM
-
-from qiskit.circuit import QuantumCircuit
-from qiskit.circuit.library.standard_gates import (
-    HGate,
-    SGate,
-    SdgGate,
-    SwapGate,
-    TGate,
-    TdgGate,
-    XGate,
-    YGate,
-    ZGate,
-)
-
-_QISKIT_OPS = {
-    "std.h": HGate,
-    "std.s": SGate,
-    "std.sdg": SdgGate,
-    "std.swap": SwapGate,
-    "std.t": TGate,
-    "std.tdg": TdgGate,
-    "std.x": XGate,
-    "std.y": YGate,
-    "std.z": ZGate,
-}
-
-
-@HAS_TWEEDLEDUM.require_in_call
-def _convert_tweedledum_operator(op):
-    base_gate = _QISKIT_OPS.get(op.kind())
-    if base_gate is None:
-        if op.kind() == "py_operator":
-            return op.py_op()
-        else:
-            raise RuntimeError(f"Unrecognized operator: {op.kind()}")
-
-    # TODO: need to deal with cbits too!
-    if op.num_controls() > 0:
-        from tweedledum.ir import Qubit  # pylint: disable=import-error
-
-        qubits = op.qubits()
-        ctrl_state = ""
-        for qubit in qubits[: op.num_controls()]:
-            ctrl_state += f"{int(qubit.polarity() == Qubit.Polarity.positive)}"
-        return base_gate().control(len(ctrl_state), ctrl_state=ctrl_state[::-1])
-    return base_gate()
-
-
-@HAS_TWEEDLEDUM.require_in_call
-def tweedledum2qiskit(tweedledum_circuit, name=None, qregs=None):
-    """Converts a `Tweedledum <https://github.com/boschmitt/tweedledum>`_
-    circuit into a Qiskit circuit.
-    Args:
-        tweedledum_circuit (tweedledum.ir.Circuit): Tweedledum circuit.
-        name (str): Name for the resulting Qiskit circuit.
-        qregs (list(QuantumRegister)): Optional. List of QuantumRegisters on which the
-           circuit would operate. If not provided, it will create a flat register.
-
-    Returns:
-        QuantumCircuit: The Tweedledum circuit converted to a Qiskit circuit.
-
-    Raises:
-        ClassicalFunctionCompilerError: If a gate in the Tweedledum circuit has no Qiskit equivalent.
-    """
-    if qregs:
-        qiskit_qc = QuantumCircuit(*qregs, name=name)
-    else:
-        qiskit_qc = QuantumCircuit(tweedledum_circuit.num_qubits(), name=name)
-
-    from tweedledum.passes import parity_decomp  # pylint: disable=import-error
-
-    for instruction in parity_decomp(tweedledum_circuit):
-        gate = _convert_tweedledum_operator(instruction)
-        qubits = [qubit.uid() for qubit in instruction.qubits()]
-        qiskit_qc.append(gate, qubits)
-    return qiskit_qc

qiskit/circuit/classicalregister.py

@@ -1,57 +0,0 @@
-# This code is part of Qiskit.
-#
-# (C) Copyright IBM 2017.
-#
-# 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.
-
-# pylint: disable=bad-docstring-quotes
-
-"""
-Classical register reference object.
-"""
-import itertools
-
-from qiskit.circuit.exceptions import CircuitError
-
-from .register import Register
-from .bit import Bit
-
-
-class Clbit(Bit):
-    """Implement a classical bit."""
-
-    __slots__ = ()
-
-    def __init__(self, register=None, index=None):
-        """Creates a classical bit.
-
-        Args:
-            register (ClassicalRegister): Optional. A classical register containing the bit.
-            index (int): Optional. The index of the bit in its containing register.
-
-        Raises:
-            CircuitError: if the provided register is not a valid :class:`ClassicalRegister`
-        """
-
-        if register is None or isinstance(register, ClassicalRegister):
-            super().__init__(register, index)
-        else:
-            raise CircuitError(
-                f"Clbit needs a ClassicalRegister and {type(register).__name__} was provided"
-            )
-
-
-class ClassicalRegister(Register):
-    """Implement a classical register."""
-
-    # Counter for the number of instances in this class.
-    instances_counter = itertools.count()
-    # Prefix to use for auto naming.
-    prefix = "c"
-    bit_type = Clbit