classiq 0.74.0__py3-none-any.whl → 0.76.0__py3-none-any.whl

classiq/model_expansions/scope.py

@@ -66,8 +66,6 @@ class QuantumSymbol:
             raise ClassiqExpansionError(
                 f"{self.quantum_type.type_name} is not subscriptable"
             )
-        if TYPE_CHECKING:
-            assert self.quantum_type.length is not None
         if isinstance(start, int) and isinstance(end, int) and start >= end:
             raise ClassiqExpansionError(
                 f"{self.quantum_type.type_name} slice '{self.handle}[{start}:{end}]' "
@@ -75,6 +73,7 @@ class QuantumSymbol:
             )
         if (isinstance(start, int) and start < 0) or (
             isinstance(end, int)
+            and self.quantum_type.length is not None
             and self.quantum_type.length.is_constant()
             and end > self.quantum_type.length_value
         ):
@@ -100,19 +99,23 @@ class QuantumSymbol:
             raise ClassiqExpansionError(
                 f"{self.quantum_type.type_name} is not subscriptable"
             )
-        if TYPE_CHECKING:
-            assert self.quantum_type.length is not None
         if isinstance(index, int) and (
             index < 0
             or (
-                self.quantum_type.length.is_constant()
+                self.quantum_type.length is not None
+                and self.quantum_type.length.is_constant()
                 and index >= self.quantum_type.length_value
             )
         ):
+            length_suffix = (
+                f" (of length {self.quantum_type.length})"
+                if self.quantum_type.length is not None
+                else ""
+            )
             raise ClassiqExpansionError(
                 f"Index {index} is out of bounds for "
-                f"{self.quantum_type.type_name.lower()} {str(self.handle)!r} (of "
-                f"length {self.quantum_type.length})"
+                f"{self.quantum_type.type_name.lower()} {str(self.handle)!r}"
+                f"{length_suffix}"
             )
         return QuantumSymbol(
             handle=SubscriptHandleBinding(

classiq/model_expansions/sympy_conversion/arithmetics.py

@@ -47,3 +47,21 @@ class BitwiseNot(Function):
             return ~a
 
         return None
+
+
+class RShift(Function):
+    @classmethod
+    def eval(cls, a: Any, b: Any) -> Optional[int]:
+        if isinstance(a, Integer) and isinstance(b, Integer):
+            return a >> b
+
+        return None
+
+
+class LShift(Function):
+    @classmethod
+    def eval(cls, a: Any, b: Any) -> Optional[int]:
+        if isinstance(a, Integer) and isinstance(b, Integer):
+            return a << b
+
+        return None

classiq/model_expansions/sympy_conversion/expression_to_sympy.py

@@ -23,6 +23,8 @@ class ExpressionSympyTranslator(ast.NodeTransformer):
         ast.BitAnd: "BitwiseAnd",
         ast.BitXor: "BitwiseXor",
         ast.Div: "do_div",
+        ast.RShift: "RShift",
+        ast.LShift: "LShift",
     }
 
     UNARY_OPERATORS: dict[type[ast.AST], str] = {

classiq/model_expansions/sympy_conversion/sympy_to_python.py

@@ -17,6 +17,9 @@ from sympy.printing.pycode import PythonCodePrinter
 
 from classiq.interface.exceptions import ClassiqInternalExpansionError
 from classiq.interface.generator.expressions.expression_types import ExpressionValue
+from classiq.interface.generator.expressions.proxies.classical.any_classical_value import (
+    AnyClassicalValue,
+)
 
 from classiq.model_expansions.sympy_conversion.arithmetics import LogicalXor
 
@@ -24,7 +27,9 @@ from classiq.model_expansions.sympy_conversion.arithmetics import LogicalXor
 def sympy_to_python(
     value: Any, locals: Optional[dict[str, ExpressionValue]] = None
 ) -> ExpressionValue:
-    if isinstance(value, Integer):
+    if isinstance(value, AnyClassicalValue):
+        pass
+    elif isinstance(value, Integer):
         value = int(value)
     elif isinstance(value, Float):
         value = float(value)
@@ -66,6 +71,8 @@ class SympyToQuantumExpressionTranslator(PythonCodePrinter):
         "BitwiseOr": "|",
         "BitwiseXor": "^",
         "LogicalXor": "^",
+        "RShift": ">>",
+        "LShift": "<<",
     }
     UNARY_BITWISE_OPERATORS_MAPPING = {"BitwiseNot": "~"}
 
@@ -117,6 +124,8 @@ class SympyToBoolExpressionTranslator(SympyToQuantumExpressionTranslator):
 
 
 def translate_sympy_quantum_expression(expr: Basic, preserve_bool_ops: bool) -> str:
+    if isinstance(expr, AnyClassicalValue):
+        return str(expr)
     if preserve_bool_ops:
         return SympyToBoolExpressionTranslator().doprint(expr)
     else:

classiq/model_expansions/transformers/model_renamer.py

@@ -2,8 +2,10 @@ import ast
 import re
 from collections.abc import Mapping, Sequence
 from dataclasses import dataclass
+from functools import cmp_to_key
 from typing import TypeVar, cast
 
+from classiq.interface.exceptions import ClassiqInternalExpansionError
 from classiq.interface.generator.expressions.expression import Expression
 from classiq.interface.generator.visitor import NodeType
 from classiq.interface.model.handle_binding import HandleBinding
@@ -23,6 +25,39 @@ def _replace_full_word(pattern: str, substitution: str, target: str) -> str:
     )
 
 
