classiq 0.62.0__py3-none-any.whl → 0.63.0__py3-none-any.whl

classiq/interface/generator/model/preferences/preferences.py

@@ -1,4 +1,5 @@
 from collections.abc import Sequence
+from enum import IntEnum
 from typing import TYPE_CHECKING, Annotated, Any, Optional, Union
 
 import pydantic
@@ -64,6 +65,13 @@ else:
     ]
 
 
+class OptimizationLevel(IntEnum):
+    NONE = 0
+    LIGHT = 1
+    MEDIUM = 2
+    HIGH = 3
+
+
 class TranspilationOption(StrEnum):
     NONE = "none"
     DECOMPOSE = "decompose"
@@ -157,6 +165,11 @@ class Preferences(pydantic.BaseModel, extra="forbid"):
     synthesize_all_separately: bool = pydantic.Field(
         default=False,
         description="If true, a heuristic is used to determine if a function should be synthesized separately",
+        deprecated=True,
+    )
+    optimization_level: OptimizationLevel = pydantic.Field(
+        default=OptimizationLevel.HIGH,
+        description="The optimization level used during synthesis; determines the trade-off between synthesis speed and the quality of the results",
     )
     output_format: PydanticConstrainedQuantumFormatList = pydantic.Field(
         default=[QuantumFormat.QASM],

classiq/interface/generator/quantum_function_call.py

@@ -22,7 +22,9 @@ from pydantic_core.core_schema import ValidationInfo
 from classiq.interface.exceptions import ClassiqControlError, ClassiqValueError
 from classiq.interface.generator import function_param_list, function_params as f_params
 from classiq.interface.generator.arith.arithmetic import Arithmetic
-from classiq.interface.generator.compiler_keywords import EXPANDED_KEYWORD
+from classiq.interface.generator.compiler_keywords import (
+    generate_original_function_name,
+)
 from classiq.interface.generator.control_state import ControlState
 from classiq.interface.generator.function_params import (
     NAME_REGEX,
@@ -237,7 +239,7 @@ class SynthesisQuantumFunctionCall(BaseModel):
         suffix = f"{SUFFIX_MARKER}_{randomize_suffix()}"
         if not function or params is None:
             return name if name else suffix
-        return f"{function.split(f'_{EXPANDED_KEYWORD}')[0]}_{suffix}"
+        return f"{generate_original_function_name(function)}_{suffix}"
 
     @pydantic.model_validator(mode="before")
     @classmethod

classiq/interface/model/handle_binding.py

@@ -149,8 +149,7 @@ class SubscriptHandleBinding(NestedHandleBinding):
         if (
             isinstance(other_handle, SlicedHandleBinding)
             and self.index.is_evaluated()
-            and other_handle.start.is_evaluated()
-            and other_handle.end.is_evaluated()
+            and other_handle._is_evaluated()
         ):
             return (
                 other_handle.start.to_int_value()
@@ -159,6 +158,26 @@ class SubscriptHandleBinding(NestedHandleBinding):
             )
         return False
 
+    def replace_prefix(
+        self, prefix: HandleBinding, replacement: HandleBinding
+    ) -> HandleBinding:
+        if (
+            isinstance(prefix, SlicedHandleBinding)
+            and self.base_handle == prefix.base_handle
+            and self.index.is_evaluated()
+            and prefix._is_evaluated()
+            and prefix.start.to_int_value()
+            <= self.index.to_int_value()
+            < prefix.end.to_int_value()
+        ):
+            return SubscriptHandleBinding(
+                base_handle=replacement,
+                index=Expression(
+                    expr=str(self.index.to_int_value() - prefix.start.to_int_value())
+                ),
+            )
+        return super().replace_prefix(prefix, replacement)
+
 
 class SlicedHandleBinding(NestedHandleBinding):
     start: Expression
@@ -192,7 +211,7 @@ class SlicedHandleBinding(NestedHandleBinding):
         )
 
     def _tail_overlaps(self, other_handle: "HandleBinding") -> bool:
-        if not self.start.is_evaluated() or not self.end.is_evaluated():
+        if not self._is_evaluated():
             return False
         start = self.start.to_int_value()
         end = self.end.to_int_value()
@@ -203,8 +222,7 @@ class SlicedHandleBinding(NestedHandleBinding):
             return start <= other_handle.index.to_int_value() < end
         if (
             isinstance(other_handle, SlicedHandleBinding)
-            and other_handle.start.is_evaluated()
-            and other_handle.end.is_evaluated()
+            and other_handle._is_evaluated()
         ):
             other_start = other_handle.start.to_int_value()
             other_end = other_handle.end.to_int_value()
@@ -231,6 +249,33 @@ class SlicedHandleBinding(NestedHandleBinding):
             )
         return Expression(expr=f"({self.base_handle.end})-({self.end})")
 
