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

classiq/interface/generator/copy.py

@@ -0,0 +1,47 @@
+from typing import Optional
+
+import pydantic
+
+from classiq.interface.generator.arith import argument_utils
+from classiq.interface.generator.arith.register_user_input import RegisterArithmeticInfo
+from classiq.interface.generator.function_params import FunctionParams
+
+
+class Copy(FunctionParams):
+    source: argument_utils.RegisterOrConst
+    target: RegisterArithmeticInfo
+    output_size: Optional[pydantic.PositiveInt] = pydantic.Field(default=None)
+
+    @property
+    def source_size(self) -> int:
+        return argument_utils.size(self.source)
+
+    @property
+    def source_reg_size(self) -> int:
+        return (
+            self.source.size if isinstance(self.source, RegisterArithmeticInfo) else 0
+        )
+
+    @property
+    def source_fraction_places(self) -> int:
+        return argument_utils.fraction_places(self.source)
+
+    @property
+    def offset(self) -> int:
+        return self.target.fraction_places - self.source_fraction_places
+
+    @property
+    def source_name(self) -> str:
+        return "source"
+
+    @property
+    def target_name(self) -> str:
+        return "target"
+
+    def _create_ios(self) -> None:
+        self._inputs = {
+            self.target_name: self.target,
+        }
+        if isinstance(self.source, RegisterArithmeticInfo):
+            self._inputs[self.source_name] = self.source
+        self._outputs = {**self._inputs}

classiq/interface/generator/function_param_list_without_self_reference.py

@@ -28,6 +28,7 @@ from classiq.interface.generator.arith.unary_ops import BitwiseInvert, Negation,
 from classiq.interface.generator.commuting_pauli_exponentiation import (
     CommutingPauliExponentiation,
 )
+from classiq.interface.generator.copy import Copy
 from classiq.interface.generator.entangler_params import (
     GridEntangler,
     HypercubeEntangler,
@@ -148,6 +149,7 @@ function_param_library_without_self_reference: FunctionParamLibrary = (
                 PiecewiseLinearAmplitudeLoading,
                 PiecewiseLinearRotationAmplitudeLoading,
                 HadamardTransform,
+                Copy,
             },
             standard_gate_function_param_library.param_list,
             oracle_function_param_library.param_list,

classiq/interface/generator/functions/type_name.py

@@ -69,6 +69,12 @@ class TypeName(ClassicalType, QuantumType):
     def set_fields(self, fields: Mapping[str, "ConcreteQuantumType"]) -> None:
         self._assigned_fields = fields
 
+    @property
+    def is_instantiated(self) -> bool:
+        return self.has_fields and all(
+            field_type.is_instantiated for field_type in self.fields.values()
+        )
+
 
 class Enum(TypeName):
     pass

classiq/interface/generator/generated_circuit_data.py

@@ -197,14 +197,16 @@ class FunctionDebugInfoInterface(pydantic.BaseModel):
 
         updated_children: list[FunctionDebugInfoInterface] = []
         for child in self.children:
-            updated_child = child.model_copy(
-                update=dict(
-                    absolute_qubits=_get_absolute_from_relative(
-                        self.absolute_qubits, child.relative_qubits
-                    )
+            updated_child = child.white_new_absolute_qubits(self.absolute_qubits)
+            if updated_child.override_debug_info is None:
+                updated_child = updated_child.propagate_absolute_qubits()
+            else:
+                updated_child.override_debug_info = (
+                    updated_child.override_debug_info.white_new_absolute_qubits(
+                        absolute_qubits=self.absolute_qubits
+                    ).propagate_absolute_qubits()
                 )
-            )
-            updated_children.append(updated_child.propagate_absolute_qubits())
+            updated_children.append(updated_child)
 
         return self.model_copy(
             update=dict(
@@ -213,6 +215,17 @@ class FunctionDebugInfoInterface(pydantic.BaseModel):
             )
         )
 
+    def white_new_absolute_qubits(
+        self, absolute_qubits: tuple[int, ...]
+    ) -> "FunctionDebugInfoInterface":
+        return self.model_copy(
+            update=dict(
+                absolute_qubits=_get_absolute_from_relative(
+                    absolute_qubits, self.relative_qubits
+                )
+            )
+        )
+
     def inverse(self) -> "FunctionDebugInfoInterface":
         inverted_children = [child.inverse() for child in self.children[::-1]]
         return self.model_copy(
@@ -226,6 +239,8 @@ class FunctionDebugInfoInterface(pydantic.BaseModel):
 def _get_absolute_from_relative(
     absolute_qubits: tuple[int, ...], relative_qubits: tuple[int, ...]
 ) -> tuple[int, ...]:
+    if len(relative_qubits) == 0:
+        return tuple()
     if max(relative_qubits) >= len(absolute_qubits):
         _logger.warning(
             "Invalid qubit computation (relative qubits: %s, absolute qubits: %s)",

classiq/interface/generator/model/model.py

@@ -68,3 +68,6 @@ class ExecutionModel(ClassiqBaseModel):
         description="Mapping between a measured register name and its qmod type",
         default=dict(),
     )
+    register_filter_bitstrings: dict[str, list[str]] = pydantic.Field(
+        default_factory=dict,
+    )

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"
@@ -156,7 +164,12 @@ class Preferences(pydantic.BaseModel, extra="forbid"):
     )
     synthesize_all_separately: bool = pydantic.Field(
         default=False,
-        description="If true, all functions will be synthesized separately",
+        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/generator/types/compilation_metadata.py

@@ -1,5 +1,6 @@
-from pydantic import BaseModel, Field
+from pydantic import BaseModel, Field, NonNegativeInt
 
 
 class CompilationMetadata(BaseModel):
     should_synthesize_separately: bool = Field(default=False)
+    occurrences_number: NonNegativeInt = Field(default=1)

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

@@ -1,6 +1,5 @@
 import dataclasses
-from collections.abc import Iterator, Sequence
-from contextlib import contextmanager
+from collections.abc import Sequence
 from dataclasses import dataclass, field
 from typing import TYPE_CHECKING, Optional
 
@@ -9,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,
 )
@@ -105,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:
@@ -146,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)
@@ -205,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)
@@ -277,11 +359,8 @@ class CapturedVars:
             if not captured_handle.is_propagated
         }
 
-    @contextmanager
-    def freeze(self) -> Iterator[None]:
-        previous = self._captured_handles
-        yield
-        self._captured_handles = previous
+    def clone(self) -> "CapturedVars":
+        return CapturedVars(_captured_handles=list(self._captured_handles))
 
 
 def _same_closure(closure_1: "FunctionClosure", closure_2: "FunctionClosure") -> bool:
@@ -311,7 +390,9 @@ def validate_args_are_not_propagated(
         )
 
 
-def validate_captured_directions(captured_vars: CapturedVars) -> None:
+def validate_captured_directions(
+    captured_vars: CapturedVars, report_outin: bool = True
+) -> None:
     captured_inputs = [
         captured_handle.handle.name
         for captured_handle in captured_vars._captured_handles
@@ -320,7 +401,12 @@ def validate_captured_directions(captured_vars: CapturedVars) -> None:
     captured_outputs = [
         captured_handle.handle.name
         for captured_handle in captured_vars._captured_handles
-        if captured_handle.direction == PortDirection.Output
+        if captured_handle.direction
+        in (
+            (PortDirection.Output, PortDirection.Outin)
+            if report_outin
+            else (PortDirection.Output,)
+        )
     ]
     if len(captured_inputs) > 0:
         raise ClassiqExpansionError(