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

classiq/model_expansions/interpreters/frontend_generative_interpreter.py

@@ -4,21 +4,42 @@ import os
 from pydantic import ValidationError
 
 from classiq.interface.exceptions import ClassiqError
+from classiq.interface.model.allocate import Allocate
+from classiq.interface.model.native_function_definition import NativeFunctionDefinition
 from classiq.interface.model.quantum_function_call import QuantumFunctionCall
+from classiq.interface.model.quantum_function_declaration import (
+    NamedParamsQuantumFunctionDeclaration,
+)
 from classiq.interface.source_reference import SourceReference
 
 from classiq.model_expansions.closure import FunctionClosure, GenerativeFunctionClosure
 from classiq.model_expansions.interpreters.generative_interpreter import (
     GenerativeInterpreter,
 )
+from classiq.model_expansions.quantum_operations.allocate import AllocateEmitter
 from classiq.model_expansions.quantum_operations.quantum_function_call import (
     DeclarativeQuantumFunctionCallEmitter,
 )
 from classiq.model_expansions.scope import Scope
+from classiq.model_expansions.visitors.symbolic_param_inference import (
+    SymbolicParamInference,
+)
 from classiq.qmod.model_state_container import QMODULE
 
 
 class FrontendGenerativeInterpreter(GenerativeInterpreter):
+    def infer_symbolic_parameters(
+        self,
+        functions: list[NativeFunctionDefinition],
+        additional_signatures: (
+            list[NamedParamsQuantumFunctionDeclaration] | None
+        ) = None,
+    ) -> None:
+        SymbolicParamInference(functions, additional_signatures).infer()
+
+    def emit_allocate(self, allocate: Allocate) -> None:
+        AllocateEmitter(self, allow_symbolic_size=True).emit(allocate)
+
     def emit_quantum_function_call(self, call: QuantumFunctionCall) -> None:
         DeclarativeQuantumFunctionCallEmitter(self).emit(call)
 

classiq/model_expansions/interpreters/generative_interpreter.py

@@ -93,6 +93,18 @@ class GenerativeInterpreter(BaseInterpreter):
         add_generative_functions_to_scope(
             generative_functions, self._top_level_scope, override_atomic=True
         )
