qiskit 1.3.0__cp39-abi3-macosx_11_0_arm64.whl

qiskit/circuit/classicalfunction/boolean_expression.py

@@ -0,0 +1,129 @@
+# 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.circuit import QuantumCircuit
+from qiskit.utils.optionals import HAS_TWEEDLEDUM
+from .classical_element import ClassicalElement
+
+
+@HAS_TWEEDLEDUM.require_in_instance
+class BooleanExpression(ClassicalElement):
+    """The Boolean Expression gate."""
+
+    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

@@ -0,0 +1,54 @@
+# 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

@@ -0,0 +1,155 @@
+# 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())

qiskit/circuit/classicalfunction/classicalfunction.py

@@ -0,0 +1,173 @@
+# 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.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
+
+
+@HAS_TWEEDLEDUM.require_in_instance
+class ClassicalFunction(ClassicalElement):
+    """Represent a classical function and its logic network."""
+
+    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

@@ -0,0 +1,35 @@
+# 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"""
+
+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

@@ -0,0 +1,18 @@
+# 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

@@ -0,0 +1,91 @@
+# 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