classiq 0.37.0__py3-none-any.whl → 0.38.0__py3-none-any.whl

classiq/interface/generator/arith/number_utils.py

@@ -1,7 +1,6 @@
-from typing import Tuple, Union
+from typing import Final, Tuple, Union
 
-MAXIMAL_MACHINE_PRECISION: int = 20
-MAX_FRACTION_PLACES: int = 8
+MAXIMAL_MACHINE_PRECISION: Final[int] = 20
 
 
 def signed_int_to_unsigned(number: int) -> int:
@@ -32,8 +31,8 @@ def binary_to_float_or_int(
     return binary_to_float(bin_rep, fraction_part_size, is_signed)
 
 
-def _get_fraction_places(*, binary_value: str, machine_precision: int) -> int:
-    fraction_places = machine_precision
+def _get_fraction_places(*, binary_value: str) -> int:
+    fraction_places = MAXIMAL_MACHINE_PRECISION
     for bit in reversed(binary_value):
         if bit == "1" or fraction_places == 0:
             return fraction_places
@@ -41,79 +40,70 @@ def _get_fraction_places(*, binary_value: str, machine_precision: int) -> int:
     return fraction_places
 
 
-def get_int_representation_and_fraction_places(
-    float_value: float, *, machine_precision: int
-) -> Tuple[int, int]:
-    int_val = signed_int_to_unsigned(int(float_value * 2**machine_precision))
+def get_int_representation_and_fraction_places(float_value: float) -> Tuple[int, int]:
+    int_val = signed_int_to_unsigned(int(float_value * 2**MAXIMAL_MACHINE_PRECISION))
     if int_val == 0:
         return 0, 0
-    fraction_places = _get_fraction_places(
-        binary_value=bin(int_val)[2:], machine_precision=machine_precision
-    )
-    int_val = int_val >> (machine_precision - fraction_places)
+    fraction_places = _get_fraction_places(binary_value=bin(int_val)[2:])
+    int_val = int_val >> (MAXIMAL_MACHINE_PRECISION - fraction_places)
     return int_val, fraction_places
 
 
-def fraction_places(float_value: float, *, machine_precision: int) -> int:
-    int_val = signed_int_to_unsigned(int(float_value * 2**machine_precision))
+def fraction_places(float_value: float) -> int:
+    int_val = signed_int_to_unsigned(int(float_value * 2**MAXIMAL_MACHINE_PRECISION))
     if int_val == 0:
         return 0
-    return _get_fraction_places(
-        binary_value=bin(int_val)[2:], machine_precision=machine_precision
-    )
+    return _get_fraction_places(binary_value=bin(int_val)[2:])
 
 
 def _bit_length(integer_representation: int) -> int:
     return 1 if integer_representation == 0 else integer_representation.bit_length()
 
 
-def binary_string(
-    float_value: float, *, machine_precision: int = MAXIMAL_MACHINE_PRECISION
-) -> str:
-    int_val, _ = get_int_representation_and_fraction_places(
-        float_value=float_value, machine_precision=machine_precision
-    )
+def binary_string(float_value: float) -> str:
+    int_val, _ = get_int_representation_and_fraction_places(float_value)
     bin_rep = bin(int_val)[2:]
-    size_diff = size(
-        float_value=float_value, machine_precision=machine_precision
-    ) - len(bin_rep)
+    size_diff = size(float_value=float_value) - len(bin_rep)
     extension_bit = "0" if float_value >= 0 else "1"
     return bin_rep[::-1] + extension_bit * size_diff
 
 
 def integer_part_size(float_value: float) -> int:
-    int_val, fraction_places = get_int_representation_and_fraction_places(
-        float_value=float_value, machine_precision=MAXIMAL_MACHINE_PRECISION
-    )
+    int_val, fraction_places = get_int_representation_and_fraction_places(float_value)
     return max(_bit_length(int_val) - fraction_places, 0)
 
 
-def size(float_value: float, *, machine_precision: int) -> int:
-    int_val, fraction_places = get_int_representation_and_fraction_places(
-        float_value=float_value, machine_precision=machine_precision
-    )
+def size(float_value: float) -> int:
+    int_val, fraction_places = get_int_representation_and_fraction_places(float_value)
     return max(_bit_length(int_val), fraction_places)
 
 
+def _is_extra_sign_bit_needed(*, lb: float, ub: float) -> bool:
+    integer_lb = lb * 2 ** fraction_places(lb)
+    max_represented_number = (
+        2 ** (len(binary_string(integer_lb)) - 1) - 1
+    ) / 2 ** fraction_places(lb)
+    return ub > max_represented_number
+
+
 def bounds_to_integer_part_size(lb: float, ub: float) -> int:
     lb, ub = min(lb, ub), max(lb, ub)
     ub_integer_part_size: int = integer_part_size(float_value=ub)
     lb_integer_part_size: int = integer_part_size(float_value=lb)
-    if lb == 0:
+    if lb >= 0:
         return ub_integer_part_size
-    if ub == 0:
+    if ub <= 0:
         return lb_integer_part_size
-    is_extra_bit_needed = lb < 0 < ub and ub_integer_part_size >= lb_integer_part_size
-    return max(ub_integer_part_size + 1 * is_extra_bit_needed, lb_integer_part_size)
+    return max(
+        ub_integer_part_size + 1 * _is_extra_sign_bit_needed(lb=lb, ub=ub),
+        lb_integer_part_size,
+    )
 
 
 def limit_fraction_places(number: float, *, machine_precision: int) -> float:
-    orig_bin_rep = binary_string(number, machine_precision=MAXIMAL_MACHINE_PRECISION)[
-        ::-1
-    ]
-    orig_fractions = fraction_places(
-        number, machine_precision=MAXIMAL_MACHINE_PRECISION
-    )
+    orig_bin_rep = binary_string(number)[::-1]
+    orig_fractions = fraction_places(number)
+
     removed_fractions = max(orig_fractions - machine_precision, 0)
     return binary_to_float(
         bin_rep=orig_bin_rep[: len(orig_bin_rep) - removed_fractions],

classiq/interface/generator/arith/register_user_input.py

@@ -2,6 +2,7 @@ from typing import Any, Dict, Optional
 
 import pydantic
 
+from classiq.interface.generator.arith import number_utils
 from classiq.interface.helpers.custom_pydantic_types import PydanticFloatTuple
 from classiq.interface.helpers.hashable_pydantic_base_model import (
     HashablePydanticBaseModel,
@@ -29,7 +30,17 @@ class RegisterArithmeticInfo(HashablePydanticBaseModel):
         if bounds is not None:
             if min(bounds) < 0:
                 assert values.get("is_signed")
-            return tuple(bounds)  # type: ignore[return-value]
+            fraction_places = values.get("fraction_places")
+            if not isinstance(fraction_places, int):
+                raise ClassiqValueError(
+                    "RegisterUserInput must have an integer fraction_places"
+                )
+            return number_utils.limit_fraction_places(
+                min(bounds), machine_precision=fraction_places
+            ), number_utils.limit_fraction_places(
+                max(bounds), machine_precision=fraction_places
+            )
+
         size = values.get("size")
         if not isinstance(size, int):
             raise ClassiqValueError("RegisterUserInput must have an integer size")
@@ -39,6 +50,15 @@ class RegisterArithmeticInfo(HashablePydanticBaseModel):
         fraction_factor = float(2 ** -values.get("fraction_places", 0))
         return (lb * fraction_factor, ub * fraction_factor)
 
+    def limit_fraction_places(self, machine_precision: int) -> "RegisterArithmeticInfo":
+        truncated_bits: int = max(self.fraction_places - machine_precision, 0)
+        return RegisterArithmeticInfo(
+            size=self.size - truncated_bits,
+            is_signed=self.is_signed,
+            fraction_places=self.fraction_places - truncated_bits,
+            bounds=self.bounds,
+        )
+
     @property
     def is_boolean_register(self) -> bool:
         return (not self.is_signed) and (self.size == 1) and (self.fraction_places == 0)

classiq/interface/generator/arith/unary_ops.py

@@ -1,17 +1,16 @@
-from __future__ import annotations
-
-import abc
-from typing import Iterable, Optional
+from typing import TYPE_CHECKING, Iterable, Optional
 
 import pydantic
 
-from classiq.interface.generator.arith import number_utils
+from classiq.interface.generator.arith import argument_utils, number_utils
 from classiq.interface.generator.arith.arithmetic_operations import (
     ArithmeticOperationParams,
 )
 from classiq.interface.generator.arith.register_user_input import RegisterArithmeticInfo
 from classiq.interface.generator.function_params import get_zero_input_name
 
+from classiq.exceptions import ClassiqValueError
+
 UNARY_ARG_NAME: str = "arg"
 
 
@@ -19,16 +18,9 @@ class UnaryOpParams(ArithmeticOperationParams):
     arg: RegisterArithmeticInfo
     inplace: bool = False
 
-    @abc.abstractmethod
-    def _expected_result_size(self) -> pydantic.PositiveInt:
-        pass
-
-    def actual_result_size(self) -> int:
-        return self.output_size or self._expected_result_size()
-
     def garbage_output_size(self) -> pydantic.NonNegativeInt:
         return int(self.is_inplaced()) * max(
-            self.arg.size - self.actual_result_size(), 0
+            self.arg.size - self.result_register.size, 0
         )
 
     def should_add_zero_inputs(self) -> bool:
@@ -60,7 +52,7 @@ class UnaryOpParams(ArithmeticOperationParams):
     def is_inplaced(self) -> bool:
         return self.inplace
 
-    def get_params_inplace_options(self) -> Iterable[UnaryOpParams]:
+    def get_params_inplace_options(self) -> Iterable["UnaryOpParams"]:
         params_kwargs = self.copy().__dict__
         params_kwargs["inplace"] = True
         yield self.__class__(**params_kwargs)
@@ -72,14 +64,16 @@ class UnaryOpParams(ArithmeticOperationParams):
 class BitwiseInvert(UnaryOpParams):
     output_name = "inverted"
 
-    def _expected_result_size(self) -> pydantic.PositiveInt:
-        return self.arg.size
-
     def _get_result_register(self) -> RegisterArithmeticInfo:
+        eff_arg = argument_utils.limit_fraction_places(
+            self.arg, machine_precision=self.machine_precision
+        )
+        if TYPE_CHECKING:
+            assert isinstance(eff_arg, RegisterArithmeticInfo)
         return RegisterArithmeticInfo(
-            size=self.actual_result_size(),
-            fraction_places=self.arg.fraction_places,
-            is_signed=self.arg.is_signed and self._include_sign,
+            size=self.output_size or eff_arg.size,
+            fraction_places=eff_arg.fraction_places,
+            is_signed=eff_arg.is_signed and self._include_sign,
         )
 
 
@@ -97,7 +91,7 @@ class Negation(UnaryOpParams):
         is_signed = max(self.arg.bounds) > 0 and self._include_sign
         bounds = (-max(self.arg.bounds), -min(self.arg.bounds))
         return RegisterArithmeticInfo(
-            size=self.actual_result_size(),
+            size=self.output_size or self._expected_result_size(),
             fraction_places=self.arg.fraction_places,
             is_signed=is_signed,
             bounds=bounds if (is_signed or min(bounds) >= 0) else None,
@@ -112,10 +106,7 @@ class Sign(UnaryOpParams):
         cls, output_size: Optional[pydantic.PositiveInt]
     ) -> pydantic.PositiveInt:
         if output_size is not None and output_size != 1:
-            raise ValueError("Sign output size must be 1")
-        return 1
-
-    def _expected_result_size(self) -> pydantic.PositiveInt:
+            raise ClassiqValueError("Sign output size must be 1")
         return 1
 
     def _get_result_register(self) -> RegisterArithmeticInfo:

classiq/interface/generator/chemistry_function_params.py

@@ -11,18 +11,18 @@ from classiq.interface.generator.function_params import (
     FunctionParams,
 )
 
+from classiq.exceptions import ClassiqValueError
+
 
 class ChemistryFunctionParams(FunctionParams):
-    gs_problem: CHEMISTRY_PROBLEMS_TYPE = pydantic.Field(
-        description="Ground state problem object describing the system."
-    )
+    gs_problem: CHEMISTRY_PROBLEMS_TYPE
 
     @pydantic.validator("gs_problem")
     def validate_gs_problem_contains_num_qubits(
         cls, gs_problem: CHEMISTRY_PROBLEMS_TYPE
     ) -> CHEMISTRY_PROBLEMS_TYPE:
         if not gs_problem.num_qubits:
-            raise ValueError(
+            raise ClassiqValueError(
                 "Ground state problem doesn't contain num_qubits. "
                 "Use update_problem method."
             )

classiq/interface/generator/commuting_pauli_exponentiation.py

@@ -10,6 +10,8 @@ from classiq.interface.generator.function_params import (
 )
 from classiq.interface.generator.parameters import ParameterFloatType
 
+from classiq.exceptions import ClassiqValueError
+
 
 class CommutingPauliExponentiation(FunctionParams):
     """
@@ -32,7 +34,7 @@ class CommutingPauliExponentiation(FunctionParams):
     @pydantic.validator("pauli_operator")
     def _validate_paulis_commute(cls, pauli_operator: PauliOperator) -> PauliOperator:
         if not pauli_operator.is_commutative:
-            raise ValueError("Pauli strings are not commutative")
+            raise ClassiqValueError("Pauli strings are not commutative")
         return pauli_operator
 
     def _create_ios(self) -> None:

classiq/interface/generator/compiler_keywords.py

@@ -0,0 +1,4 @@
+EXPANDED_KEYWORD = "expanded__"
+CAPTURE_SUFFIX = "_captured__"
+LAMBDA_KEYWORD = "lambda__"
+GENERAL_INPLACE_ARITHMETIC_AUXILIARY_VARIABLE = "result__temp__"

classiq/interface/generator/complex_type.py

@@ -1,17 +1,16 @@
-from typing import Any
+from typing import Any, Callable, Dict, Iterator
 
-import pydantic.json
 from typing_extensions import Self
 
 
 # Use this class as a type for complex data from the json, e.g., in the state_propagator function.
 class Complex(complex):
     @classmethod
-    def __get_validators__(cls):
+    def __get_validators__(cls) -> Iterator[Callable]:
         yield cls.validate
 
     @classmethod
-    def __modify_schema__(cls, field_schema):
+    def __modify_schema__(cls, field_schema: Dict[str, Any]) -> None:
         field_schema.update(
             pattern=r"[+-]?\d+\.?\d* *[+-] *\d+\.?\d*j",
         )
@@ -22,9 +21,3 @@ class Complex(complex):
             v = "".join(v.split())
 
         return cls(v)
-
-
-assert (
-    complex not in pydantic.json.ENCODERS_BY_TYPE
-), "Is complex type supported on newer version of pydantic?"
-pydantic.json.ENCODERS_BY_TYPE[complex] = str

classiq/interface/generator/control_state.py

@@ -7,6 +7,8 @@ from pydantic import BaseModel
 
 from classiq.interface.generator.arith.register_user_input import RegisterUserInput
 
+from classiq.exceptions import ClassiqValueError
+
 _DEFAULT_CONTROL_NAME: str = "ctrl"
 _DEFAULT_NUM_CONTROL_QUBITS = 1
 _INVALID_CONTROL_STATE = "invalid_control_state"
@@ -39,7 +41,7 @@ class ControlState(BaseModel):
             values["num_ctrl_qubits"] = num_ctrl_qubits
 
         if len(ctrl_state) != num_ctrl_qubits:
-            raise ValueError(
+            raise ClassiqValueError(
                 "Control state length should be equal to the number of control qubits"
             )
 
@@ -51,11 +53,11 @@ class ControlState(BaseModel):
     @staticmethod
     def validate_control_string(ctrl_state: str) -> None:
         if not set(ctrl_state) <= {"1", "0"}:
-            raise ValueError(
+            raise ClassiqValueError(
                 f"Control state can only be constructed from 0 and 1, received: {ctrl_state}"
             )
         if not ctrl_state:
-            raise ValueError("Control state cannot be empty")
+            raise ClassiqValueError("Control state cannot be empty")
 
     def __str__(self) -> str:
         return self.ctrl_state

classiq/interface/generator/credit_risk_example/linear_gci.py

@@ -1,5 +1,5 @@
 from statistics import NormalDist
-from typing import List, Tuple
+from typing import Any, Dict, List, Tuple
 
 import numpy as np
 import pydantic
@@ -11,6 +11,8 @@ from classiq.interface.helpers.custom_pydantic_types import (
     PydanticProbabilityFloat,
 )
 
+from classiq.exceptions import ClassiqValueError
+
 RHOS_PZEROS_LENGTH_ERROR_MSG = "rhos and p_zeros must have the same length"
 
 
@@ -42,10 +44,15 @@ class LinearGCI(function_params.FunctionParams):
     )
 
     @pydantic.validator("rhos")
-    def validate_rhos(cls, rhos, values):
+    def validate_rhos(
+        cls, rhos: List[PydanticNonOneProbabilityFloat], values: Dict[str, Any]
+    ) -> List[PydanticNonOneProbabilityFloat]:
         p_zeros = values.get("p_zeros")
+        if p_zeros is None:
+            raise ClassiqValueError("Cannot validate rhos, p_zeros is missing")
+
         if len(p_zeros) != len(rhos):
-            raise ValueError(RHOS_PZEROS_LENGTH_ERROR_MSG)
+            raise ClassiqValueError(RHOS_PZEROS_LENGTH_ERROR_MSG)
         return rhos
 
     @property

classiq/interface/generator/credit_risk_example/weighted_adder.py

@@ -1,4 +1,4 @@
-from typing import List
+from typing import Any, Dict, List, Optional
 
 import numpy as np
 import pydantic
@@ -7,6 +7,8 @@ from classiq.interface.generator import function_params
 from classiq.interface.generator.arith.register_user_input import RegisterUserInput
 from classiq.interface.generator.function_params import get_zero_input_name
 
+from classiq.exceptions import ClassiqValueError
+
 LENGTH_ERROR_MESSAGE = "Input length error: Length of weights vector has to be identical to the number of input qubits"
 STATE = "state"
 SUM = "sum"
@@ -33,12 +35,20 @@ class WeightedAdder(function_params.FunctionParams):
     )
 
     @pydantic.validator("weights", always=True, pre=True)
-    def validate_weights(cls, weights, values):
+    def validate_weights(
+        cls,
+        weights: Optional[List[PydanticStrictNonNegativeInteger]],
+        values: Dict[str, Any],
+    ) -> List[PydanticStrictNonNegativeInteger]:
         num_state_qubits = values.get("num_state_qubits")
+        if num_state_qubits is None:
+            raise ClassiqValueError(
+                "Missing num_state_qubits and weights, either must be provided"
+            )
         if weights is None:
-            return [1] * num_state_qubits
+            return [PydanticStrictNonNegativeInteger(1)] * num_state_qubits
         if len(weights) != num_state_qubits:
-            raise ValueError(LENGTH_ERROR_MESSAGE)
+            raise ClassiqValueError(LENGTH_ERROR_MESSAGE)
         return weights
 
     def num_sum_qubits(self) -> int:

classiq/interface/generator/expressions/atomic_expression_functions.py

@@ -3,9 +3,7 @@ SUPPORTED_BUILTIN_FUNCTIONS = {"len", "sum", "print"}
 SUPPORTED_ATOMIC_EXPRESSION_FUNCTIONS = {
     "hypercube_entangler_graph",
     "grid_entangler_graph",
-    "optimization_problem_to_hamiltonian",
-    "compute_qaoa_initial_point",
-    "get_optimization_solution",
+    "qft_const_adder_phase",
     "log_normal_finance_post_process",
     "gaussian_finance_post_process",
     "get_type",
@@ -16,5 +14,9 @@ SUPPORTED_ATOMIC_EXPRESSION_FUNCTIONS = {
     "molecule_problem_to_hamiltonian",
     "fock_hamiltonian_problem_to_hamiltonian",
     "molecule_ground_state_solution_post_process",
+    "BitwiseAnd",
+    "BitwiseXor",
+    "BitwiseNot",
+    "BitwiseOr",
     *SUPPORTED_BUILTIN_FUNCTIONS,
 }

classiq/interface/generator/expressions/evaluated_expression.py

@@ -1,8 +1,11 @@
+import re
 from dataclasses import dataclass
-from typing import Any, Mapping, Type
+from typing import Any, Mapping, Optional, Type
 
+from sympy import Expr
 from typing_extensions import get_args
 
+from classiq.interface.backend.pydantic_backend import EXECUTION_PARAMETER_PATTERN
 from classiq.interface.generator.expressions.expression_types import (
     ExpressionValue,
     QmodStructInstance,
@@ -17,15 +20,20 @@ from classiq.exceptions import ClassiqValueError
 class EvaluatedExpression:
     value: ExpressionValue
 
-    def is_constant(self) -> bool:
+    def is_constant(self, constant_type: Optional[Type] = None) -> bool:
         if self.value is None:
             return False
 
-        return isinstance(self.value, get_args(RuntimeConstant))
+        return isinstance(
+            self.value,
+            get_args(RuntimeConstant) if constant_type is None else constant_type,
+        )
 
     def as_constant_type(self, constant_type: Type) -> Any:
         if not self.is_constant():
-            raise ClassiqValueError(f"Invalid access to expression as {constant_type}")
+            raise ClassiqValueError(
+                f"Invalid access to expression {self.value!r} as {constant_type}"
+            )
 
         return constant_type(self.value)
 
@@ -62,3 +70,9 @@ class EvaluatedExpression:
             raise ClassiqValueError("Invalid access to unevaluated expression")
 
         return str(self.value)
+
+    def is_identifier(self) -> bool:
+        return (
+            isinstance(self.value, Expr)
+            and re.fullmatch(EXECUTION_PARAMETER_PATTERN, str(self.value)) is not None
+        )

classiq/interface/generator/expressions/expression.py

@@ -69,7 +69,7 @@ class Expression(HashablePydanticBaseModel):
             result = ast.literal_eval(self.expr)
             if isinstance(result, (int, float, bool)):
                 self._evaluated_expr = EvaluatedExpression(value=result)
-        except Exception:  # nosec B110
+        except Exception:  # noqa: S110
             pass
 
     @property

classiq/interface/generator/expressions/qmod_qscalar_proxy.py

@@ -0,0 +1,33 @@
+from sympy import Symbol
+
+from classiq.interface.generator.expressions.qmod_sized_proxy import QmodSizedProxy
+
+
+class QmodQScalarProxy(Symbol, QmodSizedProxy):
+    def __new__(cls, name, **assumptions):
+        return super().__new__(cls, name, **assumptions)
+
+    def __init__(self, name: str, size: int) -> None:
+        super().__init__(size)
+
+
+class QmodQBitProxy(QmodQScalarProxy):
+    pass
+
+
+class QmodQNumProxy(QmodQScalarProxy):
+
+    def __init__(
+        self, name: str, size: int, fraction_digits: int, is_signed: bool
+    ) -> None:
+        super().__init__(name, size)
+        self._fraction_digits = fraction_digits
+        self._is_signed = is_signed
+
+    @property
+    def fraction_digits(self) -> int:
+        return self._fraction_digits
+
+    @property
+    def is_signed(self) -> bool:
+        return self._is_signed

classiq/interface/generator/expressions/sympy_supported_expressions.py

@@ -34,6 +34,7 @@ MATHEMATICAL_FUNCTIONS: List[str] = [
     "ceiling",
     "Max",
     "Min",
+    "mod_inverse",
 ]
 SPECIAL_FUNCTIONS: List[str] = [
     "erf",
@@ -69,7 +70,7 @@ LOGIC_OPERATORS: List[str] = [
     "Nand",
     "Nor",
 ]
-RELATIONAL_OPERATORS: List[str] = ["<", "<=", ">", ">=", "!=", "<>", "Eq"]
+RELATIONAL_OPERATORS: List[str] = ["<", "<=", ">", ">=", "!=", "<>", "Eq", "Ne"]
 
 SYMPY_SUPPORTED_EXPRESSIONS: List[str] = (
     BASIC_ARITHMETIC_OPERATORS

classiq/interface/generator/finance.py

@@ -20,7 +20,7 @@ DEFAULT_POST_INPUT_NAME = "post_function_input"
 
 class Finance(function_params.FunctionParams):
     model: Union[GaussianModelInput, LogNormalModelInput] = pydantic.Field(
-        description="Load a financial model"
+        description="Load a financial model", discriminator="kind"
     )
     finance_function: FinanceFunctionInput = pydantic.Field(
         description="The finance function to solve the model"

classiq/interface/generator/function_params.py

@@ -30,6 +30,7 @@ from classiq.interface.helpers.hashable_pydantic_base_model import (
 )
 
 from classiq._internals.enum_utils import StrEnum
+from classiq.exceptions import ClassiqValueError
 
 FunctionParamsDiscriminator = str
 
@@ -84,7 +85,6 @@ ExecutionExpressionSupportedNodeTypes = Union[
 ]
 
 GenerationOnlyExpressionSupportedNodeTypes = Union[
-    ast.FloorDiv,
     ast.Pow,
     ast.List,
     ast.Subscript,
@@ -96,6 +96,7 @@ GenerationOnlyExpressionSupportedNodeTypes = Union[
     ast.Lt,
     ast.LtE,
     ast.Eq,
+    ast.NotEq,
     ast.Call,
     ast.Dict,
     ast.Slice,
@@ -243,7 +244,7 @@ class FunctionParams(HashablePydanticBaseModel):
         error_msg += self._get_error_msg(self._outputs, BAD_OUTPUT_REGISTER_ERROR_MSG)
         if error_msg:
             error_msg += [END_BAD_REGISTER_ERROR_MSG]
-            raise ValueError("\n".join(error_msg))
+            raise ClassiqValueError("\n".join(error_msg))
 
     @staticmethod
     def _sum_registers_sizes(registers: Iterable[RegisterArithmeticInfo]) -> int:
@@ -255,7 +256,7 @@ class FunctionParams(HashablePydanticBaseModel):
         )
         total_outputs_size = self._sum_registers_sizes(self._outputs.values())
         if total_inputs_size != total_outputs_size:
-            raise ValueError(REGISTER_SIZES_MISMATCH_ERROR_MSG)
+            raise ClassiqValueError(REGISTER_SIZES_MISMATCH_ERROR_MSG)
 
     def _get_error_msg(self, names: Iterable[IOName], msg: str) -> List[str]:
         bad_names = [name for name in names if re.fullmatch(NAME_REGEX, name) is None]
@@ -312,7 +313,7 @@ def parse_function_params(
             try:
                 return default_parser_class.parse_obj(params)
             except Exception:
-                raise bad_function_error
+                raise bad_function_error from None
         raise bad_function_error
 
     return matching_classes[0].parse_obj(params)
@@ -335,10 +336,10 @@ def parse_function_params_values(
         params=params,
         discriminator=discriminator,
         param_classes=param_classes,
-        no_discriminator_error=ValueError(
+        no_discriminator_error=ClassiqValueError(
             f"The {discriminator_key} {NO_DISCRIMINATOR_ERROR_MSG} {params_key} type."
         ),
-        bad_function_error=ValueError(
+        bad_function_error=ClassiqValueError(
             f"{BAD_FUNCTION_ERROR_MSG} {discriminator_key}: {discriminator}"
         ),
         default_parser_class=default_parser_class,

classiq/interface/generator/functions/__init__.py

@@ -1,7 +1,7 @@
 from typing import List
 
 import classiq.interface.generator.functions.core_lib_declarations.quantum_functions
-import classiq.interface.generator.functions.core_lib_declarations.quantum_operators  # noqa: F401
+import classiq.interface.generator.functions.core_lib_declarations.quantum_operators
 from classiq.interface.generator.functions.foreign_function_definition import *
 from classiq.interface.generator.functions.foreign_function_definition import (
     SynthesisForeignFunctionDefinition as ForeignFunctionDefinition,