+        self.infer_symbolic_parameters(
+            model.functions, [gen_func.func_decl for gen_func in generative_functions]
+        )
+
+    def infer_symbolic_parameters(
+        self,
+        functions: list[NativeFunctionDefinition],
+        additional_signatures: (
+            list[NamedParamsQuantumFunctionDeclaration] | None
+        ) = None,
+    ) -> None:
+        pass
 
     def evaluate_lambda(self, function: QuantumLambdaFunction) -> Evaluated:
         func_decl = NamedParamsQuantumFunctionDeclaration(

classiq/model_expansions/quantum_operations/allocate.py

@@ -1,7 +1,10 @@
+from typing import TYPE_CHECKING
+
+import sympy
+
 from classiq.interface.debug_info.debug_info import FunctionDebugInfo
 from classiq.interface.exceptions import ClassiqValueError
 from classiq.interface.generator.expressions.expression import Expression
-from classiq.interface.generator.generated_circuit_data import OperationLevel
 from classiq.interface.model.allocate import Allocate
 from classiq.interface.model.handle_binding import NestedHandleBinding
 from classiq.interface.model.quantum_type import QuantumBitvector
@@ -10,8 +13,17 @@ from classiq.model_expansions.evaluators.quantum_type_utils import copy_type_inf
 from classiq.model_expansions.quantum_operations.emitter import Emitter
 from classiq.model_expansions.scope import QuantumSymbol
 
+if TYPE_CHECKING:
+    from classiq.model_expansions.interpreters.base_interpreter import BaseInterpreter
+
 
 class AllocateEmitter(Emitter[Allocate]):
+    def __init__(
+        self, interpreter: "BaseInterpreter", allow_symbolic_size: bool = False
+    ) -> None:
+        super().__init__(interpreter)
+        self._allow_symbolic_size = allow_symbolic_size
+
     def emit(self, allocate: Allocate, /) -> bool:
         target: QuantumSymbol = self._interpreter.evaluate(allocate.target).as_type(
             QuantumSymbol
@@ -22,10 +34,10 @@ class AllocateEmitter(Emitter[Allocate]):
                 f"Cannot allocate partial quantum variable {str(target.handle)!r}"
             )
 
-        size = self._get_var_size(target, allocate.size)
+        size_expr = self._get_var_size(target, allocate.size)
         allocate = allocate.model_copy(
             update=dict(
-                size=Expression(expr=str(size)),
+                size=Expression(expr=size_expr),
                 target=target.handle,
                 back_ref=allocate.uuid,
             )
@@ -34,27 +46,29 @@ class AllocateEmitter(Emitter[Allocate]):
         self.emit_statement(allocate)
         return True
 
-    def _get_var_size(self, target: QuantumSymbol, size: Expression | None) -> int:
+    def _get_var_size(self, target: QuantumSymbol, size: Expression | None) -> str:
         if size is None:
             if not target.quantum_type.is_evaluated:
                 raise ClassiqValueError(
                     f"Could not infer the size of variable {str(target.handle)!r}"
                 )
-            return target.quantum_type.size_in_bits
+            return str(target.quantum_type.size_in_bits)
 
         size_value = self._interpreter.evaluate(size).value
+        if self._allow_symbolic_size and isinstance(size_value, sympy.Basic):
+            return str(size_value)
         if not isinstance(size_value, (int, float)):
             raise ClassiqValueError(
                 f"The number of allocated qubits must be an integer. Got "
                 f"{str(size_value)!r}"
             )
-        size_value = int(size_value)
+        size_expr = str(size_value)
         copy_type_information(
-            QuantumBitvector(length=Expression(expr=str(size_value))),
+            QuantumBitvector(length=Expression(expr=size_expr)),
             target.quantum_type,
             str(target.handle),
         )
-        return size_value
+        return size_expr
 
     def _register_debug_info(self, allocate: Allocate) -> None:
         if (
@@ -67,9 +81,6 @@ class AllocateEmitter(Emitter[Allocate]):
             parameters["num_qubits"] = allocate.size.expr
         self._debug_info[allocate.uuid] = FunctionDebugInfo(
             name="allocate",
-            parameters=parameters,
-            level=OperationLevel.QMOD_STATEMENT,
-            is_allocate_or_free=True,
             port_to_passed_variable_map={"ARG": str(allocate.target)},
             node=allocate._as_back_ref(),
         )

classiq/model_expansions/quantum_operations/assignment_result_processor.py

@@ -36,6 +36,8 @@ class AssignmentResultProcessor(Emitter[QuantumAssignmentOperation]):
 
     def _update_result_type(self, op: ArithmeticOperation) -> None:
         expr = self._evaluate_expression(op.expression)
+        if len(self._get_classical_vars_in_expression(expr)):
+            return
         symbols = self._get_symbols_in_expression(expr)
         expr_str = rename_variables(
             expr.expr,

classiq/model_expansions/quantum_operations/call_emitter.py

@@ -24,7 +24,6 @@ from classiq.interface.generator.expressions.proxies.classical.qmod_struct_insta
 from classiq.interface.generator.functions.port_declaration import (
     PortDeclarationDirection,
 )
-from classiq.interface.generator.generated_circuit_data import OperationLevel
 from classiq.interface.model.classical_parameter_declaration import (
     ClassicalParameterDeclaration,
 )
@@ -63,7 +62,6 @@ from classiq.model_expansions.quantum_operations.emitter import (
 from classiq.model_expansions.scope import Evaluated, QuantumSymbol, Scope
 from classiq.model_expansions.transformers.var_splitter import VarSplitter
 from classiq.model_expansions.utils.text_utils import are, readable_list, s
-from classiq.qmod.builtins.functions import free
 from classiq.qmod.semantics.validation.signature_validation import (
     validate_function_signature,
 )
@@ -188,7 +186,6 @@ class CallEmitter(Generic[QuantumStatementT], Emitter[QuantumStatementT], VarSpl
             positional_args=new_positional_args,
             back_ref=self._get_back_ref(propagated_debug_info),
         )
-        is_allocate_or_free = new_call.func_name == free.func_decl.name
 
         port_to_passed_variable_map = {
             arg_decl.name: str(evaluated_arg.value.handle)
@@ -197,8 +194,6 @@ class CallEmitter(Generic[QuantumStatementT], Emitter[QuantumStatementT], VarSpl
         }
         self._debug_info[new_call.uuid] = FunctionDebugInfo(
             name=new_call.func_name,
-            level=OperationLevel.QMOD_FUNCTION_CALL,
-            is_allocate_or_free=is_allocate_or_free,
             port_to_passed_variable_map=port_to_passed_variable_map,
             node=new_call._as_back_ref(),
         )

classiq/model_expansions/quantum_operations/emitter.py

@@ -13,7 +13,6 @@ import sympy
 
 from classiq.interface.debug_info.debug_info import (
     DebugInfoCollection,
-    new_function_debug_info_by_node,
 )
 from classiq.interface.exceptions import ClassiqInternalExpansionError
 from classiq.interface.generator.expressions.evaluated_expression import (
@@ -161,10 +160,7 @@ class Emitter(Generic[QuantumStatementT], ABC):
         self._update_captured_classical_vars(statement)
         if isinstance(statement, QuantumOperation):
             self._update_captured_vars(statement)
-        if statement.uuid not in self._interpreter._model.debug_info:
-            self._interpreter._model.debug_info[statement.uuid] = (
-                new_function_debug_info_by_node(statement)  # type:ignore[arg-type]
-            )
+        self._interpreter.add_to_debug_info(statement)
         self._builder.emit_statement(statement)
 
     def _update_captured_classical_vars(self, stmt: QuantumStatement) -> None:

classiq/model_expansions/quantum_operations/expression_evaluator.py

@@ -33,5 +33,6 @@ class ExpressionEvaluator(Emitter[QuantumOperation]):
         op = op.model_copy(
             update={self._expression_name: evaluated_expression, "back_ref": op.uuid}
         )
+        self._interpreter.add_to_debug_info(op)
         self._interpreter.emit(op)
         return True

classiq/model_expansions/quantum_operations/handle_evaluator.py

@@ -24,5 +24,6 @@ class HandleEvaluator(Emitter[QuantumOperation]):
         op = op.model_copy(
             update={self._handle_name: evaluated_handle, "back_ref": op.uuid}
         )
+        self._interpreter.add_to_debug_info(op)
         self._interpreter.emit(op)
         return True

classiq/model_expansions/transformers/model_renamer.py

@@ -92,7 +92,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/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/qmod/qmod_variable.py

@@ -22,7 +22,12 @@ from typing import (  # type: ignore[attr-defined]
 
 from typing_extensions import ParamSpec, Self, _AnnotatedAlias
 
-from classiq.interface.exceptions import ClassiqInternalError, ClassiqValueError
+from classiq.interface.exceptions import (
+    ClassiqInternalError,
+    ClassiqNotImplementedError,
+    ClassiqValueError,
+)
+from classiq.interface.generator.arith.register_user_input import RegisterArithmeticInfo
 from classiq.interface.generator.expressions.expression import Expression
 from classiq.interface.generator.expressions.non_symbolic_expr import NonSymbolicExpr
 from classiq.interface.generator.expressions.proxies.quantum.qmod_qarray_proxy import (
@@ -340,6 +345,23 @@ class QNum(Generic[_P], QScalar):
                 return interpret_expression(str(self.is_signed))
         return CParamScalar(f"get_field({self}, 'is_signed')")
 
+    def get_maximal_bounds(self) -> tuple[float, float]:
+        if not is_generative_mode():
+            raise ClassiqNotImplementedError(
+                "get_maximal_bounds() is supported in generative mode only"
+            )
+
+        if TYPE_CHECKING:
+            assert isinstance(self.size, int)
+            assert isinstance(self.is_signed, bool)
+            assert isinstance(self.fraction_digits, int)
+
+        return RegisterArithmeticInfo.get_maximal_bounds(
+            size=self.size,
+            is_signed=self.is_signed,
+            fraction_places=self.fraction_digits,
+        )
+
     # Support comma-separated generic args in older Python versions
     if sys.version_info[0:2] < (3, 10):
 

classiq/qmod/symbolic_expr.py

@@ -4,6 +4,8 @@ import ast
 from enum import Enum as PythonEnum
 from typing import Any
 
+import sympy
+
 from classiq.qmod.utilities import qmod_val_to_expr_str
 
 
@@ -33,10 +35,14 @@ class SymbolicExpr(Symbolic):
 
     @staticmethod
     def _binary_op(lhs: Any, rhs: Any, op: str) -> SymbolicExpr:
-        if not isinstance(lhs, (SymbolicExpr, int, float, bool, PythonEnum)):
+        if not isinstance(
+            lhs, (SymbolicExpr, int, float, bool, PythonEnum, sympy.Basic)
+        ):
             raise TypeError(f"Invalid lhs argument {lhs!r} for binary operation {op!r}")
 
-        if not isinstance(rhs, (SymbolicExpr, int, float, bool, PythonEnum)):
+        if not isinstance(
+            rhs, (SymbolicExpr, int, float, bool, PythonEnum, sympy.Basic)
+        ):
             raise TypeError(f"Invalid lhs argument {rhs!r} for binary operation {op!r}")
 
         lhs_str = qmod_val_to_expr_str(lhs)

classiq/qmod/write_qmod.py

@@ -1,6 +1,6 @@
 import json
 from pathlib import Path
-from typing import Optional, Union
+from typing import Any, Optional, Union
 
 from classiq.interface.model.model import Model, SerializedModel
 
@@ -17,6 +17,8 @@ def write_qmod(
     name: str,
     directory: Optional[Path] = None,
     decimal_precision: int = DEFAULT_DECIMAL_PRECISION,
+    *args: Any,
+    **kwargs: Any,
 ) -> None:
     """
     Creates a native Qmod file from a serialized model and outputs the synthesis options (Preferences and Constraints) to a file.
@@ -27,6 +29,8 @@ def write_qmod(
         name: The name to save the file by.
         directory: The directory to save the files in. If None, the current working directory is used.
         decimal_precision: The number of decimal places to use for numbers, set to 4 by default.
+        args: (placeholder)
+        kwargs: (placeholder)
 
     Returns:
         None

{classiq-0.74.0.dist-info → classiq-0.75.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: classiq
-Version: 0.74.0
+Version: 0.75.0
 Summary: Classiq's Python SDK for quantum computing
 License: Proprietary
 Keywords: quantum computing,quantum circuits,quantum algorithms,QAD,QDL