classiq 0.85.0__py3-none-any.whl → 0.86.1__py3-none-any.whl

classiq/applications/combinatorial_optimization/combinatorial_problem.py

@@ -46,11 +46,11 @@ class CombinatorialProblem:
         self._es: ExecutionSession | None = None
         self._optimized_params: list[float] | None = None
         self.params_trace_: list[np.ndarray] = []
-        self.cost_trace_: list = []
+        self._cost_trace: list[float] = []
 
     @property
-    def cost_trace(self) -> list:
-        return self.cost_trace_
+    def cost_trace(self) -> list[float]:
+        return self._cost_trace
 
     @property
     def params_trace(self) -> list[np.ndarray]:
@@ -119,6 +119,7 @@ class CombinatorialProblem:
         )
         _optimized_params = cast(list[float], result[-1][1]["params"])
         self._optimized_params = _optimized_params
+        self._cost_trace = [cost for cost, _ in result]
         self._es = _es
         return _optimized_params
 

classiq/evaluators/qmod_annotated_expression.py

@@ -0,0 +1,207 @@
+import ast
+from collections.abc import Sequence
+from dataclasses import dataclass
+from typing import Any, Union, cast
+
+from classiq.interface.model.handle_binding import HandleBinding
+
+from classiq.evaluators.qmod_node_evaluators.utils import QmodType, is_classical_type
+
+QmodExprNodeId = int
+
+
+@dataclass(frozen=True)
+class QuantumSubscriptAnnotation:
+    value: QmodExprNodeId
+    index: QmodExprNodeId
+
+
+@dataclass(frozen=True)
+class QuantumTypeAttributeAnnotation:
+    value: QmodExprNodeId
+    attr: str
+
+
+@dataclass(frozen=True)
+class ConcatenationAnnotation:
+    elements: list[QmodExprNodeId]
+
+
+class _ExprInliner(ast.NodeTransformer):
+    def __init__(self, expr_val: "QmodAnnotatedExpression") -> None:
+        self._expr_val = expr_val
+
+    def visit(self, node: ast.AST) -> Any:
+        if self._expr_val.has_value(node):
+            return ast.Name(id=str(self._expr_val.get_value(node)))
+        if self._expr_val.has_var(node):
+            return ast.Name(id=str(self._expr_val.get_var(node)))
+        return super().visit(node)
+
+
+class QmodAnnotatedExpression:
+    def __init__(self, expr_ast: ast.AST) -> None:
+        self.root = expr_ast
+        self._node_mapping: dict[QmodExprNodeId, ast.AST] = {}
+        self._values: dict[QmodExprNodeId, Any] = {}
+        self._types: dict[QmodExprNodeId, QmodType] = {}
+        self._classical_vars: dict[QmodExprNodeId, HandleBinding] = {}
+        self._quantum_vars: dict[QmodExprNodeId, HandleBinding] = {}
+        self._quantum_subscripts: dict[QmodExprNodeId, QuantumSubscriptAnnotation] = {}
+        self._quantum_type_attrs: dict[
+            QmodExprNodeId, QuantumTypeAttributeAnnotation
+        ] = {}
+        self._concatenations: dict[QmodExprNodeId, ConcatenationAnnotation] = {}
+
+    def to_qmod_expr(self) -> str:
+        return ast.unparse(_ExprInliner(self).visit(self.root))
+
+    def has_node(self, node_id: QmodExprNodeId) -> bool:
+        return node_id in self._node_mapping
+
+    def get_node(self, node_id: QmodExprNodeId) -> ast.AST:
+        return self._node_mapping[node_id]
+
+    def set_value(self, node: Union[ast.AST, QmodExprNodeId], value: Any) -> None:
+        if isinstance(node, ast.AST):
+            node = id(node)
+        self._values[node] = value
+
+    def get_value(self, node: Union[ast.AST, QmodExprNodeId]) -> Any:
+        if isinstance(node, ast.AST):
+            node = id(node)
+        return self._values[node]
+
+    def has_value(self, node: Union[ast.AST, QmodExprNodeId]) -> bool:
+        if isinstance(node, ast.AST):
+            node = id(node)
+        return node in self._values
+
+    def set_type(
+        self, node: Union[ast.AST, QmodExprNodeId], qmod_type: QmodType
+    ) -> None:
+        if isinstance(node, ast.AST):
+            node_id = id(node)
+            self._node_mapping[node_id] = node
+            node = id(node)
+        self._types[node] = qmod_type
+
+    def get_type(self, node: Union[ast.AST, QmodExprNodeId]) -> QmodType:
+        if isinstance(node, ast.AST):
+            node = id(node)
+        return self._types[node]
+
+    def set_var(self, node: Union[ast.AST, QmodExprNodeId], var: HandleBinding) -> None:
+        var = var.collapse()
+        if isinstance(node, ast.AST):
+            node = id(node)
+        if is_classical_type(self.get_type(node)):
+            self._classical_vars[node] = var
+        else:
+            self._quantum_vars[node] = var
+
+    def get_var(self, node: Union[ast.AST, QmodExprNodeId]) -> HandleBinding:
+        if isinstance(node, ast.AST):
+            node = id(node)
+        return (self._classical_vars | self._quantum_vars)[node]
+
+    def has_var(self, node: Union[ast.AST, QmodExprNodeId]) -> bool:
+        return self.has_classical_var(node) or self.has_quantum_var(node)
+
+    def has_classical_var(self, node: Union[ast.AST, QmodExprNodeId]) -> bool:
+        if isinstance(node, ast.AST):
+            node = id(node)
+        return node in self._classical_vars
+
+    def has_quantum_var(self, node: Union[ast.AST, QmodExprNodeId]) -> bool:
+        if isinstance(node, ast.AST):
+            node = id(node)
+        return node in self._quantum_vars
+
+    def remove_var(self, node: Union[ast.AST, QmodExprNodeId]) -> None:
+        if isinstance(node, ast.AST):
+            node = id(node)
+        if node in self._classical_vars:
+            self._classical_vars.pop(node)
+        else:
+            self._quantum_vars.pop(node)
+
+    def set_quantum_subscript(
+        self,
+        node: Union[ast.AST, QmodExprNodeId],
+        value: Union[ast.AST, QmodExprNodeId],
+        index: Union[ast.AST, QmodExprNodeId],
+    ) -> None:
+        if isinstance(node, ast.AST):
+            node = id(node)
+        if isinstance(value, ast.AST):
+            value = id(value)
+        if isinstance(index, ast.AST):
+            index = id(index)
+        self._quantum_subscripts[node] = QuantumSubscriptAnnotation(
+            value=value, index=index
+        )
+
+    def has_quantum_subscript(self, node: Union[ast.AST, QmodExprNodeId]) -> bool:
+        if isinstance(node, ast.AST):
+            node = id(node)
+        return node in self._quantum_subscripts
+
+    def get_quantum_subscripts(
+        self,
+    ) -> dict[QmodExprNodeId, QuantumSubscriptAnnotation]:
+        return self._quantum_subscripts
+
+    def set_quantum_type_attr(
+        self,
+        node: Union[ast.AST, QmodExprNodeId],
+        value: Union[ast.AST, QmodExprNodeId],
+        attr: str,
+    ) -> None:
+        if isinstance(node, ast.AST):
+            node = id(node)
+        if isinstance(value, ast.AST):
+            value = id(value)
+        self._quantum_type_attrs[node] = QuantumTypeAttributeAnnotation(
+            value=value, attr=attr
+        )
+
+    def has_quantum_type_attribute(self, node: Union[ast.AST, QmodExprNodeId]) -> bool:
+        if isinstance(node, ast.AST):
+            node = id(node)
+        return node in self._quantum_type_attrs
+
+    def get_quantum_type_attributes(
+        self,
+    ) -> dict[QmodExprNodeId, QuantumTypeAttributeAnnotation]:
+        return self._quantum_type_attrs
+
+    def set_concatenation(
+        self,
+        node: Union[ast.AST, QmodExprNodeId],
+        elements: Sequence[Union[ast.AST, QmodExprNodeId]],
+    ) -> None:
+        if isinstance(node, ast.AST):
+            node = id(node)
+        elements = cast(
+            list[QmodExprNodeId],
+            [
+                id(element) if isinstance(element, ast.AST) else element
+                for element in elements
+            ],
+        )
+        self._concatenations[node] = ConcatenationAnnotation(elements=elements)
+
+    def has_concatenation(self, node: Union[ast.AST, QmodExprNodeId]) -> bool:
+        if isinstance(node, ast.AST):
+            node = id(node)
+        return node in self._concatenations
+
+    def get_concatenations(self) -> dict[QmodExprNodeId, ConcatenationAnnotation]:
+        return self._concatenations
+
+    def get_classical_vars(self) -> dict[QmodExprNodeId, HandleBinding]:
+        return self._classical_vars
+
+    def get_quantum_vars(self) -> dict[QmodExprNodeId, HandleBinding]:
+        return self._quantum_vars

