classiq 0.90.0__py3-none-any.whl → 0.91.0__py3-none-any.whl

classiq/model_expansions/interpreters/generative_interpreter.py

@@ -11,6 +11,7 @@ from classiq.interface.generator.functions.builtins.internal_operators import (
     CLASSICAL_IF_OPERATOR_NAME,
     CONTROL_OPERATOR_NAME,
     INVERT_OPERATOR_NAME,
+    POWER_OPERATOR_NAME,
     REPEAT_OPERATOR_NAME,
     WITHIN_APPLY_NAME,
 )
@@ -108,6 +109,7 @@ class GenerativeInterpreter(BaseInterpreter):
         self.infer_symbolic_parameters(
             model.functions, [gen_func.func_decl for gen_func in generative_functions]
         )
+        self._symbolic_parameters_switch = self.allow_symbolic_parameters()
 
     def infer_symbolic_parameters(
         self,
@@ -118,6 +120,9 @@ class GenerativeInterpreter(BaseInterpreter):
     ) -> None:
         pass
 
+    def allow_symbolic_parameters(self) -> bool:
+        return True
+
     def evaluate_lambda(self, function: QuantumLambdaFunction) -> Evaluated:
         func_decl = NamedParamsQuantumFunctionDeclaration(
             name=self._counted_name_allocator.allocate(
@@ -164,18 +169,28 @@ class GenerativeInterpreter(BaseInterpreter):
         QuantumFunctionCallEmitter(self).emit(call)
 
     @emit.register
-    def _emit_allocate(self, allocate: Allocate) -> None:
-        return self.emit_allocate(allocate)
-
     def emit_allocate(self, allocate: Allocate) -> None:
-        AllocateEmitter(self).emit(allocate)
+        CompositeEmitter[Allocate](
+            self,
+            [
+                ExpressionEvaluator(
+                    self,
+                    "size",
+                    readable_expression_name="allocation size",
+                    allow_link_time_vars=self._symbolic_parameters_switch,
+                    allow_runtime_vars=self._symbolic_parameters_switch,
+                ),
+                AllocateEmitter(
+                    self, allow_symbolic_attrs=self._symbolic_parameters_switch
+                ),
+            ],
+        ).emit(allocate)
 
     @emit.register
-    def _emit_bind(self, bind: BindOperation) -> None:
-        self.emit_bind(bind)
-
     def emit_bind(self, bind: BindOperation) -> None:
-        BindEmitter(self).emit(bind)
+        BindEmitter(self, allow_symbolic_size=self._symbolic_parameters_switch).emit(
+            bind
+        )
 
     @emit.register
     def emit_amplitude_loading_operation(self, op: AmplitudeLoadingOperation) -> None:
@@ -184,7 +199,12 @@ class GenerativeInterpreter(BaseInterpreter):
             [
                 HandleEvaluator(self, "result_var"),
                 ExpressionEvaluator(
-                    self, "expression", simplify=True, treat_qnum_as_float=True
+                    self,
+                    "expression",
+                    readable_expression_name="amplitude-encoding expression",
+                    simplify=True,
+                    treat_qnum_as_float=True,
+                    allow_runtime_vars=self._symbolic_parameters_switch,
                 ),
                 AssignmentResultProcessor(self),
             ],
@@ -223,14 +243,16 @@ class GenerativeInterpreter(BaseInterpreter):
         VariableDeclarationStatementEmitter(self).emit(variable_declaration)
 
     @emit.register
-    def _emit_classical_if(self, classical_if: ClassicalIf) -> None:
-        self.emit_classical_if(classical_if)
-
     def emit_classical_if(self, classical_if: ClassicalIf) -> None:
         CompositeEmitter[ClassicalIf](
             self,
             [
-                ExpressionEvaluator(self, "condition"),
+                ExpressionEvaluator(
+                    self,
+                    "condition",
+                    readable_expression_name="classical-if condition",
+                    allow_link_time_vars=self._symbolic_parameters_switch,
+                ),
                 IfElimination(self),
                 BlockEvaluator(
                     self,
@@ -278,7 +300,14 @@ class GenerativeInterpreter(BaseInterpreter):
         CompositeEmitter[Control](
             self,
             [
-                ExpressionEvaluator(self, "expression", simplify=True),
+                ExpressionEvaluator(
+                    self,
+                    "expression",
+                    simplify=True,
+                    readable_expression_name="control expression",
+                    allow_link_time_vars=self._symbolic_parameters_switch,
+                    allow_runtime_vars=self._symbolic_parameters_switch,
+                ),
                 BlockEvaluator(
                     self,
                     CONTROL_OPERATOR_NAME,
@@ -293,8 +322,13 @@ class GenerativeInterpreter(BaseInterpreter):
         CompositeEmitter[Power](
             self,
             [
-                ExpressionEvaluator(self, "power"),
-                BlockEvaluator(self, CONTROL_OPERATOR_NAME, "body"),
+                ExpressionEvaluator(
+                    self,
+                    "power",
+                    readable_expression_name="power exponent",
+                    allow_runtime_vars=self._symbolic_parameters_switch,
+                ),
+                BlockEvaluator(self, POWER_OPERATOR_NAME, "body"),
             ],
         ).emit(power)
 
@@ -303,8 +337,19 @@ class GenerativeInterpreter(BaseInterpreter):
         CompositeEmitter[PhaseOperation](
             self,
             [
-                ExpressionEvaluator(self, "expression", simplify=True),
-                ExpressionEvaluator(self, "theta"),
+                ExpressionEvaluator(
+                    self,
+                    "expression",
+                    readable_expression_name="phase expression",
+                    simplify=True,
+                    allow_runtime_vars=self._symbolic_parameters_switch,
+                ),
+                ExpressionEvaluator(
+                    self,
+                    "theta",
+                    readable_expression_name="phase theta expression",
+                    allow_runtime_vars=self._symbolic_parameters_switch,
+                ),
             ],
         ).emit(phase)
 

classiq/model_expansions/quantum_operations/emitter.py

@@ -45,7 +45,7 @@ from classiq.model_expansions.function_builder import (
     OperationBuilder,
     OperationContext,
 )
-from classiq.model_expansions.scope import QuantumSymbol, Scope
+from classiq.model_expansions.scope import ClassicalSymbol, QuantumSymbol, Scope
 from classiq.model_expansions.utils.counted_name_allocator import CountedNameAllocator
 from classiq.qmod.quantum_function import GenerativeQFunc
 
@@ -240,10 +240,20 @@ class Emitter(Generic[QuantumStatementT], ABC):
             dict.fromkeys(var.name for var in expr_val.get_classical_vars().values())
         )
         return [
-            (var, get_proxy_type(proxy))
+            (
+                var,
+                (
+                    get_proxy_type(proxy)
+                    if isinstance(proxy, ClassicalProxy)
+                    else proxy.classical_type
+                ),
+            )
             for var in classical_vars
             if var in self._current_scope
-            and isinstance(proxy := self._current_scope[var].value, ClassicalProxy)
+            and isinstance(
+                proxy := self._current_scope[var].value,
+                (ClassicalProxy, ClassicalSymbol),
+            )
         ]
 
     def _get_quantum_type_attributes_in_expression(

classiq/model_expansions/quantum_operations/expression_evaluator.py

@@ -1,12 +1,18 @@
-from typing import TYPE_CHECKING
+from typing import TYPE_CHECKING, Optional
 
+from classiq.interface.exceptions import (
+    ClassiqExpansionError,
+    ClassiqInternalExpansionError,
+)
 from classiq.interface.generator.expressions.expression import Expression
 from classiq.interface.generator.functions.port_declaration import (
     PortDeclarationDirection,
 )
+from classiq.interface.helpers.text_utils import readable_list, s
 from classiq.interface.model.quantum_statement import QuantumOperation
 
 from classiq.model_expansions.quantum_operations.emitter import Emitter
+from classiq.model_expansions.scope import ClassicalSymbol
 
 if TYPE_CHECKING:
     from classiq.model_expansions.interpreters.base_interpreter import BaseInterpreter
@@ -18,13 +24,23 @@ class ExpressionEvaluator(Emitter[QuantumOperation]):
         interpreter: "BaseInterpreter",
         expression_name: str,
         *,
+        readable_expression_name: Optional[str] = None,
         simplify: bool = False,
         treat_qnum_as_float: bool = False,
+        allow_link_time_vars: bool = True,
+        allow_runtime_vars: bool = True,
     ) -> None:
         super().__init__(interpreter)
         self._expression_name = expression_name
         self._simplify = simplify
         self._treat_qnum_as_float = treat_qnum_as_float
+        self._allow_link_time_vars = allow_link_time_vars
+        self._allow_runtime_vars = allow_runtime_vars
+        if (
+            not allow_link_time_vars or not allow_runtime_vars
+        ) and readable_expression_name is None:
+            raise ClassiqInternalExpansionError
+        self._readable_expression_name = readable_expression_name
 
     def emit(self, op: QuantumOperation, /) -> bool:
         expression = getattr(op, self._expression_name)
@@ -37,13 +53,41 @@ class ExpressionEvaluator(Emitter[QuantumOperation]):
         )
         for symbol in self._get_symbols_in_expression(evaluated_expression):
             self._capture_handle(symbol.handle, PortDeclarationDirection.Inout)
-        for var_name, var_type in self._get_classical_vars_in_expression(
-            evaluated_expression
-        ):
-            self._capture_classical_var(var_name, var_type)
+        self._process_classical_parameters(evaluated_expression)
         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
+
+    def _process_classical_parameters(self, evaluated_expression: Expression) -> None:
+        link_time_vars: list[str] = []
+        runtime_vars: list[str] = []
+        for var_name, var_type in self._get_classical_vars_in_expression(
+            evaluated_expression
+        ):
+            if isinstance(self._current_scope[var_name].value, ClassicalSymbol):
+                runtime_vars.append(var_name)
+            else:
+                link_time_vars.append(var_name)
+            self._capture_classical_var(var_name, var_type)
+        if not self._allow_link_time_vars and len(link_time_vars) > 0:
+            link_time_message = f"link-time variable{s(link_time_vars)} {readable_list(link_time_vars, quote=True)}"
+        else:
+            link_time_message = None
+        if not self._allow_runtime_vars and len(runtime_vars) > 0:
+            runtime_message = f"runtime variable{s(runtime_vars)} {readable_list(runtime_vars, quote=True)}"
+        else:
+            runtime_message = None
+        if link_time_message is None:
+            error_message = runtime_message
+        elif runtime_message is None:
+            error_message = link_time_message
+        else:
+            error_message = f"{link_time_message} and {runtime_message}"
+        if error_message is not None:
+            raise ClassiqExpansionError(
+                f"The {self._readable_expression_name} cannot receive "
+                f"{error_message}"
+            )

classiq/model_expansions/scope.py

@@ -3,7 +3,7 @@ from collections import UserDict
 from collections.abc import Iterator
 from dataclasses import dataclass
 from functools import singledispatch
-from typing import TYPE_CHECKING, Any, NoReturn, Optional, TypeVar, Union
+from typing import TYPE_CHECKING, Any, Optional, TypeVar, Union
 
 import sympy
 
@@ -20,7 +20,6 @@ from classiq.interface.generator.expressions.proxies.classical.qmod_struct_insta
 )
 from classiq.interface.generator.functions.classical_type import ClassicalType
 from classiq.interface.generator.functions.type_name import TypeName
-from classiq.interface.helpers.text_utils import readable_list, s
 from classiq.interface.model.handle_binding import (
     FieldHandleBinding,
     GeneralHandle,
@@ -235,29 +234,21 @@ def _evaluated_to_str_struct_literal(value: QmodStructInstance) -> str:
     return f"struct_literal({value.struct_declaration.name}, {', '.join(f'{k}={evaluated_to_str(v)}' for k, v in value.fields.items())})"
 
 
-def _raise_type_error(val: Any, t: type, location_hint: Optional[str]) -> NoReturn:
-    if isinstance(val, QmodAnnotatedExpression) and len(val.get_classical_vars()) > 0:
-        symbolic_vars = sorted(map(str, val.get_classical_vars().values()))
-        suffix = f" {location_hint}" if location_hint is not None else ""
-        raise ClassiqExpansionError(
-            f"Cannot use execution parameter{s(symbolic_vars)} {readable_list(symbolic_vars, quote=True)} in a compile-time context{suffix}"
-        )
-    raise ClassiqExpansionError(f"Invalid access to expression {val!r} as {t}")
-
-
 @dataclass(frozen=True)
 class Evaluated:  # FIXME: Merge with EvaluatedExpression if possible
     value: Any
     defining_function: Optional["FunctionClosure"] = None
 
-    def as_type(self, t: type[T], location_hint: Optional[str] = None) -> T:
+    def as_type(self, t: type[T]) -> T:
         value = self.value
         if isinstance(value, sympy.Basic):
             value = get_sympy_val(value)
         if t is int and isinstance(value, float):
             value = int(value)
         if not isinstance(value, t):
-            _raise_type_error(self.value, t, location_hint)
+            raise ClassiqExpansionError(
+                f"Invalid access to expression {self.value!r} as {t}"
+            )
 
         return value
 

classiq/model_expansions/utils/handles_collector.py

@@ -7,6 +7,7 @@ from classiq.interface.model.quantum_expressions.quantum_expression import (
     QuantumExpressionOperation,
 )
 
+from classiq.evaluators.qmod_annotated_expression import QmodAnnotatedExpression
 from classiq.model_expansions.visitors.variable_references import VarRefCollector
 
 
@@ -18,6 +19,12 @@ class _HandlesCollector(Visitor):
         self.handles.append(handle)
 
     def visit_Expression(self, expression: Expression) -> None:
+        if expression.is_evaluated():
+            expr_val = expression.value.value
+            if isinstance(expr_val, QmodAnnotatedExpression):
+                self.handles.extend(expr_val.get_classical_vars().values())
+                self.handles.extend(expr_val.get_quantum_vars().values())
+            return
         vrc = VarRefCollector(ignore_duplicated_handles=True, unevaluated=True)
         vrc.visit(ast.parse(expression.expr))
         self.handles.extend(vrc.var_handles)

classiq/qmod/builtins/operations.py

@@ -518,19 +518,23 @@ def invert(stmt_block: Union[QCallable, Callable[[], Statements]]) -> None:
 
 
 @overload
-def phase(phase_expr: Union[SymbolicExpr, float], theta: float = 1.0) -> None:
+def phase(
+    phase_expr: Union[SymbolicExpr, float], theta: Union[SymbolicExpr, float] = 1.0
+) -> None:
     pass
 
 
 @overload
-def phase(*, expr: Union[SymbolicExpr, float], theta: float = 1.0) -> None:
+def phase(
+    *, expr: Union[SymbolicExpr, float], theta: Union[SymbolicExpr, float] = 1.0
+) -> None:
     pass
 
 
 @suppress_return_value
 def phase(
     phase_expr: Union[SymbolicExpr, float, None] = None,
-    theta: float = 1.0,
+    theta: Union[SymbolicExpr, float] = 1.0,
     expr: Any = None,
 ) -> None:
     """

classiq/qmod/qmod_variable.py

@@ -31,10 +31,6 @@ from classiq.interface.exceptions import (
 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 (
-    ILLEGAL_SLICE_MSG,
-    ILLEGAL_SLICING_STEP_MSG,
-)
 from classiq.interface.generator.functions.concrete_types import ConcreteQuantumType
 from classiq.interface.generator.functions.port_declaration import (
     PortDeclarationDirection,
@@ -83,6 +79,9 @@ from classiq.qmod.utilities import (
     version_portable_get_args,
 )
 
+ILLEGAL_SLICING_STEP_MSG = "Slicing with a step of a quantum variable is not supported"
+ILLEGAL_SLICE_MSG = "Quantum array slice must be of the form [<int-value>:<int-value>]."
+
 
 @contextmanager
 def _no_current_expandable() -> Iterator[None]:

classiq/qmod/semantics/error_manager.py

@@ -18,6 +18,7 @@ class ErrorManager:
             return
         self._instantiated = True
         self._errors: list[SourceReferencedError] = []
+        self._warnings: list[SourceReferencedError] = []
         self._current_nodes_stack: list[ASTNode] = []
         self._call_stack: list[str] = []
         self._ignore_errors: bool = False
@@ -41,38 +42,56 @@ class ErrorManager:
     def annotated_errors(self) -> list[str]:
         return [str(error) for error in self._errors]
 
+    @property
+    def annotated_warnings(self) -> list[str]:
+        return [str(error) for error in self._warnings]
+
     def add_error(
         self,
         error: str,
         *,
         source_ref: Optional[SourceReference] = None,
         function: Optional[str] = None,
+        warning: bool = False,
     ) -> None:
-        if not self._ignore_errors:
-            self._errors.append(
-                SourceReferencedError(
-                    error=error.replace(CLASSIQ_SLACK_COMMUNITY_LINK, ""),
-                    source_ref=(
-                        source_ref
-                        if source_ref is not None
-                        else self._current_source_ref
-                    ),
-                    function=(
-                        function if function is not None else self.current_function
-                    ),
-                )
-            )
+        if self._ignore_errors:
+            return
+
+        source_ref_error = SourceReferencedError(
+            error=error.replace(CLASSIQ_SLACK_COMMUNITY_LINK, ""),
+            source_ref=(
+                source_ref if source_ref is not None else self._current_source_ref
+            ),
+            function=(function if function is not None else self.current_function),
+        )
+        if warning:
+            self._warnings.append(source_ref_error)
+        else:
+            self._errors.append(source_ref_error)
 
     def get_errors(self) -> list[SourceReferencedError]:
         return self._errors
 
+    def get_warnings(self) -> list[SourceReferencedError]:
+        return self._warnings
+
     def clear(self) -> None:
+        self.clear_errors()
+        self.clear_warnings()
+
+    def clear_errors(self) -> None:
         self._current_nodes_stack = []
         self._errors = []
 
+    def clear_warnings(self) -> None:
+        self._warnings = []
+
     def has_errors(self) -> bool:
         return len(self._errors) > 0
 
+    def has_warnings(self) -> bool:
+        return len(self._warnings) > 0
+
     def report_errors(
         self, error_type: type[Exception], mask: Optional[list[int]] = None
     ) -> None:
@@ -82,7 +101,7 @@ class ErrorManager:
                 if mask is None
                 else [self.annotated_errors[idx] for idx in mask]
             )
-            self.clear()
+            self.clear_errors()
             raise error_type("\n\t" + "\n\t".join(errors))
 
     @property

classiq/qmod/symbolic.py

@@ -11,9 +11,6 @@ from typing import (
 import numpy as np
 
 from classiq.interface.exceptions import ClassiqValueError
-from classiq.interface.generator.expressions.proxies.classical.any_classical_value import (
-    subscript_to_str,
-)
 
 from classiq.qmod import model_state_container
 from classiq.qmod.declaration_inferrer import python_type_to_qmod
@@ -309,12 +306,26 @@ def sum(arr: SymbolicTypes) -> CParamScalar:
     return symbolic_function(arr)
 
 
+def _subscript_to_str(index: Any) -> str:
+    if not isinstance(index, slice):
+        return str(index)
+    expr = ""
+    if index.start is not None:
+        expr += str(index.start)
+    expr += ":"
+    if index.stop is not None:
+        expr += str(index.stop)
+    if index.step is not None:
+        expr += f":{index.step}"
+    return expr
+
+
 def subscript(
     array: Union[list, CArray[CReal], np.ndarray],
     index: Any,
 ) -> CParamScalar:
     return CParamScalar(
-        expr=f"{qmod_val_to_expr_str(_unwrap_numpy(array))}[{subscript_to_str(index)}]"
+        expr=f"{qmod_val_to_expr_str(_unwrap_numpy(array))}[{_subscript_to_str(index)}]"
     )
 
 

classiq/qmod/utilities.py

@@ -29,6 +29,7 @@ from classiq.interface.generator.expressions.proxies.classical.qmod_struct_insta
 from classiq.interface.source_reference import SourceReference
 
 if TYPE_CHECKING:
+    from classiq.qmod.cparam import CParam
     from classiq.qmod.qmod_variable import QVar
 
 
@@ -162,7 +163,9 @@ def suppress_return_value(func: Callable[Params, None]) -> Callable[Params, None
     return func
 
 
-Statements = Union[None, list[Union[None, "QVar"]], tuple[Union[None, "QVar"], ...]]
+Statements = Union[
+    None, list[Union[None, "QVar", "CParam"]], tuple[Union[None, "QVar", "CParam"], ...]
+]
 
 
 def _eval_qnum(val: int, size: int, is_signed: bool, fraction_digits: int) -> float:

classiq/synthesis.py

@@ -57,8 +57,7 @@ async def synthesize_async(
 ) -> QuantumProgram:
     model = Model.model_validate_json(serialized_model)
     quantum_program = await ApiWrapper.call_generation_task(model)
-    if quantum_program.should_warn:
-        quantum_program.raise_warnings()
+    quantum_program.raise_warnings()
     return quantum_program
 
 

{classiq-0.90.0.dist-info → classiq-0.91.0.dist-info}/METADATA

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