+    def replace_prefix(
+        self, prefix: HandleBinding, replacement: HandleBinding
+    ) -> HandleBinding:
+        if (
+            isinstance(prefix, SlicedHandleBinding)
+            and self.base_handle == prefix.base_handle
+            and self._is_evaluated()
+            and prefix._is_evaluated()
+        ):
+            prefix_start = prefix.start.to_int_value()
+            prefix_end = prefix.end.to_int_value()
+            self_start = self.start.to_int_value()
+            self_end = self.end.to_int_value()
+            if (
+                prefix_start <= self_start < prefix_end
+                and prefix_start < self_end <= prefix_end
+            ):
+                return SlicedHandleBinding(
+                    base_handle=replacement,
+                    start=Expression(expr=str(self_start - prefix_start)),
+                    end=Expression(expr=str(self_end - prefix_start)),
+                )
+        return super().replace_prefix(prefix, replacement)
+
+    def _is_evaluated(self) -> bool:
+        return self.start.is_evaluated() and self.end.is_evaluated()
+
 
 class FieldHandleBinding(NestedHandleBinding):
     field: str

classiq/interface/model/quantum_type.py

@@ -59,6 +59,10 @@ class QuantumType(HashableASTNode):
     def type_name(self) -> str:
         raise NotImplementedError
 
+    @property
+    def is_instantiated(self) -> bool:
+        raise NotImplementedError
+
 
 class QuantumScalar(QuantumType):
     def get_proxy(self, handle: "HandleBinding") -> QmodQScalarProxy:
@@ -88,6 +92,10 @@ class QuantumBit(QuantumScalar):
     def type_name(self) -> str:
         return "Quantum bit"
 