classiq/evaluators/qmod_expression_visitors/qmod_expression_bwc.py

@@ -0,0 +1,134 @@
+import ast
+from typing import Any, cast
+
+import sympy
+
+MAX_PIECEWISE_LOOPS = 1000
+
+
+# FIXME: Remove with deprecation (CLS-3214)
+class QmodExpressionBwc(ast.NodeTransformer):
+    def visit_Call(self, node: ast.Call) -> Any:
+        node = cast(ast.Call, self.generic_visit(node))
+        if not isinstance(node.func, ast.Name):
+            return node
+        func = node.func.id
+        args = node.args
+        kwargs = node.keywords
+        num_args = len(args)
+        num_kwargs = len(kwargs)
+
+        if func == "BitwiseNot":
+            if num_args != 1 or num_kwargs != 0:
+                return node
+            return ast.UnaryOp(op=ast.Invert(), operand=args[0])
+        if func == "LShift":
+            if num_args != 2 or num_kwargs != 0:
+                return node
+            return ast.BinOp(left=args[0], op=ast.LShift(), right=args[1])
+        if func == "RShift":
+            if num_args != 2 or num_kwargs != 0:
+                return node
+            return ast.BinOp(left=args[0], op=ast.RShift(), right=args[1])
+        if func == "BitwiseOr":
+            if num_args != 2 or num_kwargs != 0:
+                return node
+            return ast.BinOp(left=args[0], op=ast.BitOr(), right=args[1])
+        if func == "BitwiseXor":
+            if num_args != 2 or num_kwargs != 0:
+                return node
+            return ast.BinOp(left=args[0], op=ast.BitXor(), right=args[1])
+        if func == "BitwiseAnd":
+            if num_args != 2 or num_kwargs != 0:
+                return node
+            return ast.BinOp(left=args[0], op=ast.BitAnd(), right=args[1])
+
+        if func == "LogicalXor":
+            if num_args != 2 or num_kwargs != 0:
+                return node
+            return ast.BinOp(left=args[0], op=ast.BitXor(), right=args[1])
+
+        if func == "Eq":
+            if num_args != 2 or num_kwargs != 0:
+                return node
+            return ast.Compare(left=args[0], ops=[ast.Eq()], comparators=[args[1]])
+        if func == "Ne":
+            if num_args != 2 or num_kwargs != 0:
+                return node
+            return ast.Compare(left=args[0], ops=[ast.NotEq()], comparators=[args[1]])
+        if func == "Lt":
+            if num_args != 2 or num_kwargs != 0:
+                return node
+            return ast.Compare(left=args[0], ops=[ast.Lt()], comparators=[args[1]])
+        if func == "Le":
+            if num_args != 2 or num_kwargs != 0:
+                return node
+            return ast.Compare(left=args[0], ops=[ast.LtE()], comparators=[args[1]])
+        if func == "Gt":
+            if num_args != 2 or num_kwargs != 0:
+                return node
+            return ast.Compare(left=args[0], ops=[ast.Gt()], comparators=[args[1]])
+        if func == "Ge":
+            if num_args != 2 or num_kwargs != 0:
+                return node
+            return ast.Compare(left=args[0], ops=[ast.GtE()], comparators=[args[1]])
+
+        if func == "struct_literal":
+            if num_args != 1:
+                return node
+            return ast.Call(func=node.args[0], args=[], keywords=node.keywords)
+
+        if func == "do_subscript":
+            if num_args != 2 or num_kwargs != 0:
+                return node
+            return ast.Subscript(value=args[0], slice=args[1])
+
+        if func == "get_field":
+            if num_args != 2 or num_kwargs != 0:
+                return node
+            attr = args[1]
+            if not isinstance(attr, ast.Constant):
+                return node
+            return ast.Attribute(value=args[0], attr=attr.value)
+
+        if func == "Piecewise":
+            if num_args == 0:
+                return node
+            first_piece = args[0]
+            if not isinstance(first_piece, ast.Tuple) or len(first_piece.elts) != 2:
+                return node
+            first_cond = first_piece.elts[1]
+            if isinstance(first_cond, ast.BinOp):
+                first_cond = first_cond.right
+            if not isinstance(first_cond, ast.Compare) or len(first_cond.ops) != 1:
+                return node
+            index_var_node = first_cond.left
+            if not isinstance(index_var_node, ast.Name):
+                return node
+            index_var = index_var_node.id
+            last_cond = args[-1]
+            if not isinstance(last_cond, ast.Tuple) or len(last_cond.elts) != 2:
+                return node
+            last_value = last_cond.elts[0]
+            if not isinstance(last_value, ast.Constant) and (
+                not isinstance(last_value, ast.UnaryOp)
+                or not isinstance(last_value.operand, ast.Constant)
+            ):
+                return node
+            dummy_var_name = f"{index_var}_not_it"
+            last_cond.elts[0] = ast.Name(id=dummy_var_name)
+            items: list = []
+            idx = 0
+            for idx in range(MAX_PIECEWISE_LOOPS):
+                item = sympy.sympify(ast.unparse(node), locals={index_var: idx})
+                if str(item) == dummy_var_name:
+                    items.append(last_value)
+                    break
+                items.append(ast.parse(str(item), mode="eval").body)
+            if idx == MAX_PIECEWISE_LOOPS:
+                return node
+            return ast.Subscript(
+                value=ast.List(elts=items), slice=ast.Name(id=index_var)
+            )
+
+        return node

