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

classiq/applications/chemistry/chemistry_model_constructor.py

@@ -53,6 +53,7 @@ from classiq.qmod.builtins.structs import (
     MoleculeProblem as QmodMoleculeProblem,
     Position as QmodPosition,
 )
+from classiq.qmod.global_declarative_switch import set_global_declarative_switch
 from classiq.qmod.utilities import qmod_val_to_expr_str
 
 # isort: split
@@ -60,6 +61,11 @@ from classiq.qmod.utilities import qmod_val_to_expr_str
 # This import causes a circular import if done earlier. We use isort: split to avoid it
 from classiq.open_library.functions.hea import full_hea
 
+with set_global_declarative_switch():
+    _FULL_HEA = cast(
+        NativeFunctionDefinition, full_hea.create_model().function_dict["full_hea"]
+    )
+
 _LADDER_OPERATOR_TYPE_INDICATOR_TO_QMOD_MAPPING: dict[str, str] = {
     "+": "PLUS",
     "-": "MINUS",
@@ -506,12 +512,7 @@ def construct_chemistry_model(
         )
     ]
     if isinstance(ansatz_parameters, HEAParameters):
-        chemistry_functions.append(
-            cast(
-                NativeFunctionDefinition,
-                full_hea.create_model().function_dict["full_hea"],
-            )
-        )
+        chemistry_functions.append(_FULL_HEA)
     model = Model(
         functions=chemistry_functions,
         classical_execution_code=_get_chemistry_classical_code(

classiq/applications/combinatorial_optimization/combinatorial_optimization_model_constructor.py

@@ -36,6 +36,14 @@ from classiq.applications.combinatorial_helpers.pauli_helpers.pauli_utils import
 )
 from classiq.applications.combinatorial_optimization import OptimizerConfig, QAOAConfig
 from classiq.open_library.functions.qaoa_penalty import qaoa_penalty
+from classiq.qmod.global_declarative_switch import set_global_declarative_switch
+
+with set_global_declarative_switch():
+    _LIBRARY_FUNCTIONS = [
+        f.model_dump()
+        for f in qaoa_penalty.create_model().functions
+        if f.name != "main"
+    ]
 
 
 def construct_combi_opt_py_model(
@@ -107,7 +115,7 @@ def construct_combi_opt_py_model(
                     ),
                 ],
             ),