+def _handle_contains_handle(handle: HandleBinding, other_handle: HandleBinding) -> int:
+    if str(other_handle) in str(handle) or other_handle.qmod_expr in handle.qmod_expr:
+        return 1
+    if str(handle) in str(other_handle) or handle.qmod_expr in other_handle.qmod_expr:
+        return -1
+    return 0
+
+
+class _ExprNormalizer(ast.NodeTransformer):
+    def visit_Call(self, node: ast.Call) -> ast.AST:
+        if not isinstance(node.func, ast.Name):
+            return self.generic_visit(node)
+        if node.func.id == "get_field":
+            if (
+                len(node.args) != 2
+                or not isinstance(node.args[1], ast.Constant)
+                or not isinstance(node.args[1].value, str)
+            ):
+                raise ClassiqInternalExpansionError("Unexpected 'get_field' arguments")
+            return ast.Attribute(
+                value=self.visit(node.args[0]), attr=node.args[1].value
+            )
+        if node.func.id == "do_subscript":
+            if len(node.args) != 2:
+                raise ClassiqInternalExpansionError(
+                    "Unexpected 'do_subscript' arguments"
+                )
+            return ast.Subscript(
+                value=self.visit(node.args[0]), slice=self.visit(node.args[1])
+            )
+        return self.generic_visit(node)
+
+
 @dataclass(frozen=True)
 class HandleRenaming:
     source_handle: HandleBinding
@@ -39,26 +74,29 @@ SymbolRenaming = Mapping[HandleBinding, Sequence[HandleRenaming]]
 def _rewrite_expression(
     symbol_mapping: SymbolRenaming, expression: Expression
 ) -> Expression:
+    normalized_expr = _ExprNormalizer().visit(ast.parse(expression.expr))
     vrc = VarRefCollector(
         ignore_duplicated_handles=True, ignore_sympy_symbols=True, unevaluated=True
     )
-    vrc.visit(ast.parse(expression.expr))
+    vrc.visit(normalized_expr)
 
     handle_names = {
         part.source_handle: part.target_var_handle
         for parts in symbol_mapping.values()
         for part in parts
     }
-    new_expr_str = expression.expr
-    for handle in vrc.var_handles:
+    new_expr_str = ast.unparse(normalized_expr)
+    sorted_handles = sorted(
+        vrc.var_handles,
+        key=cmp_to_key(  # type:ignore[misc]
+            lambda handle, other_handle: _handle_contains_handle(other_handle, handle)
+        ),
+    )
+    for handle in sorted_handles:
         new_handle = handle.collapse()
         for handle_to_replace, replacement in handle_names.items():
             new_handle = new_handle.replace_prefix(handle_to_replace, replacement)
         new_expr_str = _replace_full_word(str(handle), str(new_handle), new_expr_str)
-        if handle.qmod_expr != str(handle):
-            new_expr_str = _replace_full_word(
-                str(handle.qmod_expr), str(new_handle.qmod_expr), new_expr_str
-            )
 
     new_expr = Expression(expr=new_expr_str)
     new_expr._evaluated_expr = expression._evaluated_expr
@@ -92,7 +130,9 @@ class _ReplaceSplitVarsExpressions(ModelTransformer):
     ) -> QuantumExpressionOperation:
         op = cast(QuantumExpressionOperation, self.generic_visit(op))
         previous_var_handles = list(op._var_handles)
-        op._var_handles = self.visit(op._var_handles)
+        op._var_handles = _ReplaceSplitVarsHandles(self._symbol_mapping).visit(
+            op._var_handles
+        )
         op._var_types = {
             new_handle.name: op._var_types.get(
                 new_handle.name, op._var_types[previous_handle.name]

classiq/model_expansions/utils/handles_collector.py

@@ -18,7 +18,7 @@ class _HandlesCollector(Visitor):
         self.handles.append(handle)
 
     def visit_Expression(self, expression: Expression) -> None:
-        vrc = VarRefCollector(ignore_duplicated_handles=True)
+        vrc = VarRefCollector(ignore_duplicated_handles=True, unevaluated=True)
         vrc.visit(ast.parse(expression.expr))
         self.handles.extend(vrc.var_handles)
 

classiq/model_expansions/visitors/symbolic_param_inference.py

@@ -0,0 +1,197 @@
+import ast
+from collections.abc import Iterator, Mapping, Sequence
+from contextlib import contextmanager
+from itertools import chain, zip_longest
+from typing import Optional, cast
+
+from classiq.interface.generator.expressions.atomic_expression_functions import (
+    CLASSICAL_ATTRIBUTES,
+)
+from classiq.interface.generator.expressions.expression import Expression
+from classiq.interface.generator.functions.classical_type import ClassicalType
+from classiq.interface.generator.functions.type_name import TypeName
+from classiq.interface.helpers.pydantic_model_helpers import nameables_to_dict
+from classiq.interface.model.classical_parameter_declaration import (
+    AnonClassicalParameterDeclaration,
+)
+from classiq.interface.model.handle_binding import FieldHandleBinding, HandleBinding
+from classiq.interface.model.model_visitor import ModelVisitor
+from classiq.interface.model.native_function_definition import NativeFunctionDefinition
+from classiq.interface.model.quantum_function_call import ArgValue, QuantumFunctionCall
+from classiq.interface.model.quantum_function_declaration import (
+    AnonPositionalArg,
+    AnonQuantumFunctionDeclaration,
+    AnonQuantumOperandDeclaration,
+    NamedParamsQuantumFunctionDeclaration,
+    QuantumOperandDeclaration,
+)
+from classiq.interface.model.quantum_lambda_function import (
+    OperandIdentifier,
+    QuantumLambdaFunction,
+)
+
+from classiq.model_expansions.visitors.variable_references import VarRefCollector
+
+
+def _get_expressions(arg: ArgValue) -> list[Expression]:
+    if isinstance(arg, Expression):
+        return [arg]
+    if isinstance(arg, HandleBinding):
+        return arg.expressions()
+    if isinstance(arg, OperandIdentifier):
+        return [arg.index]
+    if isinstance(arg, list):
+        return list(chain.from_iterable(_get_expressions(item) for item in arg))
+    return []
+
+
+def _get_param_expressions(param: AnonPositionalArg) -> list[Expression]:
+    if isinstance(param, AnonClassicalParameterDeclaration):
+        return param.classical_type.expressions
+    if isinstance(param, AnonQuantumOperandDeclaration):
+        return list(
+            chain.from_iterable(
+                _get_param_expressions(nested_param)
+                for nested_param in param.positional_arg_declarations
+            )
+        )
+    return param.quantum_type.expressions
+
+
+class SymbolicParamInference(ModelVisitor):
+    def __init__(
+        self,
+        functions: list[NativeFunctionDefinition],
+        additional_signatures: (
+            list[NamedParamsQuantumFunctionDeclaration] | None
+        ) = None,
+    ) -> None:
+        self._functions = nameables_to_dict(functions)
+        self._additional_signatures = (
+            {}
+            if additional_signatures is None
+            else nameables_to_dict(additional_signatures)
+        )
+        self._inferred_funcs: set[str] = set()
+        self._call_stack: list[str] = []
+        self._scope: Mapping[str, ClassicalType] = {}
+        self._scope_operands: dict[str, QuantumOperandDeclaration] = {}
+
+    def infer(self) -> None:
+        for func in self._functions.values():
+            self._infer_func_params(func)
+
+    def _is_recursive_call(self, func: str) -> bool:
+        return func in self._call_stack
+
+    @contextmanager
+    def function_context(
+        self,
+        func_name: Optional[str],
+        scope: Mapping[str, ClassicalType],
+        scope_operands: dict[str, QuantumOperandDeclaration],
+    ) -> Iterator[None]:
+        if func_name is not None:
+            self._call_stack.append(func_name)
+        prev_scope = self._scope
+        self._scope = scope
+        prev_scope_ops = self._scope_operands
+        self._scope_operands = scope_operands
+        yield
+        self._scope = prev_scope
+        self._scope_operands = prev_scope_ops
+        if func_name is not None:
+            self._call_stack.pop()
+
+    def _infer_func_params(self, func: NativeFunctionDefinition) -> None:
+        if func.name in self._inferred_funcs:
+            return
+        scope = {param.name: param.classical_type for param in func.param_decls}
+        scope_operands = func.operand_declarations_dict
+        with self.function_context(func.name, scope, scope_operands):
+            for param in func.positional_arg_declarations:
+                for expr in _get_param_expressions(param):
+                    self._process_compile_time_expression(expr.expr)
+            self._set_enums_generative(func)
+            self.visit(func.body)
+        self._inferred_funcs.add(func.name)
+
+    def _set_enums_generative(self, decl: AnonQuantumFunctionDeclaration) -> None:
+        for param in decl.positional_arg_declarations:
+            if (
+                isinstance(param, AnonClassicalParameterDeclaration)
+                and param.name is not None
+                and isinstance(param.classical_type, TypeName)
+                and param.classical_type.is_enum
+            ):
+                self._scope[param.name].set_generative()
+
+    def visit_QuantumLambdaFunction(self, func: QuantumLambdaFunction) -> None:
+        func.set_op_decl(func.func_decl.model_copy(deep=True))
+        scope = dict(self._scope) | {
+            cast(str, param.name): param.classical_type
+            for param in func.named_func_decl.param_decls
+        }
+        scope_operands = self._scope_operands | nameables_to_dict(
+            cast(
+                Sequence[QuantumOperandDeclaration],
+                func.named_func_decl.operand_declarations,
+            )
+        )
+        with self.function_context(None, scope, scope_operands):
+            self._set_enums_generative(func.named_func_decl)
+            self.visit(func.body)
+
+    def visit_QuantumFunctionCall(self, call: QuantumFunctionCall) -> None:
+        self._process_compile_time_expressions(call.function)
+        name = call.func_name
+        if self._is_recursive_call(name):
+            return  # Recursion is not fully supported
+        params = self._get_params(call)
+        for param, arg in zip_longest(params, call.positional_args):
+            if (
+                not isinstance(param, AnonClassicalParameterDeclaration)
+                or param.classical_type.is_generative
+            ):
+                self._process_compile_time_expressions(arg)
+            else:
+                for expr in _get_expressions(arg):
+                    self._process_nested_compile_time_expression(expr.expr)
+        self.generic_visit(call)
+
+    def _get_params(self, call: QuantumFunctionCall) -> Sequence[AnonPositionalArg]:
+        name = call.func_name
+        if name in self._scope_operands:
+            return self._scope_operands[name].positional_arg_declarations
+        elif name in self._functions:
+            func = self._functions[name]
+            self._infer_func_params(func)
+            return func.positional_arg_declarations
+        elif name in self._additional_signatures:
+            return self._additional_signatures[name].positional_arg_declarations
+        return call.func_decl.positional_arg_declarations
+
+    def _process_compile_time_expressions(self, arg: ArgValue) -> None:
+        for expr in _get_expressions(arg):
+            self._process_compile_time_expression(expr.expr)
+
+    def _process_compile_time_expression(self, expr: str) -> None:
+        vrc = VarRefCollector(
+            ignore_duplicated_handles=True, ignore_sympy_symbols=True, unevaluated=True
+        )
+        vrc.visit(ast.parse(expr))
+        for handle in vrc.var_handles:
+            if handle.name in self._scope and (
+                not isinstance(handle, FieldHandleBinding)
+                or handle.field not in CLASSICAL_ATTRIBUTES
+            ):
+                self._scope[handle.name].set_generative()
+
+    def _process_nested_compile_time_expression(self, expr: str) -> None:
+        vrc = VarRefCollector(
+            ignore_duplicated_handles=True, ignore_sympy_symbols=True, unevaluated=True
+        )
+        vrc.visit(ast.parse(expr))
+        for handle in vrc.var_handles:
+            for nested_expr in handle.expressions():
+                self._process_compile_time_expression(nested_expr.expr)

classiq/model_expansions/visitors/variable_references.py

@@ -95,16 +95,25 @@ class VarRefCollector(ast.NodeVisitor):
     def visit_Attribute(self, node: ast.Attribute) -> Optional[FieldHandleBinding]:
         return self._get_field_handle(node.value, node.attr)
 
-    def visit_Call(self, node: ast.Call) -> Optional[FieldHandleBinding]:
-        if (
-            not isinstance(node.func, ast.Name)
-            or node.func.id != "get_field"
-            or len(node.args) != 2
-            or not isinstance(node.args[1], ast.Constant)
-            or not isinstance(node.args[1].value, str)
-        ):
+    def visit_Call(self, node: ast.Call) -> Optional[HandleBinding]:
+        if not isinstance(node.func, ast.Name):
             return self.generic_visit(node)
-        return self._get_field_handle(node.args[0], node.args[1].value)
+        if node.func.id == "get_field":
+            if (
+                len(node.args) != 2
+                or not isinstance(node.args[1], ast.Constant)
+                or not isinstance(node.args[1].value, str)
+            ):
+                raise ClassiqInternalExpansionError("Unexpected 'get_field' arguments")
+            return self._get_field_handle(node.args[0], node.args[1].value)
+        if node.func.id == "do_subscript":
+            if len(node.args) != 2:
+                raise ClassiqInternalExpansionError(
+                    "Unexpected 'do_subscript' arguments"
+                )
+            self.visit(node.args[1])
+            return self._get_subscript_handle(node.args[0], node.args[1])
+        return self.generic_visit(node)
 
     def _get_field_handle(
         self, subject: ast.expr, field: str
@@ -121,6 +130,33 @@ class VarRefCollector(ast.NodeVisitor):
             self._var_handles[handle] = True
         return handle
 
+    def _get_subscript_handle(
+        self, subject: ast.expr, subscript: ast.expr
+    ) -> Optional[HandleBinding]:
+        with self.set_nested():
+            base_handle = self.visit(subject)
+        if base_handle is None:
+            return None
+        handle: HandleBinding
+        if isinstance(subscript, ast.Slice):
+            if subscript.lower is None or subscript.upper is None:
+                raise ClassiqExpansionError(
+                    f"{str(base_handle)!r} slice must specify both lower and upper bounds"
+                )
+            handle = SlicedHandleBinding(
+                base_handle=base_handle,
+                start=Expression(expr=ast.unparse(subscript.lower)),
+                end=Expression(expr=ast.unparse(subscript.upper)),
+            )
+        else:
+            handle = SubscriptHandleBinding(
+                base_handle=base_handle,
+                index=Expression(expr=ast.unparse(subscript)),
+            )
+        if not self._is_nested:
+            self._var_handles[handle] = True
+        return handle
+
     def visit_Name(self, node: ast.Name) -> Optional[HandleBinding]:
         if not self._ignore_sympy_symbols and node.id in set(
             SYMPY_SUPPORTED_EXPRESSIONS

classiq/qmod/builtins/functions/allocation.py

@@ -2,11 +2,11 @@ from typing import Literal
 
 from classiq.qmod.qfunc import qfunc
 from classiq.qmod.qmod_parameter import CArray, CReal
-from classiq.qmod.qmod_variable import Input, Output, QArray, QBit
+from classiq.qmod.qmod_variable import Input, Output, QArray, QBit, QFree
 
 
 @qfunc(external=True)
-def free(in_: Input[QArray[QBit]]) -> None:
+def free(in_: QFree[Input[QArray[QBit]]]) -> None:
     """
     [Qmod core-library function]
 

classiq/qmod/builtins/functions/arithmetic.py

@@ -2,7 +2,7 @@ from typing import Literal
 
 from classiq.qmod.qfunc import qfunc
 from classiq.qmod.qmod_parameter import CArray, CBool, CReal
-from classiq.qmod.qmod_variable import Output, QArray, QBit, QNum
+from classiq.qmod.qmod_variable import Const, Output, QArray, QBit, QFree, QNum
 
 
 @qfunc(external=True)
@@ -24,13 +24,15 @@ def unitary(
 
 @qfunc(external=True)
 def add(
-    left: QNum,
-    right: QNum,
-    result: Output[
-        QNum[
-            Literal["result_size"],
-            Literal["result_is_signed"],
-            Literal["result_fraction_places"],
+    left: Const[QNum],
+    right: Const[QNum],
+    result: QFree[
+        Output[
+            QNum[
+                Literal["result_size"],
+                Literal["result_is_signed"],
+                Literal["result_fraction_places"],
+            ]
         ]
     ],
     result_size: CReal,
@@ -41,20 +43,20 @@ def add(
 
 
 @qfunc(external=True)
-def modular_add(left: QArray[QBit], right: QArray[QBit]) -> None:
+def modular_add(left: Const[QArray[QBit]], right: QFree[QArray[QBit]]) -> None:
     pass
 
 
 @qfunc(external=True)
-def modular_add_constant(left: CReal, right: QNum) -> None:
+def modular_add_constant(left: CReal, right: QFree[QNum]) -> None:
     pass
 
 
 @qfunc(external=True)
-def integer_xor(left: QArray[QBit], right: QArray[QBit]) -> None:
+def integer_xor(left: Const[QArray[QBit]], right: QFree[QArray[QBit]]) -> None:
     pass
 
 
 @qfunc(external=True)
-def real_xor_constant(left: CReal, right: QNum) -> None:
+def real_xor_constant(left: CReal, right: QFree[QNum]) -> None:
     pass