classiq 0.84.0__py3-none-any.whl → 0.86.0__py3-none-any.whl

classiq/applications/combinatorial_optimization/combinatorial_problem.py

@@ -1,12 +1,11 @@
 import math
 import re
-from typing import Callable, Optional
+from typing import Callable, Optional, cast
 
 import numpy as np
 import pandas as pd
 import pyomo.core as pyo
 import scipy
-from tqdm import tqdm
 
 from classiq.interface.executor.execution_preferences import ExecutionPreferences
 from classiq.interface.executor.result import ExecutionDetails
@@ -44,22 +43,22 @@ class CombinatorialProblem:
         self.num_layers_ = num_layers
         self.model_ = None
         self.qprog_ = None
-        self.es_ = None
-        self.optimized_params_ = None
+        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]:
         return self.params_trace_
 
     @property
-    def optimized_params(self) -> list:
-        return self.optimized_params_  # type:ignore[return-value]
+    def optimized_params(self) -> list[float]:
+        return self._optimized_params  # type:ignore[return-value]
 
     def get_model(
         self,
@@ -100,22 +99,9 @@ class CombinatorialProblem:
     ) -> list[float]:
         if self.qprog_ is None:
             self.get_qprog()
-        self.es_ = ExecutionSession(
-            self.qprog_, execution_preferences  # type:ignore[assignment,arg-type]
+        _es = ExecutionSession(
+            self.qprog_, execution_preferences  # type:ignore[arg-type]
         )
-        self.params_trace_ = []
-        self.cost_trace_ = []
-
-        def estimate_cost_wrapper(params: np.ndarray) -> float:
-            cost = self.es_.estimate_cost(  # type:ignore[attr-defined]
-                lambda state: self.cost_func(state["v"]),
-                {"params": params.tolist()},
-                quantile=quantile,
-            )
-            self.cost_trace_.append(cost)
-            self.params_trace_.append(params)
-            return cost
-
         initial_params = (
             np.concatenate(
                 (
@@ -125,31 +111,24 @@ class CombinatorialProblem:
             )
             * math.pi
         )
-
-        with tqdm(total=maxiter, desc="Optimization Progress", leave=True) as pbar:
-
-            def _minimze_callback(xk: np.ndarray) -> None:
-                pbar.update(1)  # increment progress bar
-                self.optimized_params_ = xk.tolist()  # save recent optimized value
-
-            self.optimized_params_ = scipy.optimize.minimize(
-                estimate_cost_wrapper,
-                callback=_minimze_callback,
-                x0=initial_params,
-                method="COBYLA",
-                options={"maxiter": maxiter},
-            ).x.tolist()
-
-        return self.optimized_params_  # type:ignore[return-value]
+        result = _es.minimize(
+            lambda v: self.cost_func(v),  # type:ignore[arg-type]
+            {"params": initial_params.tolist()},
+            maxiter,
+            quantile,
+        )
+        _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
 
     def sample_uniform(self) -> pd.DataFrame:
         return self.sample([0] * self.num_layers_ * 2)
 
     def sample(self, params: list) -> pd.DataFrame:
-        assert self.es_ is not None
-        res = self.es_.sample(  # type:ignore[unreachable]
-            {"params": params}
-        )
+        assert self._es is not None
+        res = self._es.sample({"params": params})
         parsed_result = [
             {
                 "solution": {
@@ -157,7 +136,7 @@ class CombinatorialProblem:
                     for key, value in sampled.state["v"].items()
                     if not re.match(".*_slack_var_.*", key)
                 },
-                "probability": sampled.shots / res.num_shots,
+                "probability": sampled.shots / res.num_shots,  # type:ignore[operator]
                 "cost": self.cost_func(sampled.state["v"]),
             }
             for sampled in res.parsed_counts

classiq/evaluators/classical_expression.py

@@ -11,26 +11,43 @@ from classiq.interface.generator.expressions.proxies.classical.any_classical_val
 from classiq.interface.model.handle_binding import HandleBinding
 
 from classiq.evaluators.expression_evaluator import evaluate
-from classiq.model_expansions.scope import Evaluated, QuantumSymbol, Scope
+from classiq.model_expansions.scope import (
+    ClassicalSymbol,
+    Evaluated,
+    QuantumSymbol,
+    Scope,
+)
 
 
 def evaluate_classical_expression(expr: Expression, scope: Scope) -> Evaluated:
     all_symbols = scope.items()
-    locals_dict = {
-        name: EvaluatedExpression(value=evaluated.value)
-        for name, evaluated in all_symbols
-        if isinstance(evaluated.value, get_args(ExpressionValue))
-    } | {
-        name: EvaluatedExpression(
-            value=(
-                evaluated.value.quantum_type.get_proxy(HandleBinding(name=name))
-                if evaluated.value.quantum_type.is_evaluated
-                else AnyClassicalValue(name)
+    locals_dict = (
+        {
+            name: EvaluatedExpression(value=evaluated.value)
+            for name, evaluated in all_symbols
+            if isinstance(evaluated.value, get_args(ExpressionValue))
+        }
+        | {
+            name: EvaluatedExpression(
+                value=(
+                    evaluated.value.quantum_type.get_proxy(HandleBinding(name=name))
+                    if evaluated.value.quantum_type.is_evaluated
+                    else AnyClassicalValue(name)
+                )
+            )
+            for name, evaluated in all_symbols
+            if isinstance(evaluated.value, QuantumSymbol)
+        }
+        | {
+            name: EvaluatedExpression(
+                value=evaluated.value.classical_type.get_classical_proxy(
+                    HandleBinding(name=name)
+                )
             )
-        )
-        for name, evaluated in all_symbols
-        if isinstance(evaluated.value, QuantumSymbol)
-    }
+            for name, evaluated in all_symbols
+            if isinstance(evaluated.value, ClassicalSymbol)
+        }
+    )
 
     ret = evaluate(expr, locals_dict)
     return Evaluated(value=ret.value)

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