classiq/evaluators/qmod_expression_visitors/qmod_expression_evaluator.py

@@ -0,0 +1,232 @@
+import ast
+from collections.abc import Mapping, Sequence
+from enum import IntEnum
+from typing import Any, Callable, Optional
+
+from classiq.interface.exceptions import (
+    ClassiqExpansionError,
+    ClassiqInternalExpansionError,
+)
+from classiq.interface.generator.arith.machine_precision import (
+    DEFAULT_MACHINE_PRECISION,
+)
+from classiq.interface.generator.functions.classical_function_declaration import (
+    ClassicalFunctionDeclaration,
+)
+from classiq.interface.generator.types.enum_declaration import EnumDeclaration
+from classiq.interface.generator.types.struct_declaration import StructDeclaration
+from classiq.interface.helpers.pydantic_model_helpers import nameables_to_dict
+
+from classiq.evaluators.qmod_annotated_expression import QmodAnnotatedExpression
+from classiq.evaluators.qmod_node_evaluators.attribute_evaluation import eval_attribute
+from classiq.evaluators.qmod_node_evaluators.binary_op_evaluation import eval_binary_op
+from classiq.evaluators.qmod_node_evaluators.bool_op_evaluation import eval_bool_op
+from classiq.evaluators.qmod_node_evaluators.classical_function_evaluation import (
+    eval_function,
+    eval_symbolic_function,
+    try_eval_builtin_function,
+    try_eval_sympy_function,
+)
+from classiq.evaluators.qmod_node_evaluators.compare_evaluation import eval_compare
+from classiq.evaluators.qmod_node_evaluators.constant_evaluation import (
+    eval_constant,
+    eval_enum_member,
+    try_eval_sympy_constant,
+)
+from classiq.evaluators.qmod_node_evaluators.list_evaluation import eval_list
+from classiq.evaluators.qmod_node_evaluators.measurement_evaluation import (
+    eval_measurement,
+)
+from classiq.evaluators.qmod_node_evaluators.name_evaluation import eval_name
+from classiq.evaluators.qmod_node_evaluators.struct_instantiation_evaluation import (
+    eval_struct_instantiation,
+)
+from classiq.evaluators.qmod_node_evaluators.subscript_evaluation import (
+    eval_quantum_subscript,
+    eval_subscript,
+)
+from classiq.evaluators.qmod_node_evaluators.unary_op_evaluation import eval_unary_op
+from classiq.evaluators.qmod_node_evaluators.utils import is_classical_type
+
+_SUPPORTED_NODES = (
+    ast.BoolOp,
+    ast.BinOp,
+    ast.UnaryOp,
+    ast.Compare,
+    ast.Call,
+    ast.Constant,
+    ast.Attribute,
+    ast.Subscript,
+    ast.Name,
+    ast.List,
+    ast.cmpop,
+    ast.operator,
+    ast.expr_context,
+    ast.keyword,
+    ast.unaryop,
+    ast.boolop,
+    ast.Slice,
+)
+
+
+class QmodExpressionEvaluator(ast.NodeVisitor):
+    def __init__(
+        self,
+        expr_val: QmodAnnotatedExpression,
+        *,
+        machine_precision: int = DEFAULT_MACHINE_PRECISION,
+        classical_struct_declarations: Optional[Sequence[StructDeclaration]] = None,
+        enum_declarations: Optional[Sequence[EnumDeclaration]] = None,
+        classical_function_declarations: Optional[
+            Sequence[ClassicalFunctionDeclaration]
+        ] = None,
+        classical_function_callables: Optional[Mapping[str, Callable]] = None,
+        scope: Optional[dict[str, Any]] = None,
+    ) -> None:
+        self._expr_val = expr_val
+        self._machine_precision = machine_precision
+        self._classical_struct_decls = nameables_to_dict(
+            classical_struct_declarations or []
+        )
+        self._enum_declarations = {decl.name: decl for decl in enum_declarations or []}
+        self._enums: dict[str, type[IntEnum]] = {}
+        self._classical_function_declarations = nameables_to_dict(
+            classical_function_declarations or []
+        )
+        self._classical_function_callables = classical_function_callables or {}
+        self._scope = scope or {}
+
+    def visit(self, node: ast.AST) -> None:
+        if not isinstance(node, _SUPPORTED_NODES):
+            raise ClassiqInternalExpansionError(
+                f"Syntax error: {type(node).__name__!r} is not supported"
+            )
+        super().visit(node)
+
+    def visit_BoolOp(self, node: ast.BoolOp) -> None:
+        super().generic_visit(node)
+        eval_bool_op(self._expr_val, node)
+
+    def visit_BinOp(self, node: ast.BinOp) -> None:
+        super().generic_visit(node)
+        eval_binary_op(self._expr_val, node)
+
+    def visit_UnaryOp(self, node: ast.UnaryOp) -> None:
+        super().generic_visit(node)
+        eval_unary_op(self._expr_val, node)
+
+    def visit_Compare(self, node: ast.Compare) -> None:
+        super().generic_visit(node)
+        eval_compare(self._expr_val, node)
+
+    def visit_Call(self, node: ast.Call) -> None:
+        for arg in node.args:
+            self.visit(arg)
+        for kwarg in node.keywords:
+            self.visit(kwarg)
+
+        func = node.func
+        if not isinstance(func, ast.Name):
+            raise ClassiqExpansionError(
+                f"Function {ast.unparse(node.func)!r} is not supported"
+            )
+        func_name = func.id
+
+        if func_name == "measure":
+            eval_measurement(self._expr_val, node)
+            return
+
+        if func_name in self._classical_struct_decls:
+            eval_struct_instantiation(
+                self._expr_val, node, self._classical_struct_decls[func_name]
+            )
+            return
+
+        if func_name in self._classical_function_callables:
+            if func_name not in self._classical_function_declarations:
+                raise ClassiqInternalExpansionError
+            eval_function(
+                self._expr_val,
+                node,
+                self._classical_function_declarations[func_name],
+                self._classical_function_callables[func_name],
+            )
+            return
+
+        if func_name in self._classical_function_declarations:
+            eval_symbolic_function(
+                self._expr_val, node, self._classical_function_declarations[func_name]
+            )
+            return
+
+        if try_eval_builtin_function(self._expr_val, node, func_name):
+            return
+
+        if try_eval_sympy_function(self._expr_val, node, func_name):
+            return
+
+        raise ClassiqExpansionError(f"{func.id!r} is undefined")
+
+    def visit_Constant(self, node: ast.Constant) -> None:
+        eval_constant(self._expr_val, node)
+
+    def visit_Attribute(self, node: ast.Attribute) -> None:
+        if (
+            isinstance(node.value, ast.Name)
+            and (enum_name := node.value.id) in self._enum_declarations
+        ):
+            if enum_name not in self._enums:
+                self._enums[enum_name] = self._enum_declarations[
+                    enum_name
+                ].create_enum()
+            eval_enum_member(self._expr_val, node, self._enums[enum_name])
+            return
+        super().generic_visit(node)
+        eval_attribute(self._expr_val, node)
+
+    def visit_Subscript(self, node: ast.Subscript) -> None:
+        super().generic_visit(node)
+        if not isinstance(node.slice, ast.Slice) and not is_classical_type(
+            self._expr_val.get_type(node.slice)
+        ):
+            eval_quantum_subscript(self._expr_val, node, self._machine_precision)
+            return
+        eval_subscript(self._expr_val, node)
+
+    def visit_Name(self, node: ast.Name) -> None:
+        if try_eval_sympy_constant(self._expr_val, node):
+            return
+
+        if node.id not in self._scope:
+            raise ClassiqExpansionError(f"Variable {node.id!r} is undefined")
+        eval_name(self._expr_val, node, self._scope[node.id])
+
+    def visit_List(self, node: ast.List) -> None:
+        super().generic_visit(node)
+        eval_list(self._expr_val, node)
+
+
+def evaluate_qmod_expression(
+    expr: str,
+    *,
+    machine_precision: int = DEFAULT_MACHINE_PRECISION,
+    classical_struct_declarations: Optional[Sequence[StructDeclaration]] = None,
+    enum_declarations: Optional[Sequence[EnumDeclaration]] = None,
+    classical_function_declarations: Optional[
+        Sequence[ClassicalFunctionDeclaration]
+    ] = None,
+    classical_function_callables: Optional[Mapping[str, Callable]] = None,
+    scope: Optional[dict[str, Any]] = None,
+) -> QmodAnnotatedExpression:
+    expr_ast = ast.parse(expr, mode="eval").body
+    expr_value = QmodAnnotatedExpression(expr_ast)
+    QmodExpressionEvaluator(
+        expr_value,
+        machine_precision=machine_precision,
+        classical_struct_declarations=classical_struct_declarations,
+        enum_declarations=enum_declarations,
+        classical_function_declarations=classical_function_declarations,
+        classical_function_callables=classical_function_callables,
+        scope=scope,
+    ).visit(expr_value.root)
+    return expr_value

classiq/evaluators/qmod_expression_visitors/qmod_expression_renamer.py

@@ -0,0 +1,44 @@
+from typing import Optional
+
+from classiq.interface.model.handle_binding import HandleBinding, NestedHandleBinding
+
+from classiq.evaluators.qmod_annotated_expression import (
+    QmodAnnotatedExpression,
+    QmodExprNodeId,
+)
+
+
+def rename_handles_in_expression(
+    expr_val: QmodAnnotatedExpression,
+    renaming: dict[HandleBinding, HandleBinding],
+) -> str:
+    if len(renaming) == 0:
+        return expr_val.to_qmod_expr()
+    all_vars = expr_val.get_classical_vars() | expr_val.get_quantum_vars()
+    for node_id, var in all_vars.items():
+        renamed_var = _rename_var(renaming, var)
+        if renamed_var is not None:
+            expr_val.set_var(node_id, renamed_var)
+    return expr_val.to_qmod_expr()
+
+
+def _rename_var(
+    renaming: dict[HandleBinding, HandleBinding], var: HandleBinding
+) -> Optional[HandleBinding]:
+    if (renamed_var := renaming.get(var)) is not None:
+        return renamed_var
+    if not isinstance(var, NestedHandleBinding):
+        return None
+    renamed_inner = _rename_var(renaming, var.base_handle)
+    if renamed_inner is None:
+        return None
+    return var.model_copy(update=dict(base_handle=renamed_inner))
+
+
+def rename_nodes_in_expression(
+    expr_val: QmodAnnotatedExpression,
+    renaming: dict[QmodExprNodeId, HandleBinding],
+) -> str:
+    for node_id, renamed_var in renaming.items():
+        expr_val.set_var(node_id, renamed_var)
+    return expr_val.to_qmod_expr()