classiq 0.37.1__py3-none-any.whl → 0.65.3__py3-none-any.whl

classiq/interface/generator/application_apis/combinatorial_optimization_declarations.py

@@ -3,40 +3,37 @@ from classiq.interface.generator.functions.classical_function_declaration import
 )
 from classiq.interface.generator.functions.classical_type import (
     ClassicalList,
-    Integer,
     Real,
-    Struct,
     StructMetaType,
     VQEResult,
 )
-from classiq.interface.generator.types.struct_declaration import StructDeclaration
-
-COMBINATORIAL_OPTIMIZATION_SOLUTION = StructDeclaration(
-    name="CombinatorialOptimizationSolution",
-    variables={
-        "probability": Real(),
-        "cost": Real(),
-        "solution": ClassicalList(element_type=Integer()),
-        "count": Integer(),
-    },
+from classiq.interface.generator.functions.type_name import Struct
+from classiq.interface.model.classical_parameter_declaration import (
+    ClassicalParameterDeclaration,
 )
 
 OPTIMIZATION_PROBLEM_TO_HAMILTONIAN = ClassicalFunctionDeclaration(
     name="optimization_problem_to_hamiltonian",
-    param_decls={
-        "problem_type": StructMetaType(),
-        "penalty_energy": Real(),
-    },
+    positional_parameters=[
+        ClassicalParameterDeclaration(
+            name="problem_type", classical_type=StructMetaType()
+        ),
+        ClassicalParameterDeclaration(name="penalty_energy", classical_type=Real()),
+    ],
     return_type=ClassicalList(element_type=Struct(name="PauliTerm")),
 )
 
 GET_OPTIMIZATION_SOLUTION = ClassicalFunctionDeclaration(
     name="get_optimization_solution",
-    param_decls={
-        "problem_type": StructMetaType(),
-        "vqe_result_handle": VQEResult(),
-        "penalty_energy": Real(),
-    },
+    positional_parameters=[
+        ClassicalParameterDeclaration(
+            name="problem_type", classical_type=StructMetaType()
+        ),
+        ClassicalParameterDeclaration(
+            name="vqe_result_handle", classical_type=VQEResult()
+        ),
+        ClassicalParameterDeclaration(name="penalty_energy", classical_type=Real()),
+    ],
     return_type=ClassicalList(
         element_type=Struct(name="CombinatorialOptimizationSolution")
     ),

classiq/interface/generator/application_apis/entangler_declarations.py

@@ -6,19 +6,24 @@ from classiq.interface.generator.functions.classical_type import (
     ClassicalList,
     Integer,
 )
+from classiq.interface.model.classical_parameter_declaration import (
+    ClassicalParameterDeclaration,
+)
 
 GRID_ENTANGLER_GRAPH = ClassicalFunctionDeclaration(
     name="grid_entangler_graph",
-    param_decls={
-        "num_qubits": Integer(),
-        "schmidt_rank": Integer(),
-        "grid_randomization": Bool(),
-    },
+    positional_parameters=[
+        ClassicalParameterDeclaration(name="num_qubits", classical_type=Integer()),
+        ClassicalParameterDeclaration(name="schmidt_rank", classical_type=Integer()),
+        ClassicalParameterDeclaration(name="grid_randomization", classical_type=Bool()),
+    ],
     return_type=ClassicalList(element_type=ClassicalList(element_type=Integer())),
 )
 
 HYPERCUBE_ENTANGLER_GRAPH = ClassicalFunctionDeclaration(
     name="hypercube_entangler_graph",
-    param_decls={"num_qubits": Integer()},
+    positional_parameters=[
+        ClassicalParameterDeclaration(name="num_qubits", classical_type=Integer()),
+    ],
     return_type=ClassicalList(element_type=ClassicalList(element_type=Integer())),
 )

classiq/interface/generator/application_apis/finance_declarations.py

@@ -1,25 +1,23 @@
+from collections.abc import Mapping
 from enum import Enum
-from typing import Mapping
 
 from classiq.interface.generator.expressions.expression import Expression
 from classiq.interface.generator.functions.classical_function_declaration import (
     ClassicalFunctionDeclaration,
 )
-from classiq.interface.generator.functions.classical_type import (
-    Bool,
-    ClassicalList,
-    Integer,
-    Real,
-    Struct,
-)
+from classiq.interface.generator.functions.classical_type import Real
 from classiq.interface.generator.functions.port_declaration import (
     PortDeclarationDirection,
 )
-from classiq.interface.generator.types.struct_declaration import StructDeclaration
+from classiq.interface.generator.functions.type_name import Struct
+from classiq.interface.model.classical_parameter_declaration import (
+    ClassicalParameterDeclaration,
+)
 from classiq.interface.model.port_declaration import PortDeclaration
 from classiq.interface.model.quantum_function_declaration import (
-    QuantumFunctionDeclaration,
+    NamedParamsQuantumFunctionDeclaration,
 )
+from classiq.interface.model.quantum_type import QuantumBit, QuantumBitvector
 
 FUNCTION_PORT_NAME = "func_port"
 OBJECTIVE_PORT_NAME = "obj_port"
@@ -31,32 +29,39 @@ class FinanceModelType(Enum):
 
 
 FINANCE_FUNCTION_PORT_SIZE_MAPPING: Mapping[FinanceModelType, str] = {
-    FinanceModelType.Gaussian: "get_field(finance_model, 'num_qubits') + len(get_field(finance_model, 'rhos')) + floor(log(sum(get_field(finance_model, 'loss')), 2)) + 1",
+    FinanceModelType.Gaussian: "get_field(finance_model, 'num_qubits') + get_field(get_field(finance_model, 'rhos'), 'len') + floor(log(sum(get_field(finance_model, 'loss')), 2)) + 1",
     FinanceModelType.LogNormal: "get_field(finance_model, 'num_qubits')",
 }
 
 
 def _generate_finance_function(
     finance_model: FinanceModelType,
-) -> QuantumFunctionDeclaration:
-    return QuantumFunctionDeclaration(
+) -> NamedParamsQuantumFunctionDeclaration:
+    return NamedParamsQuantumFunctionDeclaration(
         name=f"{finance_model.value}_finance",
-        param_decls={
-            "finance_model": Struct(name=f"{finance_model.name}Model"),
-            "finance_function": Struct(name="FinanceFunction"),
-        },
-        port_declarations={
-            FUNCTION_PORT_NAME: PortDeclaration(
+        positional_arg_declarations=[
+            ClassicalParameterDeclaration(
+                name="finance_model",
+                classical_type=Struct(name=f"{finance_model.name}Model"),
+            ),
+            ClassicalParameterDeclaration(
+                name="finance_function", classical_type=Struct(name="FinanceFunction")
+            ),
+            PortDeclaration(
                 name=FUNCTION_PORT_NAME,
+                quantum_type=QuantumBitvector(
+                    length=Expression(
+                        expr=FINANCE_FUNCTION_PORT_SIZE_MAPPING[finance_model]
+                    )
+                ),
                 direction=PortDeclarationDirection.Inout,
-                size=Expression(expr=FINANCE_FUNCTION_PORT_SIZE_MAPPING[finance_model]),
             ),
-            OBJECTIVE_PORT_NAME: PortDeclaration(
+            PortDeclaration(
                 name=OBJECTIVE_PORT_NAME,
+                quantum_type=QuantumBit(),
                 direction=PortDeclarationDirection.Inout,
-                size=Expression(expr="1"),
             ),
-        },
+        ],
     )
 
 
@@ -64,63 +69,37 @@ LOG_NORMAL_FINANCE_FUNCTION = _generate_finance_function(FinanceModelType.LogNor
 
 GAUSSIAN_FINANCE_FUNCTION = _generate_finance_function(FinanceModelType.Gaussian)
 
-GAUSSIAN_MODEL = StructDeclaration(
-    name="GaussianModel",
-    variables={
-        "num_qubits": Integer(),
-        "normal_max_value": Real(),
-        "default_probabilities": ClassicalList(element_type=Real()),
-        "rhos": ClassicalList(element_type=Real()),
-        "loss": ClassicalList(element_type=Integer()),
-        "min_loss": Integer(),
-    },
-)
-
-
-LOG_NORMAL_MODEL = StructDeclaration(
-    name="LogNormalModel",
-    variables={"num_qubits": Integer(), "mu": Real(), "sigma": Real()},
-)
-
-
-FINANCE_FUNCTION = StructDeclaration(
-    name="FinanceFunction",
-    variables={
-        "f": Integer(),
-        "threshold": Real(),
-        "larger": Bool(),
-        "polynomial_degree": Integer(),
-        "use_chebyshev_polynomial_approximation": Bool(),
-        "tail_probability": Real(),
-    },
-)
-
 LOG_NORMAL_FINANCE_POST_PROCESS = ClassicalFunctionDeclaration(
     name="log_normal_finance_post_process",
-    param_decls={
-        "finance_model": Struct(name="LogNormalModel"),
-        "estimation_method": Struct(name="FinanceFunction"),
-        "probability": Real(),
-    },
+    positional_parameters=[
+        ClassicalParameterDeclaration(
+            name="finance_model", classical_type=Struct(name="LogNormalModel")
+        ),
+        ClassicalParameterDeclaration(
+            name="estimation_method", classical_type=Struct(name="FinanceFunction")
+        ),
+        ClassicalParameterDeclaration(name="probability", classical_type=Real()),
+    ],
     return_type=Real(),
 )
 
 GAUSSIAN_FINANCE_POST_PROCESS = ClassicalFunctionDeclaration(
     name="gaussian_finance_post_process",
-    param_decls={
-        "finance_model": Struct(name="GaussianModel"),
-        "estimation_method": Struct(name="FinanceFunction"),
-        "probability": Real(),
-    },
+    positional_parameters=[
+        ClassicalParameterDeclaration(
+            name="finance_model", classical_type=Struct(name="GaussianModel")
+        ),
+        ClassicalParameterDeclaration(
+            name="estimation_method", classical_type=Struct(name="FinanceFunction")
+        ),
+        ClassicalParameterDeclaration(name="probability", classical_type=Real()),
+    ],
     return_type=Real(),
 )
 
 __all__ = [
-    "LOG_NORMAL_FINANCE_FUNCTION",
     "GAUSSIAN_FINANCE_FUNCTION",
-    "GAUSSIAN_MODEL",
-    "LOG_NORMAL_MODEL",
-    "FINANCE_FUNCTION",
-    "LOG_NORMAL_FINANCE_POST_PROCESS",
     "GAUSSIAN_FINANCE_POST_PROCESS",
+    "LOG_NORMAL_FINANCE_FUNCTION",
+    "LOG_NORMAL_FINANCE_POST_PROCESS",
 ]

classiq/interface/generator/application_apis/qsvm_declarations.py

@@ -1,76 +1,6 @@
 import enum
 
-from classiq.interface.generator.expressions.expression import Expression
-from classiq.interface.generator.functions.classical_type import (
-    ClassicalList,
-    Integer,
-    Pauli,
-    Real,
-    Struct,
-)
-from classiq.interface.generator.functions.port_declaration import (
-    PortDeclarationDirection,
-)
-from classiq.interface.generator.types.struct_declaration import StructDeclaration
-from classiq.interface.model.port_declaration import PortDeclaration
-from classiq.interface.model.quantum_function_declaration import (
-    QuantumFunctionDeclaration,
-)
-
 
 class FeatureMapType(enum.Enum):
     BlochSphere = "bloch_sphere"
     Pauli = "pauli"
-
-
-QSVM_PAULI_FEATURE_MAP_SIZE = "get_field(feature_map, 'feature_dimension')"
-QSVM_PAULI_FEATURE_MAP = QuantumFunctionDeclaration(
-    name="pauli_feature_map",
-    param_decls={"feature_map": Struct(name="QSVMFeatureMapPauli")},
-    port_declarations={
-        "qbv": PortDeclaration(
-            name="qbv",
-            direction=PortDeclarationDirection.Inout,
-            size=Expression(expr=QSVM_PAULI_FEATURE_MAP_SIZE),
-        )
-    },
-)
-
-QSVM_BLOCH_SPHERE_FEATURE_MAP_SIZE = "ceiling(feature_dimension/2)"
-QSVM_BLOCH_SPHERE_FEATURE_MAP = QuantumFunctionDeclaration(
-    name="bloch_sphere_feature_map",
-    param_decls={"feature_dimension": Integer()},
-    port_declarations={
-        "qbv": PortDeclaration(
-            name="qbv",
-            direction=PortDeclarationDirection.Inout,
-            size=Expression(expr=QSVM_BLOCH_SPHERE_FEATURE_MAP_SIZE),
-        )
-    },
-)
-
-QSVM_FEATURE_MAP_PAULI = StructDeclaration(
-    name="QSVMFeatureMapPauli",
-    variables={
-        "feature_dimension": Integer(),
-        "reps": Integer(),
-        "entanglement": Integer(),
-        "alpha": Real(),
-        "paulis": ClassicalList(element_type=ClassicalList(element_type=Pauli())),
-    },
-)
-
-QSVM_RESULT = StructDeclaration(
-    name="QsvmResult",
-    variables={
-        "test_score": Real(),
-        "predicted_labels": ClassicalList(element_type=Real()),
-    },
-)
-
-__all__ = [
-    "QSVM_RESULT",
-    "QSVM_PAULI_FEATURE_MAP",
-    "QSVM_BLOCH_SPHERE_FEATURE_MAP",
-    "QSVM_FEATURE_MAP_PAULI",
-]

classiq/interface/generator/arith/argument_utils.py

@@ -1,15 +1,18 @@
-from typing import Tuple, Union
+from typing import Union
 
 from classiq.interface.generator.arith import number_utils
+from classiq.interface.generator.arith.number_utils import (
+    get_int_representation_and_fraction_places,
+)
 from classiq.interface.generator.arith.register_user_input import RegisterArithmeticInfo
 
 RegisterOrConst = Union[RegisterArithmeticInfo, float]
 
 
-def fraction_places(argument: RegisterOrConst, *, machine_precision: int) -> int:
+def fraction_places(argument: RegisterOrConst) -> int:
     if isinstance(argument, RegisterArithmeticInfo):
         return argument.fraction_places
-    return number_utils.fraction_places(argument, machine_precision=machine_precision)
+    return number_utils.fraction_places(argument)
 
 
 def integer_part_size(argument: RegisterOrConst) -> int:
@@ -18,10 +21,10 @@ def integer_part_size(argument: RegisterOrConst) -> int:
     return number_utils.integer_part_size(argument)
 
 
-def size(argument: RegisterOrConst, *, machine_precision: int) -> int:
+def size(argument: RegisterOrConst) -> int:
     if isinstance(argument, RegisterArithmeticInfo):
         return argument.size
-    return number_utils.size(argument, machine_precision=machine_precision)
+    return number_utils.size(argument)
 
 
 def is_signed(argument: RegisterOrConst) -> bool:
@@ -42,7 +45,55 @@ def lower_bound(argument: RegisterOrConst) -> float:
     return argument
 
 
-def bounds(argument: RegisterOrConst) -> Tuple[float, float]:
+def bounds(argument: RegisterOrConst) -> tuple[float, float]:
     if isinstance(argument, RegisterArithmeticInfo):
         return argument.bounds
     return argument, argument
+
+
+def limit_fraction_places(
+    argument: RegisterOrConst, machine_precision: int
+) -> RegisterOrConst:
+    if isinstance(argument, RegisterArithmeticInfo):
+        return argument.limit_fraction_places(machine_precision)
+    return number_utils.limit_fraction_places(argument, machine_precision)
+
+
+def arg_bounds_overlap(args: tuple[RegisterOrConst, RegisterOrConst]) -> bool:
+    return (max(bounds(args[0])) - min(bounds(args[1]))) * (
+        min(bounds(args[0])) - max(bounds(args[1]))
+    ) < 0
+
+
+def as_arithmetic_info(
+    arg: RegisterOrConst, with_bounds: bool = True
+) -> RegisterArithmeticInfo:
+    if isinstance(arg, RegisterArithmeticInfo):
+        return arg
+    return RegisterArithmeticInfo(
+        size=number_utils.size(arg),
+        is_signed=arg < 0,
+        fraction_places=number_utils.fraction_places(arg),
+        bounds=(arg, arg) if with_bounds else None,
+    )
+
+
+def unsigned_integer_interpretation(
+    value: float, register: RegisterArithmeticInfo
+) -> int:
+    int_val, fraction_digits = get_int_representation_and_fraction_places(value)
+
+    # align fraction digits
+    fraction_digits_diff = register.fraction_places - fraction_digits
+    if fraction_digits_diff < 0:
+        int_val >>= -fraction_digits_diff
+    else:
+        int_val <<= fraction_digits_diff
+
+    # extend sign bit
+    if int(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])
+
+    return int_val

classiq/interface/generator/arith/arithmetic.py

@@ -1,12 +1,17 @@
-from typing import Any, Dict, Optional, Set
+from typing import Any, Final, Optional
 
 import networkx as nx
 import pydantic
+from pydantic_core.core_schema import ValidationInfo
 
+from classiq.interface.exceptions import ClassiqValueError
 from classiq.interface.generator.arith import arithmetic_expression_parser
 from classiq.interface.generator.arith.arithmetic_expression_abc import (
     ArithmeticExpressionABC,
 )
+from classiq.interface.generator.arith.arithmetic_expression_validator import (
+    is_constant,
+)
 from classiq.interface.generator.arith.arithmetic_param_getters import (
     id2op,
     operation_allows_target,
@@ -15,29 +20,37 @@ from classiq.interface.generator.arith.arithmetic_result_builder import (
     ArithmeticResultBuilder,
 )
 from classiq.interface.generator.arith.register_user_input import RegisterArithmeticInfo
+from classiq.interface.generator.expressions.expression import Expression
 from classiq.interface.model.quantum_type import (
+    QuantumNumeric,
     QuantumType,
     quantum_var_to_register,
     register_info_to_quantum_type,
 )
 
-ARITHMETIC_EXPRESSION_TARGET_NAME: str = "arithmetic_target"
-ARITHMETIC_EXPRESSION_RESULT_NAME: str = "expression_result"
+ARITHMETIC_EXPRESSION_TARGET_NAME: Final[str] = "arithmetic_target"
+ARITHMETIC_EXPRESSION_RESULT_NAME: Final[str] = "expression_result"
+ARITHMETIC_EXPRESSION_GARBAGE_NAME: Final[str] = "expression_garbage"
+
+
+def is_zero(expr: str) -> bool:
+    return is_constant(expr) and float(expr) == 0
 
 
 class Arithmetic(ArithmeticExpressionABC):
     target: Optional[RegisterArithmeticInfo] = None
-    inputs_to_save: Set[str] = pydantic.Field(default_factory=set)
+    inputs_to_save: set[str] = pydantic.Field(default_factory=set)
 
-    @pydantic.validator("inputs_to_save", always=True)
+    @pydantic.field_validator("inputs_to_save")
+    @classmethod
     def _validate_inputs_to_save(
-        cls, inputs_to_save: Set[str], values: Dict[str, Any]
-    ) -> Set[str]:
-        assert all(reg in values.get("definitions", {}) for reg in inputs_to_save)
+        cls, inputs_to_save: set[str], info: ValidationInfo
+    ) -> set[str]:
+        assert all(reg in info.data.get("definitions", {}) for reg in inputs_to_save)
         return inputs_to_save
 
     @staticmethod
-    def _validate_expression_graph(graph: nx.DiGraph, values: Dict[str, Any]) -> None:
+    def _validate_expression_graph(graph: nx.DiGraph, values: dict[str, Any]) -> None:
         target = values.get("target")
         if target is None:
             return
@@ -47,7 +60,7 @@ class Arithmetic(ArithmeticExpressionABC):
             degree or operation_allows_target(id2op(node))
             for node, degree in graph.out_degree
         ):
-            raise ValueError("Expression does not support target assignment")
+            raise ClassiqValueError("Expression does not support target assignment")
 
     def _create_ios(self) -> None:
         self._inputs = {
@@ -62,19 +75,21 @@ class Arithmetic(ArithmeticExpressionABC):
             if name in self._inputs
         }
         # TODO: avoid calling the result builder again, as it is called in validation
-        result_info = ArithmeticResultBuilder(
+        result_builder = ArithmeticResultBuilder(
             graph=arithmetic_expression_parser.parse_expression(self.expression),
             definitions=self.definitions,
             machine_precision=self.machine_precision,
-        ).result
-        self._outputs[ARITHMETIC_EXPRESSION_RESULT_NAME] = result_info
+        )
+        self._outputs[ARITHMETIC_EXPRESSION_RESULT_NAME] = result_builder.result
+        if result_builder.garbage:
+            self._outputs[ARITHMETIC_EXPRESSION_GARBAGE_NAME] = result_builder.garbage
         if self.target:
             self._inputs[ARITHMETIC_EXPRESSION_TARGET_NAME] = self.target
 
 
 def get_arithmetic_params(
     expr_str: str,
-    var_types: Dict[str, QuantumType],
+    var_types: dict[str, QuantumType],
     machine_precision: int,
     enable_target: bool = False,
 ) -> Arithmetic:
@@ -92,8 +107,14 @@ def get_arithmetic_params(
 
 
 def compute_arithmetic_result_type(
-    expr_str: str, var_types: Dict[str, QuantumType], machine_precision: int
-) -> QuantumType:
+    expr_str: str, var_types: dict[str, QuantumType], machine_precision: int
+) -> QuantumNumeric:
+    if is_zero(expr_str):
+        return QuantumNumeric(
+            size=Expression(expr="1"),
+            is_signed=Expression(expr="False"),
+            fraction_digits=Expression(expr="0"),
+        )
     arith_param = get_arithmetic_params(expr_str, var_types, machine_precision)
     return register_info_to_quantum_type(
         arith_param.outputs[ARITHMETIC_EXPRESSION_RESULT_NAME]

classiq/interface/generator/arith/arithmetic_arg_type_validator.py

@@ -1,28 +1,20 @@
-from typing import Callable, Dict, List
+from typing import Callable
 
 from typing_extensions import TypeAlias
 
-from classiq.interface.generator.arith.argument_utils import (
-    RegisterOrConst,
-    fraction_places,
-)
+from classiq.interface.exceptions import ClassiqArithmeticError
+from classiq.interface.generator.arith import argument_utils
 from classiq.interface.generator.arith.binary_ops import BOOLEAN_OP_WITH_FRACTIONS_ERROR
 
-from classiq.exceptions import ClassiqArithmeticError
-
-ArgTypeValidator: TypeAlias = Callable[[List[RegisterOrConst], int], None]
+ArgTypeValidator: TypeAlias = Callable[[list[argument_utils.RegisterOrConst]], None]
 
 
-def _validate_bitwise_op_args(
-    args: List[RegisterOrConst], machine_precision: int
-) -> None:
-    if any(
-        fraction_places(arg, machine_precision=machine_precision) > 0 for arg in args
-    ):
+def _validate_bitwise_op_args(args: list[argument_utils.RegisterOrConst]) -> None:
+    if any(argument_utils.fraction_places(arg) > 0 for arg in args):
         raise ClassiqArithmeticError(BOOLEAN_OP_WITH_FRACTIONS_ERROR)
 
 
-arg_type_validator_map: Dict[str, ArgTypeValidator] = dict(
+arg_type_validator_map: dict[str, ArgTypeValidator] = dict(
     BitXor=_validate_bitwise_op_args,
     BitAnd=_validate_bitwise_op_args,
     BitOr=_validate_bitwise_op_args,
@@ -30,8 +22,14 @@ arg_type_validator_map: Dict[str, ArgTypeValidator] = dict(
 
 
 def validate_operation_arg_types(
-    operation: str, args: List[RegisterOrConst], machine_precision: int
+    operation: str,
+    arguments: list[argument_utils.RegisterOrConst],
+    machine_precision: int,
 ) -> None:
     if operation not in arg_type_validator_map:
         return
-    arg_type_validator_map[operation](args, machine_precision)
+    limited_args = [
+        argument_utils.limit_fraction_places(arg, machine_precision=machine_precision)
+        for arg in arguments
+    ]
+    arg_type_validator_map[operation](limited_args)