+    @property
+    def is_instantiated(self) -> bool:
+        return True
+
 
 class QuantumBitvector(QuantumType):
     element_type: "ConcreteQuantumType" = Field(
@@ -142,6 +150,10 @@ class QuantumBitvector(QuantumType):
     def type_name(self) -> str:
         return "Quantum array"
 
+    @property
+    def is_instantiated(self) -> bool:
+        return self.length is not None and self.element_type.is_instantiated
+
 
 class QuantumNumeric(QuantumScalar):
     kind: Literal["qnum"]
@@ -211,6 +223,10 @@ class QuantumNumeric(QuantumScalar):
     def type_name(self) -> str:
         return "Quantum numeric"
 
+    @property
+    def is_instantiated(self) -> bool:
+        return self.size is not None
+
 
 class RegisterQuantumType(BaseModel):
     quantum_types: "ConcreteQuantumType"

classiq/interface/server/routes.py

@@ -64,9 +64,7 @@ GENERATE_RESOURCE_ESTIMATOR_REPORT = "/resource_estimator_report"
 TASKS_SOLVE_EXACT_SUFFIX = "/tasks/solve_exact"
 
 GENERATE_HAMILTONIAN_SUFFIX = "/generate_hamiltonian"
-GENERATE_HAMILTONIAN_FULL_PATH = (
-    SYNTHESIS_NON_VERSIONED_PREFIX + GENERATE_HAMILTONIAN_SUFFIX
-)
+GENERATE_HAMILTONIAN_FULL_PATH = CHEMISTRY_PREFIX + GENERATE_HAMILTONIAN_SUFFIX
 
 CONVERSION_GENERATED_CIRCUIT_TO_EXECUTION_INPUT_SUFFIX = "/execution_input"
 CONVERSION_GENERATED_CIRCUIT_TO_EXECUTION_INPUT_FULL = (

classiq/model_expansions/capturing/captured_vars.py

@@ -8,13 +8,18 @@ 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.model.handle_binding import HandleBinding, NestedHandleBinding
+from classiq.interface.model.handle_binding import (
+    HandleBinding,
+    NestedHandleBinding,
+    SlicedHandleBinding,
+)
 from classiq.interface.model.port_declaration import PortDeclaration
 from classiq.interface.model.quantum_function_call import ArgValue
-from classiq.interface.model.quantum_type import QuantumType
+from classiq.interface.model.quantum_type import QuantumBitvector, QuantumType
 from classiq.interface.model.variable_declaration_statement import (
     VariableDeclarationStatement,
 )
@@ -104,6 +109,11 @@ class _CapturedHandle:
             return dataclasses.replace(self, is_propagated=False)
         return self
 
+    def set_symbol(
+        self, handle: HandleBinding, quantum_type: QuantumType
+    ) -> "_CapturedHandle":
+        return dataclasses.replace(self, handle=handle, quantum_type=quantum_type)
+
 
 @dataclass
 class CapturedVars:
@@ -145,23 +155,10 @@ class CapturedVars:
                 captured_handle = self._conjugate_direction(
                     existing_captured_handle, captured_handle
                 )
-            elif captured_handle.handle in existing_captured_handle.handle:
-                if existing_captured_handle.direction in (
-                    PortDirection.Input,
-                    PortDirection.Outin,
-                ):
-                    raise ClassiqInternalExpansionError(
-                        "Captured handle is already freed"
-                    )
-                captured_handle = existing_captured_handle
-            elif existing_captured_handle.handle in captured_handle.handle:
-                if captured_handle.direction in (
-                    PortDirection.Output,
-                    PortDirection.Outin,
-                ):
-                    raise ClassiqInternalExpansionError(
-                        "Captured handle is already allocated"
-                    )
+            elif captured_handle.handle.overlaps(existing_captured_handle.handle):
+                captured_handle = self._intersect_handles(
+                    existing_captured_handle, captured_handle
+                )
             else:
                 new_captured_handles.append(existing_captured_handle)
         new_captured_handles.append(captured_handle)
@@ -204,6 +201,92 @@ class CapturedVars:
             raise ClassiqInternalExpansionError("Captured handle is already freed")
         return captured_handle
 
+    def _intersect_handles(
+        self,
+        existing_captured_handle: _CapturedHandle,
+        captured_handle: _CapturedHandle,
+    ) -> _CapturedHandle:
+        if captured_handle.handle in existing_captured_handle.handle:
+            if existing_captured_handle.direction in (
+                PortDirection.Input,
+                PortDirection.Outin,
+            ):
+                raise ClassiqInternalExpansionError("Captured handle is already freed")
+            return existing_captured_handle
+
+        if existing_captured_handle.handle in captured_handle.handle:
+            if captured_handle.direction in (
+                PortDirection.Output,
+                PortDirection.Outin,
+            ):
+                raise ClassiqInternalExpansionError(
+                    "Captured handle is already allocated"
+                )
+            return captured_handle
+
+        sliced_handle, quantum_type, other_handle = self._get_sliced_handle(
+            existing_captured_handle, captured_handle
+        )
+        if not isinstance(other_handle, SlicedHandleBinding):
+            return captured_handle.set_symbol(sliced_handle, quantum_type)
+
+        merged_handle, merged_quantum_type = self._merge_sliced_handles(
+            sliced_handle, other_handle, quantum_type
+        )
+        return captured_handle.set_symbol(merged_handle, merged_quantum_type)
+
+    @staticmethod
+    def _get_sliced_handle(
+        existing_captured_handle: _CapturedHandle,
+        captured_handle: _CapturedHandle,
+    ) -> tuple[SlicedHandleBinding, QuantumBitvector, HandleBinding]:
+        handle_1 = existing_captured_handle.handle
+        quantum_type_1 = existing_captured_handle.quantum_type
+        handle_2 = captured_handle.handle
+        quantum_type_2 = captured_handle.quantum_type
+        if isinstance(handle_1, SlicedHandleBinding):
+            sliced_handle = handle_1
+            other_handle = handle_2
+            quantum_type = quantum_type_1
+        elif isinstance(handle_2, SlicedHandleBinding):
+            sliced_handle = handle_2
+            other_handle = handle_1
+            quantum_type = quantum_type_2
+        else:
+            raise ClassiqInternalExpansionError(
+                f"Unexpected overlapping handles {handle_1} and {handle_2}"
+            )
+        if not isinstance(quantum_type, QuantumBitvector):
+            raise ClassiqInternalExpansionError
+        return sliced_handle, quantum_type, other_handle
+
+    @staticmethod
+    def _merge_sliced_handles(
+        handle_1: SlicedHandleBinding,
+        handle_2: SlicedHandleBinding,
+        quantum_type: QuantumBitvector,
+    ) -> tuple[HandleBinding, QuantumBitvector]:
+        if (
+            not handle_1.start.is_evaluated()
+            or not handle_1.end.is_evaluated()
+            or not handle_2.start.is_evaluated()
+            or not handle_2.end.is_evaluated()
+        ):
+            raise ClassiqInternalExpansionError
+
+        new_start = min(handle_1.start.to_int_value(), handle_2.start.to_int_value())
+        new_end = max(handle_1.end.to_int_value(), handle_2.end.to_int_value())
+        merged_handle = SlicedHandleBinding(
+            base_handle=handle_1.base_handle,
+            start=Expression(expr=str(new_start)),
+            end=Expression(expr=str(new_end)),
+        )
+        merged_quantum_type = QuantumBitvector(
+            element_type=quantum_type.element_type,
+            length=Expression(expr=str(new_end - new_start)),
+        )
+        return merged_handle, merged_quantum_type
+
     def update(self, other_captured_vars: "CapturedVars") -> None:
         for captured_handle in other_captured_vars._captured_handles:
             self._capture_handle(captured_handle)

classiq/model_expansions/closure.py

@@ -1,27 +1,21 @@
 import dataclasses
 import json
-import uuid
 from collections.abc import Collection, Sequence
 from dataclasses import dataclass, field
 from functools import singledispatch
-from symtable import Symbol
 from typing import Any, Optional
 
 from typing_extensions import Self
 
 from classiq.interface.exceptions import ClassiqInternalExpansionError
-from classiq.interface.generator.functions.builtins.internal_operators import (
-    All_BUILTINS_OPERATORS,
-)
 from classiq.interface.model.port_declaration import PortDeclaration
 from classiq.interface.model.quantum_function_declaration import (
     NamedParamsQuantumFunctionDeclaration,
     PositionalArg,
-    QuantumOperandDeclaration,
 )
+from classiq.interface.model.quantum_lambda_function import QuantumCallable
 from classiq.interface.model.quantum_statement import QuantumStatement
 
-from classiq import ClassicalParameterDeclaration
 from classiq.model_expansions.capturing.captured_vars import CapturedVars
 from classiq.model_expansions.expression_renamer import ExpressionRenamer
 from classiq.model_expansions.scope import (
@@ -73,15 +67,7 @@ class FunctionClosure(Closure):
     # The closure is changing across the interpreter flow so it's closure_id may change
     @property
     def closure_id(self) -> str:
-        # builtins operators have side effects, so  generate a unique id for than
-        # may create a bugs. Therefore, with each call to closure_id a new id is
-        # created
-        if self.is_lambda or self.name in All_BUILTINS_OPERATORS:
-            signature = str(uuid.uuid4())
-        else:
-            signature = _generate_closure_id(
-                self.positional_arg_declarations, self.scope.data.values()
-            )
+        signature = _generate_closure_id(self.scope.data.values())
         return f"{self.name}__{signature}"
 
     @property
@@ -144,65 +130,42 @@ class FunctionClosure(Closure):
             captured_vars=self.captured_vars.clone(),
         )
 
+    def emit(self) -> QuantumCallable:
+        return self.name
+
 
 @dataclass(frozen=True)
 class GenerativeFunctionClosure(GenerativeClosure, FunctionClosure):
     pass
 
 
-def _generate_closure_id(
-    args_declaration: Sequence[PositionalArg], evaluated_args: Collection[Evaluated]
-) -> str:
-    args_signature: dict = {}
-    for arg_declara, eval_arg in zip(args_declaration, evaluated_args):
-        args_signature |= _generate_arg_id(arg_declara, eval_arg)
+def _generate_closure_id(evaluated_args: Collection[Evaluated]) -> str:
+    args_signature = [
+        _evaluated_arg_to_str(eval_arg.value) for eval_arg in evaluated_args
+    ]
     return json.dumps(args_signature)
 
 
-def _generate_arg_id(
-    arg_declaration: PositionalArg, evaluated_arg: Evaluated
-) -> dict[str, str]:
-    arg_value = evaluated_arg.value
-    arg_name = arg_declaration.name
-    if isinstance(arg_declaration, ClassicalParameterDeclaration):
-        return {arg_name: evaluated_classical_param_to_str(arg_value)}
-    if isinstance(arg_declaration, PortDeclaration):
-        return {arg_name: _evaluated_port_to_str(arg_value)}
-    if isinstance(arg_declaration, QuantumOperandDeclaration):
-        return {arg_name: _evaluated_operand_to_str(arg_value)}
-
-
+@singledispatch
 def _evaluated_arg_to_str(arg: Any) -> str:
     if isinstance(arg, str):
         return arg
-    return str(uuid.uuid4())
-
-
-@singledispatch
-def _evaluated_port_to_str(arg: Any) -> str:
-    return _evaluated_arg_to_str(arg)
+    if isinstance(arg, QuantumSymbol):
+        return _evaluated_quantum_symbol_to_str(arg)
+    if isinstance(arg, FunctionClosure):
+        return _evaluated_one_operand_to_str(arg)
+    if isinstance(arg, list) and arg and isinstance(arg[0], FunctionClosure):
+        return _evaluated_operands_list_to_str(arg)
+    return evaluated_classical_param_to_str(arg)
 
 
-@_evaluated_port_to_str.register
 def _evaluated_quantum_symbol_to_str(port: QuantumSymbol) -> str:
     return port.quantum_type.model_dump_json(exclude_none=True, exclude={"name"})
 
 
-@_evaluated_port_to_str.register
-def _evaluated_symbol_to_str(port: Symbol) -> str:
-    return repr(port)
-
-
-@singledispatch
-def _evaluated_operand_to_str(arg: Any) -> str:
-    return _evaluated_arg_to_str(arg)
-
-
-@_evaluated_operand_to_str.register
 def _evaluated_one_operand_to_str(operand: FunctionClosure) -> str:
     return operand.closure_id
 
 
-@_evaluated_operand_to_str.register
-def _evaluated_list_operands_to_str(operands: list) -> str:
-    return json.dumps([_evaluated_operand_to_str(ope) for ope in operands])
+def _evaluated_operands_list_to_str(arg: list[FunctionClosure]) -> str:
+    return json.dumps([_evaluated_one_operand_to_str(ope) for ope in arg])

classiq/model_expansions/function_builder.py

@@ -31,6 +31,7 @@ from classiq.model_expansions.capturing.captured_vars import (
 )
 from classiq.model_expansions.closure import Closure, FunctionClosure
 from classiq.model_expansions.scope import Scope
+from classiq.model_expansions.utils.counted_name_allocator import CountedNameAllocator
 
 ClosureType = TypeVar("ClosureType", bound=Closure)
 
@@ -82,11 +83,14 @@ class FunctionContext(OperationContext[FunctionClosure]):
 
 
 class OperationBuilder:
-    def __init__(self, functions_scope: Scope) -> None:
+    def __init__(
+        self, functions_scope: Scope, counted_name_allocator: CountedNameAllocator
+    ) -> None:
         self._operations: list[OperationContext] = []
         self._blocks: list[str] = []
         self._functions_scope = functions_scope
         self._current_source_ref: Optional[SourceReference] = None
+        self._counted_name_allocator = counted_name_allocator
 
     @property
     def current_operation(self) -> Closure:
@@ -198,13 +202,14 @@ class OperationBuilder:
     ) -> NativeFunctionDefinition:
         name = function_context.name
         if name != MAIN_FUNCTION_NAME:
-            idx = 0
-            new_name = name
-            while idx == 0 or new_name in self._functions_scope:
-                new_name = f"{name}_{LAMBDA_KEYWORD + '_0_0_' if function_context.is_lambda else ''}{EXPANDED_KEYWORD}_{idx}"
-                idx += 1
-            name = new_name
-
+            for _ in self.current_scope:
+                name = self._counted_name_allocator.allocate(
+                    f"{name}_{LAMBDA_KEYWORD + '_0_0_' if function_context.is_lambda else ''}{EXPANDED_KEYWORD}"
+                )
+                if name not in self.current_scope:
+                    break
+            else:
+                raise ClassiqInternalExpansionError("Could not allocate function name")
         new_parameters: list[PortDeclaration] = [
             param
             for param in function_context.positional_arg_declarations

classiq/model_expansions/generative_functions.py

@@ -105,7 +105,21 @@ class _InterpreterExpandable(QFunc):
             positional_arg_declarations=current_operation.positional_arg_declarations,
             body=self._interpreter._builder._current_statements + [stmt],
         )
-        resolve_function_calls(dummy_function, self._get_function_declarations())
+        declarative_functions = {
+            name: func
+            for name, func in self._qmodule.native_defs.items()
+            if name not in self._interpreter._top_level_scope
+        }
+        self._interpreter.update_declarative_functions(
+            declarative_functions, self._qmodule
+        )
+        self._interpreter.update_generative_functions(
+            self._qmodule.generative_functions
+        )
+        func_decls = self._get_function_declarations()
+        for dec_func in declarative_functions.values():
+            resolve_function_calls(dec_func, func_decls)
+        resolve_function_calls(dummy_function, func_decls)
         stmt = dummy_function.body[-1]
         with generative_mode_context(False):
             self._interpreter.emit_statement(stmt)