-            *[f for f in qaoa_penalty.create_model().functions if f.name != "main"],
+            *_LIBRARY_FUNCTIONS,
         ],
         classical_execution_code=f"""
 vqe_result = vqe(

classiq/applications/combinatorial_optimization/combinatorial_problem.py

@@ -24,6 +24,7 @@ from classiq.open_library.functions.utility_functions import (
 from classiq.qmod.builtins.functions import RX
 from classiq.qmod.builtins.operations import allocate, phase, repeat
 from classiq.qmod.cparam import CReal
+from classiq.qmod.create_model_function import create_model
 from classiq.qmod.qfunc import qfunc
 from classiq.qmod.qmod_parameter import CArray
 from classiq.qmod.qmod_variable import Output, QVar
@@ -80,9 +81,9 @@ class CombinatorialProblem:
                 ],
             )
 
-        self.model_ = main.create_model(
-            constraints=constraints, preferences=preferences
-        ).get_model()  # type:ignore[assignment]
+        self.model_ = create_model(
+            main, constraints=constraints, preferences=preferences
+        )  # type:ignore[assignment]
         return self.model_  # type:ignore[return-value]
 
     def get_qprog(self) -> QuantumProgram:

classiq/interface/_version.py

@@ -3,5 +3,5 @@ from packaging.version import Version
 # This file was generated automatically
 # Please don't track in version control (DONTTRACK)
 
-SEMVER_VERSION = '0.76.0'
+SEMVER_VERSION = '0.77.0'
 VERSION = str(Version(SEMVER_VERSION))

classiq/interface/generator/expressions/proxies/quantum/qmod_qarray_proxy.py

@@ -1,7 +1,7 @@
 from collections.abc import Mapping
 from typing import TYPE_CHECKING, Any, Union
 
-from sympy import Integer
+import sympy
 
 from classiq.interface.exceptions import ClassiqValueError
 from classiq.interface.generator.expressions.expression import Expression
@@ -28,22 +28,20 @@ class QmodQArrayProxy(NonSymbolicExpr, QmodSizedProxy):
         self,
         handle: HandleBinding,
         element_type: "QuantumType",
-        element_size: int,
-        length: int,
+        element_size: Union[int, sympy.Basic],
+        length: Union[int, sympy.Basic],
     ) -> None:
         super().__init__(handle, element_size * length)
         self._length = length
         self._element_type = element_type
         self._element_size = element_size
 
-    def __getitem__(self, key: Union[slice, int, Integer]) -> "QmodSizedProxy":
+    def __getitem__(self, key: Any) -> "QmodSizedProxy":
         return (
             self._get_slice(key) if isinstance(key, slice) else self._get_subscript(key)
         )
 
-    def _get_subscript(self, index: Union[int, Integer]) -> "QmodSizedProxy":
-        if isinstance(index, Integer):
-            index = int(index)
+    def _get_subscript(self, index: Any) -> "QmodSizedProxy":
         return self._element_type.get_proxy(
             SubscriptHandleBinding(
                 base_handle=self.handle,
@@ -54,13 +52,6 @@ class QmodQArrayProxy(NonSymbolicExpr, QmodSizedProxy):
     def _get_slice(self, slice_: slice) -> "QmodSizedProxy":
         if slice_.step is not None:
             raise ClassiqValueError(ILLEGAL_SLICING_STEP_MSG)
-        if isinstance(slice_.start, Integer):
-            slice_ = slice(int(slice_.start), slice_.stop)
-        if isinstance(slice_.stop, Integer):
-            slice_ = slice(slice_.start, int(slice_.stop))
-        if not isinstance(slice_.start, int) or not isinstance(slice_.stop, int):
-            raise ClassiqValueError(ILLEGAL_SLICE_MSG)
-
         return QmodQArrayProxy(
             SlicedHandleBinding(
                 base_handle=self.handle,
@@ -77,7 +68,7 @@ class QmodQArrayProxy(NonSymbolicExpr, QmodSizedProxy):
         return "Quantum array"
 
     @property
-    def len(self) -> int:
+    def len(self) -> Union[int, sympy.Basic]:
         return self._length
 
     @property

classiq/interface/generator/expressions/proxies/quantum/qmod_qscalar_proxy.py

@@ -1,6 +1,7 @@
 from collections.abc import Mapping
-from typing import Any, Optional
+from typing import Any, Optional, Union
 
+import sympy
 from sympy import Symbol
 from typing_extensions import Self
 
@@ -36,10 +37,18 @@ class QmodQBitProxy(QmodQScalarProxy):
 
 class QmodQNumProxy(QmodQScalarProxy):
     def __init__(
-        self, handle: HandleBinding, size: int, fraction_digits: int, is_signed: bool
+        self,
+        handle: HandleBinding,
+        size: Union[int, sympy.Basic],
+        fraction_digits: Union[int, sympy.Basic],
+        is_signed: Union[bool, sympy.Basic],
     ) -> None:
         super().__init__(handle, size)
-        if fraction_digits > size:
+        if (
+            isinstance(fraction_digits, int)
+            and isinstance(size, int)
+            and fraction_digits > size
+        ):
             raise ClassiqValueError(
                 f"Quantum numeric of size {size} cannot have {fraction_digits} "
                 f"fraction digits"
@@ -52,11 +61,11 @@ class QmodQNumProxy(QmodQScalarProxy):
         return "Quantum numeric"
 
     @property
-    def fraction_digits(self) -> int:
+    def fraction_digits(self) -> Union[int, sympy.Basic]:
         return self._fraction_digits
 
     @property
-    def is_signed(self) -> bool:
+    def is_signed(self) -> Union[bool, sympy.Basic]:
         return self._is_signed
 
     @property

classiq/interface/generator/expressions/proxies/quantum/qmod_sized_proxy.py

@@ -1,17 +1,19 @@
 from collections.abc import Mapping
-from typing import TYPE_CHECKING, Any
+from typing import TYPE_CHECKING, Any, Union
+
+import sympy
 
 if TYPE_CHECKING:
     from classiq.interface.model.handle_binding import HandleBinding
 
 
 class QmodSizedProxy:
-    def __init__(self, handle: "HandleBinding", size: int) -> None:
+    def __init__(self, handle: "HandleBinding", size: Union[int, sympy.Basic]) -> None:
         self._handle = handle
         self._size = size
 
     @property
-    def size(self) -> int:
+    def size(self) -> Union[int, sympy.Basic]:
         return self._size
 
     def __str__(self) -> str:

classiq/interface/model/handle_binding.py

@@ -355,3 +355,11 @@ ConcreteHandleBinding = Union[
 SubscriptHandleBinding.model_rebuild()
 SlicedHandleBinding.model_rebuild()
 FieldHandleBinding.model_rebuild()
+
+
+class HandlesList(ASTNode):
+    handles: list["GeneralHandle"]
+
+
+GeneralHandle = Union[ConcreteHandleBinding, HandlesList]
+HandlesList.model_rebuild()

classiq/interface/model/model.py

@@ -1,6 +1,6 @@
 from collections import Counter
 from collections.abc import Mapping
-from typing import Any, Literal, NewType, Optional
+from typing import Any, Literal, NewType
 
 import pydantic
 
@@ -9,7 +9,6 @@ from classiq.interface.debug_info.debug_info import DebugInfoCollection
 from classiq.interface.exceptions import ClassiqValueError
 from classiq.interface.executor.execution_preferences import ExecutionPreferences
 from classiq.interface.generator.constant import Constant
-from classiq.interface.generator.functions.concrete_types import ConcreteClassicalType
 from classiq.interface.generator.functions.port_declaration import (
     PortDeclarationDirection,
 )
@@ -103,9 +102,6 @@ class Model(VersionedModel, ASTNode):
     functions_compilation_metadata: dict[str, CompilationMetadata] = pydantic.Field(
         default_factory=dict
     )
-    execution_parameters: Optional[dict[str, ConcreteClassicalType]] = pydantic.Field(
-        default=None, exclude=True
-    )
 
     @property
     def main_func(self) -> NativeFunctionDefinition:
@@ -184,11 +180,12 @@ class Model(VersionedModel, ASTNode):
             )
         return constants
 
-    def dump_no_preferences_and_constraints(self) -> dict[str, Any]:
+    def dump_no_metadata(self) -> dict[str, Any]:
         return self.model_dump(
             exclude={
                 "constraints",
                 "execution_preferences",
                 "preferences",
+                "functions_compilation_metadata",
             },
         )

classiq/interface/model/quantum_function_call.py

@@ -1,4 +1,5 @@
 from collections.abc import Iterable, Mapping, Sequence
+from itertools import chain
 from typing import (
     Literal,
     Optional,
@@ -15,7 +16,9 @@ from classiq.interface.generator.functions.port_declaration import (
 )
 from classiq.interface.model.handle_binding import (
     ConcreteHandleBinding,
+    GeneralHandle,
     HandleBinding,
+    HandlesList,
 )
 from classiq.interface.model.port_declaration import AnonPortDeclaration
 from classiq.interface.model.quantum_function_declaration import (
@@ -31,6 +34,7 @@ ArgValue = Union[
     Expression,
     QuantumOperand,
     ConcreteHandleBinding,
+    HandlesList,
 ]
 
 
@@ -146,6 +150,26 @@ class QuantumFunctionCall(QuantumOperation):
             )
         ]
 
+    @property
+    def handles_with_directions(
+        self,
+    ) -> Iterable[tuple[HandleBinding, PortDeclarationDirection]]:
+        return [(handle, param.direction) for handle, param in self.handles_with_params]
+
+    @property
+    def handles_with_params(
+        self,
+    ) -> Iterable[tuple[HandleBinding, AnonPortDeclaration]]:
+        return [
+            (handle, param)
+            for arg, param in zip(
+                self.positional_args, self.func_decl.positional_arg_declarations
+            )
+            if isinstance(param, AnonPortDeclaration)
+            and isinstance(arg, (HandleBinding, HandlesList))
+            for handle in _get_handles(arg)
+        ]
+
     @property
     def params(self) -> list[Expression]:
         return [
@@ -161,7 +185,7 @@ class QuantumFunctionCall(QuantumOperation):
         return [
             param
             for param in self.positional_args
-            if not isinstance(param, (Expression, HandleBinding))
+            if not isinstance(param, (Expression, HandleBinding, HandlesList))
         ]
 
     @property
@@ -224,3 +248,9 @@ class QuantumFunctionCall(QuantumOperation):
             f" for parameter {param_name}" if len(self.positional_args) > 1 else ""
         )
         return f"as an argument{param_text} of function {self.func_name!r}"
+
+
+def _get_handles(var: GeneralHandle) -> Iterable[HandleBinding]:
+    if isinstance(var, HandleBinding):
+        return [var]
+    return chain.from_iterable(_get_handles(item) for item in var.handles)

classiq/interface/model/quantum_statement.py

@@ -1,4 +1,4 @@
-from collections.abc import Mapping, Sequence
+from collections.abc import Iterable, Mapping, Sequence
 from dataclasses import dataclass
 from typing import Any, Callable, Optional
 from uuid import UUID, uuid4
@@ -9,6 +9,9 @@ from typing_extensions import Self
 
 from classiq.interface.ast_node import ASTNode
 from classiq.interface.generator.expressions.expression import Expression
+from classiq.interface.generator.functions.port_declaration import (
+    PortDeclarationDirection,
+)
 from classiq.interface.helpers.pydantic_model_helpers import values_with_discriminator
 from classiq.interface.model.handle_binding import (
     ConcreteHandleBinding,
@@ -90,6 +93,16 @@ class QuantumOperation(QuantumStatement):
     def readable_outputs(self) -> Sequence[HandleMetadata]:
         return [HandleMetadata(handle=handle) for handle in self.outputs]
 
+    @property
+    def handles_with_directions(
+        self,
+    ) -> Iterable[tuple[HandleBinding, PortDeclarationDirection]]:
+        return (
+            [(handle, PortDeclarationDirection.Input) for handle in self.inputs]
+            + [(handle, PortDeclarationDirection.Output) for handle in self.outputs]
+            + [(handle, PortDeclarationDirection.Inout) for handle in self.inouts]
+        )
+
     def set_generative_block(self, block_name: str, py_callable: Callable) -> None:
         self._generative_blocks[block_name] = py_callable
 

classiq/interface/source_reference.py

@@ -33,11 +33,16 @@ class SourceReference(HashablePydanticBaseModel):
     file_name: Optional[str] = pydantic.Field(default=None)
 
     def __str__(self) -> str:
-        file_string = _prepare_file_string(self.file_name) if self.file_name else ""
+        return f"{self.file_string()}{self.ref_inside_file()}"
+
+    def file_string(self) -> str:
+        return _prepare_file_string(self.file_name) if self.file_name else ""
+
+    def ref_inside_file(self) -> str:
         start_character_string = (
             f" character {self.start_column + 1}" if self.start_column > 0 else ""
         )
-        return f"{file_string}line {self.start_line + 1}{start_character_string}"
+        return f"line {self.start_line + 1}{start_character_string}"
 
 
 class SourceReferencedError(pydantic.BaseModel):

classiq/model_expansions/capturing/captured_vars.py

@@ -1,7 +1,7 @@
 import dataclasses
 from collections.abc import Sequence
 from dataclasses import dataclass, field
-from typing import TYPE_CHECKING, Callable
+from typing import TYPE_CHECKING, Callable, Union, cast
 
 from typing_extensions import Self
 
@@ -21,6 +21,7 @@ from classiq.interface.model.classical_parameter_declaration import (
 )
 from classiq.interface.model.handle_binding import (
     HandleBinding,
+    HandlesList,
     NestedHandleBinding,
     SlicedHandleBinding,
 )
@@ -254,7 +255,7 @@ class CapturedVars:
 
     def _conjugate_direction(
         self,
-        source_direction: PortDirection | bool,
+        source_direction: Union[PortDirection, bool],
         target_direction: PortDirection,
         var_name: str,
     ) -> PortDirection:
@@ -653,12 +654,9 @@ def validate_args_are_not_propagated(
         for handle in captured_vars
         if isinstance(handle, HandleBinding)
     }
-    arg_handles = {
-        demangle_handle(arg) for arg in args if isinstance(arg, HandleBinding)
-    }
     violating_handles = [
         f"{str(arg_handle)!r}"
-        for arg_handle in arg_handles
+        for arg_handle in _get_all_handles(args)
         if any(
             arg_handle.overlaps(captured_handle) for captured_handle in captured_handles
         )
@@ -669,6 +667,18 @@ def validate_args_are_not_propagated(
         )
 
 
+def _get_all_handles(args: Sequence[ArgValue]) -> set[HandleBinding]:
+    arg_handles: set[HandleBinding] = set()
+    for arg in args:
+        if isinstance(arg, HandleBinding):
+            arg_handles.add(demangle_handle(arg))
+        elif isinstance(arg, HandlesList):
+            arg_handles |= set(
+                map(demangle_handle, cast(list[HandleBinding], arg.handles))
+            )
+    return arg_handles
+
+
 def validate_captured_directions(
     captured_vars: CapturedVars, report_outin: bool = True
 ) -> None:

classiq/model_expansions/evaluators/arg_type_match.py

@@ -27,7 +27,7 @@ from classiq.interface.model.quantum_function_declaration import (
 
 from classiq.model_expansions.closure import FunctionClosure
 from classiq.model_expansions.evaluators.type_type_match import check_signature_match
-from classiq.model_expansions.scope import Evaluated, QuantumSymbol
+from classiq.model_expansions.scope import Evaluated, QuantumVariable
 from classiq.qmod.model_state_container import QMODULE
 from classiq.qmod.qmod_parameter import CInt, get_qmod_type
 
@@ -77,7 +77,7 @@ def check_arg_type_match(
 
 
 def _check_qvar_type_match(argument: Any, error_message: str) -> None:
-    if not isinstance(argument, QuantumSymbol):
+    if not isinstance(argument, QuantumVariable):
         raise ClassiqExpansionError(error_message)
 
 

classiq/model_expansions/evaluators/argument_types.py

@@ -7,7 +7,7 @@ from classiq.interface.model.port_declaration import AnonPortDeclaration
 from classiq.interface.model.quantum_function_declaration import AnonPositionalArg
 
 from classiq.model_expansions.evaluators.quantum_type_utils import copy_type_information
-from classiq.model_expansions.scope import Evaluated, QuantumSymbol
+from classiq.model_expansions.scope import Evaluated, QuantumVariable
 
 
 def add_information_from_output_arguments(
@@ -29,7 +29,7 @@ def add_information_from_output_arguments(
         if not isinstance(parameter, AnonPortDeclaration):
             continue
 
-        argument_as_quantum_symbol = argument.as_type(QuantumSymbol)
+        argument_as_quantum_symbol = argument.as_type(QuantumVariable)
 
         if parameter.direction != PortDeclarationDirection.Output:
             continue
@@ -38,6 +38,6 @@ def add_information_from_output_arguments(
             copy_type_information(
                 parameter.quantum_type,
                 argument_as_quantum_symbol.quantum_type,
-                str(argument_as_quantum_symbol.handle),
+                str(argument_as_quantum_symbol),
             )
     return args

classiq/model_expansions/evaluators/classical_expression.py

@@ -5,6 +5,9 @@ from classiq.interface.generator.expressions.evaluated_expression import (
 )
 from classiq.interface.generator.expressions.expression import Expression
 from classiq.interface.generator.expressions.expression_types import ExpressionValue
+from classiq.interface.generator.expressions.proxies.classical.any_classical_value import (
+    AnyClassicalValue,
+)
 from classiq.interface.model.handle_binding import HandleBinding
 
 from classiq.model_expansions.expression_evaluator import evaluate
@@ -19,18 +22,15 @@ def evaluate_classical_expression(expr: Expression, scope: Scope) -> Evaluated:
         if isinstance(evaluated.value, get_args(ExpressionValue))
     } | {
         name: EvaluatedExpression(
-            value=evaluated.value.quantum_type.get_proxy(HandleBinding(name=name))
+            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)
-        and evaluated.value.quantum_type.is_evaluated
-    }
-    uninitialized_locals = {
-        name
-        for name, evaluated in all_symbols
-        if isinstance(evaluated.value, QuantumSymbol)
-        and not evaluated.value.quantum_type.is_evaluated
     }
 
-    ret = evaluate(expr, locals_dict, uninitialized_locals)
+    ret = evaluate(expr, locals_dict)
     return Evaluated(value=ret.value)

classiq/model_expansions/evaluators/parameter_types.py

@@ -20,6 +20,7 @@ from classiq.interface.generator.functions.type_name import (
 from classiq.interface.model.classical_parameter_declaration import (
     ClassicalParameterDeclaration,
 )
+from classiq.interface.model.handle_binding import HandleBinding
 from classiq.interface.model.port_declaration import PortDeclaration
 from classiq.interface.model.quantum_function_declaration import (
     PositionalArg,
@@ -46,7 +47,12 @@ from classiq.model_expansions.evaluators.quantum_type_utils import (
     set_length,
     set_size,
 )
-from classiq.model_expansions.scope import Evaluated, QuantumSymbol, Scope
+from classiq.model_expansions.scope import (
+    Evaluated,
+    QuantumSymbol,
+    QuantumVariable,
+    Scope,
+)
 
 
 def evaluate_parameter_types_from_args(
@@ -83,10 +89,10 @@ def _update_scope(
         return
     if parameter.direction is PortDeclarationDirection.Output:
         return
-    quantum_symbol = argument.as_type(QuantumSymbol)
+    quantum_var = argument.as_type(QuantumVariable)
     casted_argument = _cast(
         parameter.quantum_type,
-        quantum_symbol,
+        quantum_var.quantum_type,
         parameter.name,
     )
     closure.scope[parameter.name] = Evaluated(
@@ -120,12 +126,12 @@ def _update_operand_signature_environment(
 
 
 def _cast(
-    quantum_type: QuantumType, quantum_symbol: QuantumSymbol, param_name: str
+    parameter_type: QuantumType, argument_type: QuantumType, param_name: str
 ) -> QuantumSymbol:
-    updated_quantum_type = quantum_type.model_copy()
-    _inject_quantum_arg_info_to_type(updated_quantum_type, quantum_symbol, param_name)
+    updated_quantum_type = parameter_type.model_copy()
+    _inject_quantum_arg_info_to_type(updated_quantum_type, argument_type, param_name)
     return QuantumSymbol(
-        handle=quantum_symbol.handle, quantum_type=updated_quantum_type
+        handle=HandleBinding(name=param_name), quantum_type=updated_quantum_type
     )
 
 
@@ -148,7 +154,9 @@ def _evaluate_type_from_arg(
     )
     if parameter.direction != PortDeclarationDirection.Output:
         updated_quantum_type = _inject_quantum_arg_info_to_type(
-            updated_quantum_type, argument.as_type(QuantumSymbol), parameter.name
+            updated_quantum_type,
+            argument.as_type(QuantumVariable).quantum_type,
+            parameter.name,
         )
     return parameter.model_copy(update={"quantum_type": updated_quantum_type})
 
@@ -280,11 +288,11 @@ def evaluate_types_in_quantum_symbols(
 
 
 def _inject_quantum_arg_info_to_type(
-    parameter_type: QuantumType, quantum_symbol: QuantumSymbol, param_name: str
+    parameter_type: QuantumType, argument_type: QuantumType, param_name: str
 ) -> QuantumType:
-    if quantum_symbol.quantum_type.has_size_in_bits:
+    if argument_type.has_size_in_bits:
         copy_type_information(
-            quantum_symbol.quantum_type,
+            argument_type,
             parameter_type,
             param_name,
         )

classiq/model_expansions/expression_evaluator.py

@@ -1,7 +1,7 @@
 import ast
 from collections.abc import Mapping
 from enum import EnumMeta
-from typing import Any, Optional
+from typing import Any
 
 from sympy import SympifyError, sympify
 
@@ -50,11 +50,25 @@ def evaluate_constants_as_python(constants: list[Constant]) -> dict[str, Any]:
     }
 
 
+def _quick_eval(expr: str) -> Any:
+    try:
+        return int(expr)
+    except ValueError:
+        pass
+    try:
+        return float(expr)
+    except ValueError:
+        pass
+    return None
+
+
 def evaluate(
-    expr: Expression,
-    locals_dict: Mapping[str, EvaluatedExpression],
-    uninitialized_locals: Optional[set[str]] = None,
+    expr: Expression, locals_dict: Mapping[str, EvaluatedExpression]
 ) -> EvaluatedExpression:
+    val = _quick_eval(expr.expr)
+    if val is not None:
+        return EvaluatedExpression(value=val)
+
     model_locals: dict[str, ExpressionValue] = {}
     model_locals.update(ATOMIC_EXPRESSION_FUNCTIONS)
     model_locals.update(
@@ -65,9 +79,8 @@ def evaluate(
     )
     # locals override builtin-functions
     model_locals.update({name: expr.value for name, expr in locals_dict.items()})
-    uninitialized_locals = uninitialized_locals or set()
 
-    _validate_undefined_vars(expr.expr, model_locals, uninitialized_locals)
+    _validate_undefined_vars(expr.expr, model_locals)
 
     sympy_expr = translate_to_sympy(expr.expr)
     try:
@@ -95,11 +108,8 @@ def evaluate(
 
 
 def _validate_undefined_vars(
-    expr: str,
-    model_locals: dict[str, ExpressionValue],
-    uninitialized_locals: Optional[set[str]],
+    expr: str, model_locals: dict[str, ExpressionValue]
 ) -> None:
-    uninitialized_locals = uninitialized_locals or set()
     id_visitor = _VarsCollector()
     id_visitor.visit(ast.parse(expr))
     identifiers = id_visitor.vars
@@ -108,7 +118,6 @@ def _validate_undefined_vars(
         - model_locals.keys()
         - set(SYMPY_SUPPORTED_EXPRESSIONS)
         - set(symbolic.__all__)
-        - uninitialized_locals
     )
 
     if len(undefined_vars) == 1: