classiq 0.66.0__py3-none-any.whl → 0.67.0__py3-none-any.whl

classiq/applications/finance/finance_model_constructor.py

@@ -1,3 +1,4 @@
+import warnings
 from math import floor, log
 from typing import Union
 
@@ -32,6 +33,14 @@ def construct_finance_model(
     finance_function_input: FinanceFunctionInput,
     phase_port_size: int,
 ) -> SerializedModel:
+    warnings.warn(
+        "Function 'construct_finance_model' has been deprecated and will no longer"
+        "be supported starting on 03/02/2025 the earliest\nHint: It is now possible to "
+        "implement Option Pricing in pure Qmod. For example, see the Option Pricing notebook on the "
+        "Classiq library at https://github.com/Classiq/classiq-library/blob/main/applications/finance/option_pricing/option_pricing.ipynb",
+        category=DeprecationWarning,
+        stacklevel=2,
+    )
     if isinstance(finance_model_input, LogNormalModelInput):
         finance_model = f"struct_literal(LogNormalModel, num_qubits={finance_model_input.num_qubits}, mu={finance_model_input.mu}, sigma={finance_model_input.sigma})"
         finance_function = "log_normal_finance"

classiq/applications/grover/grover_model_constructor.py

@@ -1,3 +1,5 @@
+import warnings
+
 from classiq.interface.generator.expressions.expression import Expression
 from classiq.interface.generator.functions.port_declaration import (
     PortDeclarationDirection,
@@ -90,6 +92,14 @@ def construct_grover_model(
     expression: str,
     num_reps: int = 1,
 ) -> SerializedModel:
+    warnings.warn(
+        "Function 'construct_grover_model' has been deprecated and will no longer"
+        "be supported starting on 03/02/2025 the earliest\nHint: It is now possible to "
+        "implement the Grover algorithm in pure Qmod. For example, see the Grover notebook on the "
+        "Classiq library at https://github.com/Classiq/classiq-library/blob/main/algorithms/grover/3_sat_grover/3_sat_grover.ipynb",
+        category=DeprecationWarning,
+        stacklevel=2,
+    )
     predicate_port_decls = grover_main_port_declarations(
         definitions, PortDeclarationDirection.Inout
     )

classiq/applications/qnn/qlayer.py

@@ -244,9 +244,11 @@ class QLayer(nn.Module):
 
         self.weight = Parameter(value)
 
-    @staticmethod
-    def _make_execute(quantum_program: SerializedQuantumProgram) -> ExecuteFunction:
+    def _make_execute(
+        self, quantum_program: SerializedQuantumProgram
+    ) -> ExecuteFunction:
         session = ExecutionSession(quantum_program)
+        self._session = session
 
         def execute(_ignored: Any, arguments: MultipleArguments) -> ResultsCollection:
             result: ResultsCollection = []
@@ -266,3 +268,7 @@ class QLayer(nn.Module):
             self._post_process,
             self._epsilon,
         )
+
+    def _cleanup(self) -> None:
+        if hasattr(self, "_session"):
+            self._session.close()

classiq/applications/qsvm/qsvm_model_constructor.py

@@ -1,3 +1,4 @@
+import warnings
 from typing import Any
 
 from classiq.interface.applications.qsvm import DataList, LabelsInt
@@ -92,6 +93,14 @@ def construct_qsvm_model(
     feature_map_function_name: str,
     **kwargs: Any,
 ) -> SerializedModel:
+    warnings.warn(
+        "Function 'construct_qsvm_model' has been deprecated and will no longer"
+        "be supported starting on 03/02/2025 the earliest\nHint: It is now possible to "
+        "implement QSVM in pure Qmod. For example, see the QSVM notebook on the "
+        "Classiq library at https://github.com/Classiq/classiq-library/blob/main/algorithms/qml/qsvm/qsvm.ipynb",
+        category=DeprecationWarning,
+        stacklevel=2,
+    )
     qsvm_qmod = Model(
         functions=[
             NativeFunctionDefinition(

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.66.0'
+SEMVER_VERSION = '0.67.0'
 VERSION = str(Version(SEMVER_VERSION))

classiq/interface/debug_info/debug_info.py

@@ -32,6 +32,7 @@ class FunctionDebugInfo(BaseModel):
     statement_type: Union[StatementType, None] = None
     is_allocate_or_free: bool = Field(default=False)
     is_inverse: bool = Field(default=False)
+    release_by_inverse: bool = Field(default=False)
     port_to_passed_variable_map: dict[str, str] = Field(default_factory=dict)
     node: Optional[ConcreteQuantumStatement] = None
 
@@ -86,3 +87,14 @@ class DebugInfoCollection(BaseModel):
         if (debug_info := self.get(key)) is None:
             return None
         return self.blackbox_data.get(debug_info.name)
+
+
+def new_function_debug_info_by_node(
+    node: ConcreteQuantumStatement,
+) -> FunctionDebugInfo:
+    return FunctionDebugInfo(
+        name="",
+        parameters=dict(),
+        level=OperationLevel.QMOD_STATEMENT,
+        node=node._as_back_ref(),
+    )

classiq/interface/exceptions.py

@@ -6,7 +6,8 @@ _logger = logging.getLogger(__name__)
 
 CLASSIQ_SLACK_COMMUNITY_LINK = (
     "\nIf you need further assistance, please reach out on our Community Slack channel "
-    "at: https://short.classiq.io/join-slack"
+    "at: https://short.classiq.io/join-slack or open a support ticket at: "
+    "https://classiq-community.freshdesk.com/support/tickets/new"
 )
 
 
@@ -177,10 +178,6 @@ class ClassiqExecutorInvalidHamiltonianError(ClassiqCombOptError):
         super().__init__("Invalid hamiltonian")
 
 
-class ClassiqSemanticError(ClassiqError):
-    pass
-
-
 class ClassiqDeprecationWarning(FutureWarning):
     pass
 

classiq/interface/generator/arith/argument_utils.py

@@ -91,7 +91,7 @@ def unsigned_integer_interpretation(
         int_val <<= fraction_digits_diff
 
     # extend sign bit
-    if int(value) < 0:
+    if value < 0:
         bin_val = number_utils.binary_string(int_val)
         bin_val += "1" * (register.size - len(bin_val))
         int_val = number_utils.binary_to_int(bin_val[::-1])

classiq/interface/generator/arith/arithmetic.py

@@ -32,6 +32,8 @@ ARITHMETIC_EXPRESSION_TARGET_NAME: Final[str] = "arithmetic_target"
 ARITHMETIC_EXPRESSION_RESULT_NAME: Final[str] = "expression_result"
 ARITHMETIC_EXPRESSION_GARBAGE_NAME: Final[str] = "expression_garbage"
 
+TARGET_ASSIGNMENT_ERROR = "Expression does not support target assignment"
+
 
 def is_zero(expr: str) -> bool:
     return is_constant(expr) and float(expr) == 0
@@ -60,7 +62,7 @@ class Arithmetic(ArithmeticExpressionABC):
             degree or operation_allows_target(id2op(node))
             for node, degree in graph.out_degree
         ):
-            raise ClassiqValueError("Expression does not support target assignment")
+            raise ClassiqValueError(TARGET_ASSIGNMENT_ERROR)
 
     def _create_ios(self) -> None:
         self._inputs = {

classiq/interface/generator/arith/binary_ops.py

@@ -398,6 +398,7 @@ class Subtractor(InplacableBinaryOpParams[RegisterOrConst, RegisterOrConst]):
                 right_arg=-self.effective_right_arg,
                 output_size=self.output_size,
                 inplace_arg=self.inplace_arg,
+                machine_precision=self.machine_precision,
             )
             return adder_params.garbage_output_size()
 
@@ -406,6 +407,7 @@ class Subtractor(InplacableBinaryOpParams[RegisterOrConst, RegisterOrConst]):
             output_size=self.negation_output_size,
             inplace=self.should_inplace_negation,
             bypass_bounds_validation=True,
+            machine_precision=self.machine_precision,
         )
         negation_result = negation_params.result_register
         if self.output_size is None and max(self.effective_right_arg.bounds) > 0:
@@ -425,6 +427,7 @@ class Subtractor(InplacableBinaryOpParams[RegisterOrConst, RegisterOrConst]):
             right_arg=negation_result,
             output_size=self.output_size,
             inplace_arg=self.arg_to_inplace_adder,
+            machine_precision=self.machine_precision,
         )
         negation_garbage_size = negation_params.garbage_output_size() * int(
             not self.should_uncompute_negation

classiq/interface/generator/function_param_list_without_self_reference.py

@@ -65,6 +65,7 @@ from classiq.interface.generator.piecewise_linear_amplitude_loading import (
 from classiq.interface.generator.qft import QFT
 from classiq.interface.generator.qsvm import QSVMFeatureMap
 from classiq.interface.generator.randomized_benchmarking import RandomizedBenchmarking
+from classiq.interface.generator.reset import Reset
 from classiq.interface.generator.standard_gates.standard_gates_param_list import (
     standard_gate_function_param_library,
 )
@@ -150,6 +151,7 @@ function_param_library_without_self_reference: FunctionParamLibrary = (
                 PiecewiseLinearRotationAmplitudeLoading,
                 HadamardTransform,
                 Copy,
+                Reset,
             },
             standard_gate_function_param_library.param_list,
             oracle_function_param_library.param_list,

classiq/interface/generator/functions/type_name.py

@@ -3,7 +3,7 @@ from typing import TYPE_CHECKING, Any, Literal, Optional
 
 import pydantic
 
-from classiq.interface.exceptions import ClassiqInternalError
+from classiq.interface.exceptions import ClassiqExpansionError
 from classiq.interface.generator.expressions.qmod_qstruct_proxy import QmodQStructProxy
 from classiq.interface.generator.functions.classical_type import (
     ClassicalType,
@@ -59,7 +59,7 @@ class TypeName(ClassicalType, QuantumType):
     @property
     def fields(self) -> Mapping[str, "ConcreteQuantumType"]:
         if self._assigned_fields is None:
-            raise ClassiqInternalError("Fields not set")
+            raise ClassiqExpansionError(f"Type {self.name!r} is undefined")
         return self._assigned_fields
 
     @property

classiq/interface/generator/generated_circuit_data.py

@@ -135,6 +135,7 @@ class FunctionDebugInfoInterface(pydantic.BaseModel):
     level: OperationLevel = pydantic.Field(default=OperationLevel.UNKNOWN)
     parameters: list[OperationParameter] = list()
     port_to_passed_variable_map: dict[str, str] = pydantic.Field(default={})
+    release_by_inverse: bool = pydantic.Field(default=False)
 
     model_config = ConfigDict(extra="allow")
     # Temporary field to store the override debug info for parallel old/new visualization
@@ -227,14 +228,46 @@ class FunctionDebugInfoInterface(pydantic.BaseModel):
         )
 
     def inverse(self) -> "FunctionDebugInfoInterface":
-        inverted_children = [child.inverse() for child in self.children[::-1]]
+        if self.override_debug_info is not None:
+            self.override_debug_info = self.override_debug_info.inverse()
+            return self
+        inverse_generated_function = (
+            self.generated_function.model_copy(
+                update=dict(registers=self._inverse_registers)
+            )
+            if self.generated_function
+            else None
+        )
+        inverted_children = [child.inverse() for child in reversed(self.children)]
         return self.model_copy(
             update=dict(
                 is_inverse=not self.is_inverse,
                 children=inverted_children,
+                generated_function=inverse_generated_function,
             )
         )
 
+    @property
+    def _inverse_registers(self) -> list[GeneratedRegister]:
+        return [
+            reg.model_copy(update=dict(role=self._inverse_register_role(reg.role)))
+            for reg in self.registers
+        ]
+
+    def _inverse_register_role(self, role: RegisterRole) -> RegisterRole:
+        if role is RegisterRole.INPUT:
+            return RegisterRole.OUTPUT
+        if role is RegisterRole.EXPLICIT_ZERO_INPUT or role is RegisterRole.ZERO_INPUT:
+            if self.release_by_inverse:
+                return RegisterRole.ZERO_OUTPUT
+            return RegisterRole.OUTPUT
+        if role is RegisterRole.AUXILIARY:
+            return RegisterRole.AUXILIARY
+        if role is RegisterRole.OUTPUT or role is RegisterRole.GARBAGE_OUTPUT:
+            return RegisterRole.INPUT
+        if role is RegisterRole.ZERO_OUTPUT:
+            return RegisterRole.ZERO_INPUT
+
 
 def _get_absolute_from_relative(
     absolute_qubits: tuple[int, ...], relative_qubits: tuple[int, ...]

classiq/interface/generator/hardware_efficient_ansatz.py

@@ -60,7 +60,7 @@ class HardwareEfficientAnsatz(function_params.FunctionParams):
         description='List of gates for the two qubit gates entangling layer, e.g. ["cx", "cry"]',
     )
     parameter_prefix: str = pydantic.Field(
-        default="param_",
+        default="hea_param_",
         description="Prefix for the generated parameters",
     )
 

classiq/interface/generator/hva.py

@@ -17,6 +17,6 @@ class HVA(ChemistryFunctionParams):
         default=False, description="Whether to evolve the operator naively"
     )
     parameter_prefix: str = pydantic.Field(
-        default="param_",
+        default="hva_param_",
         description="Prefix for the generated parameters",
     )

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

@@ -36,7 +36,7 @@ if TYPE_CHECKING:
     PydanticBackendName = str
 else:
     PydanticBackendName = Annotated[
-        str, Field(strict=True, min_length=1, pattern="^([.A-Za-z0-9_-]*)$")
+        str, Field(strict=True, pattern="^([.A-Za-z0-9_-][ .A-Za-z0-9_-]*)$")
     ]
 
 
@@ -262,6 +262,13 @@ class Preferences(pydantic.BaseModel, extra="forbid"):
 
         return output_format
 
+    @pydantic.field_validator("backend_name")
+    @classmethod
+    def validate_backend_name(cls, backend_name: Optional[str]) -> Optional[str]:
+        if backend_name is None:
+            return backend_name
+        return backend_name.rstrip()
+
     @pydantic.model_validator(mode="after")
     def validate_backend(self) -> Self:
         backend_name = self.backend_name

classiq/interface/generator/reset.py

@@ -0,0 +1,14 @@
+from classiq.interface.generator.arith.register_user_input import (
+    RegisterArithmeticInfo,
+    RegisterUserInput,
+)
+from classiq.interface.generator.function_params import FunctionParams
+
+
+class Reset(FunctionParams):
+    target: RegisterUserInput
+
+    def _create_ios(self) -> None:
+        mapping: dict[str, RegisterArithmeticInfo] = {self.target.name: self.target}
+        self._inputs = mapping
+        self._outputs = mapping

classiq/interface/generator/ucc.py

@@ -38,7 +38,7 @@ class UCC(ChemistryFunctionParams):
         description="Maximum depth of the generated quantum circuit ansatz",
     )
     parameter_prefix: str = pydantic.Field(
-        default="param_",
+        default="ucc_param_",
         description="Prefix for the generated parameters",
     )
 

classiq/interface/interface_version.py

@@ -1 +1 @@
-INTERFACE_VERSION = "7"
+INTERFACE_VERSION = "8"

classiq/interface/model/quantum_statement.py

@@ -5,6 +5,7 @@ from uuid import UUID, uuid4
 
 import pydantic
 from pydantic import ConfigDict
+from typing_extensions import Self
 
 from classiq.interface.ast_node import ASTNode
 from classiq.interface.helpers.pydantic_model_helpers import values_with_discriminator
@@ -21,6 +22,18 @@ class QuantumStatement(ASTNode):
         description="A unique identifier for this operation", default_factory=uuid4
     )
 
+    def model_copy(
+        self,
+        *,
+        update: Optional[dict[str, Any]] = None,
+        deep: bool = False,
+        keep_uuid: bool = False
+    ) -> Self:
+        if not keep_uuid:
+            update = update or dict()
+            update.setdefault("uuid", uuid4())
+        return super().model_copy(update=update, deep=deep)
+
     @pydantic.model_validator(mode="before")
     @classmethod
     def _set_kind(cls, values: Any) -> dict[str, Any]:

classiq/model_expansions/atomic_expression_functions_defs.py

@@ -21,6 +21,7 @@ from classiq.interface.generator.functions.classical_function_declaration import
 )
 from classiq.interface.generator.functions.classical_type import (
     Bool,
+    ClassicalArray,
     ClassicalList,
     ClassicalType,
     OpaqueHandle,
@@ -64,7 +65,7 @@ def qmod_val_to_python(val: ExpressionValue, qmod_type: ClassicalType) -> Any:
         if isinstance(val, (Enum, int)):
             return val
 
-    elif isinstance(qmod_type, ClassicalList):
+    elif isinstance(qmod_type, (ClassicalArray, ClassicalList)):
         if isinstance(val, list):
             return [qmod_val_to_python(elem, qmod_type.element_type) for elem in val]