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

classiq/interface/executor/optimizer_preferences.py

@@ -1,4 +1,4 @@
-from typing import List, Optional
+from typing import Any, Dict, List, Optional
 
 import pydantic
 from pydantic import BaseModel
@@ -6,6 +6,7 @@ from pydantic import BaseModel
 from classiq.interface.helpers.custom_pydantic_types import PydanticAlphaParamCVAR
 
 from classiq._internals.enum_utils import StrEnum
+from classiq.exceptions import ClassiqValueError
 
 
 class CostType(StrEnum):
@@ -33,10 +34,10 @@ class OptimizerPreferences(BaseModel):
     max_iteration: pydantic.PositiveInt = pydantic.Field(
         default=100, description="Maximal number of optimizer iterations"
     )
-    tolerance: pydantic.PositiveFloat = pydantic.Field(
+    tolerance: Optional[pydantic.PositiveFloat] = pydantic.Field(
         default=None, description="Final accuracy in the optimization"
     )
-    step_size: pydantic.PositiveFloat = pydantic.Field(
+    step_size: Optional[pydantic.PositiveFloat] = pydantic.Field(
         default=None,
         description="step size for numerically " "calculating the gradient",
     )
@@ -54,30 +55,36 @@ class OptimizerPreferences(BaseModel):
     )
 
     @pydantic.validator("tolerance", pre=True, always=True)
-    def check_tolerance(cls, tolerance, values):
+    def check_tolerance(
+        cls, tolerance: Optional[pydantic.PositiveFloat], values: Dict[str, Any]
+    ) -> Optional[pydantic.PositiveFloat]:
         optimizer_type = values.get("type")
         if tolerance is not None and optimizer_type == OptimizerType.SPSA:
-            raise ValueError("No tolerance param for SPSA optimizer")
+            raise ClassiqValueError("No tolerance param for SPSA optimizer")
 
         if tolerance is None and optimizer_type != OptimizerType.SPSA:
-            tolerance = 0.001
+            tolerance = pydantic.PositiveFloat(0.001)
 
         return tolerance
 
     @pydantic.validator("step_size", pre=True, always=True)
-    def check_step_size(cls, step_size, values):
+    def check_step_size(
+        cls, step_size: Optional[pydantic.PositiveFloat], values: Dict[str, Any]
+    ) -> Optional[pydantic.PositiveFloat]:
         optimizer_type = values.get("name")
         if step_size is not None and optimizer_type not in (
             OptimizerType.L_BFGS_B,
             OptimizerType.ADAM,
         ):
-            raise ValueError("Use step_size only for L_BFGS_B or ADAM optimizers.")
+            raise ClassiqValueError(
+                "Use step_size only for L_BFGS_B or ADAM optimizers."
+            )
 
         if step_size is None and optimizer_type in (
             OptimizerType.L_BFGS_B,
             OptimizerType.ADAM,
         ):
-            step_size = 0.05
+            step_size = pydantic.PositiveFloat(0.05)
 
         return step_size
 
@@ -91,7 +98,7 @@ class CombinatorialOptimizer(OptimizerPreferences):
         default=CostType.CVAR,
         description="Summarizing method of the measured bit strings",
     )
-    alpha_cvar: PydanticAlphaParamCVAR = pydantic.Field(
+    alpha_cvar: Optional[PydanticAlphaParamCVAR] = pydantic.Field(
         default=None, description="Parameter for the CVAR summarizing method"
     )
     is_maximization: bool = pydantic.Field(
@@ -104,12 +111,14 @@ class CombinatorialOptimizer(OptimizerPreferences):
     )
 
     @pydantic.validator("alpha_cvar", pre=True, always=True)
-    def check_alpha_cvar(cls, alpha_cvar, values):
+    def check_alpha_cvar(
+        cls, alpha_cvar: Optional[PydanticAlphaParamCVAR], values: Dict[str, Any]
+    ) -> Optional[PydanticAlphaParamCVAR]:
         cost_type = values.get("cost_type")
         if alpha_cvar is not None and cost_type != CostType.CVAR:
-            raise ValueError("Use CVAR params only for CostType.CVAR.")
+            raise ClassiqValueError("Use CVAR params only for CostType.CVAR.")
 
         if alpha_cvar is None and cost_type == CostType.CVAR:
-            alpha_cvar = 0.2
+            alpha_cvar = PydanticAlphaParamCVAR(0.2)
 
         return alpha_cvar

classiq/interface/executor/{quantum_program.py → quantum_code.py}

@@ -6,7 +6,7 @@ from typing import Any, Dict, Optional, Tuple, Union
 import pydantic
 from pydantic import BaseModel
 
-from classiq.interface.backend.ionq import ionq_quantum_program
+from classiq.interface.backend.ionq.ionq_quantum_program import IonqQuantumCircuit
 from classiq.interface.backend.pydantic_backend import PydanticArgumentNameType
 from classiq.interface.executor.quantum_instruction_set import QuantumInstructionSet
 from classiq.interface.executor.register_initialization import RegisterInitialization
@@ -14,15 +14,17 @@ from classiq.interface.generator.synthesis_metadata.synthesis_execution_data imp
     ExecutionData,
 )
 
+from classiq.exceptions import ClassiqValueError
+
 Arguments = Dict[PydanticArgumentNameType, Any]
 MultipleArguments = Tuple[Arguments, ...]
-CodeType = Union[str, ionq_quantum_program.IonqQuantumCircuit]
+CodeType = str
 RegistersInitialization = Dict[str, RegisterInitialization]
 Qubits = Tuple[int, ...]
 OutputQubitsMap = Dict[str, Qubits]
 
 
-class QuantumBaseProgram(BaseModel):
+class QuantumBaseCode(BaseModel):
     syntax: QuantumInstructionSet = pydantic.Field(
         default=QuantumInstructionSet.QASM, description="The syntax of the program."
     )
@@ -31,17 +33,21 @@ class QuantumBaseProgram(BaseModel):
     )
 
     @pydantic.validator("code")
-    def load_quantum_program(cls, code: CodeType, values: Dict[str, Any]) -> CodeType:
-        if not isinstance(code, str):
-            return code
-
+    def load_quantum_program(
+        cls, code: Union[CodeType, IonqQuantumCircuit], values: Dict[str, Any]
+    ) -> CodeType:
         syntax = values.get("syntax")
-        if syntax == QuantumInstructionSet.IONQ:
-            return ionq_quantum_program.IonqQuantumCircuit.from_string(code)
+        if isinstance(code, IonqQuantumCircuit):
+            if syntax != QuantumInstructionSet.IONQ:
+                raise ClassiqValueError(
+                    f"Invalid code type {type(code)} for syntax: {syntax}"
+                )
+            return code.json()
+
         return code
 
 
-class QuantumProgram(QuantumBaseProgram):
+class QuantumCode(QuantumBaseCode):
     arguments: MultipleArguments = pydantic.Field(
         default=(),
         description="The parameters dictionary for a parametrized quantum program.",
@@ -68,10 +74,10 @@ class QuantumProgram(QuantumBaseProgram):
             QuantumInstructionSet.QSHARP,
             QuantumInstructionSet.QASM,
         ):
-            raise ValueError("Only QASM or Q# programs support arguments")
+            raise ClassiqValueError("Only QASM or Q# programs support arguments")
 
         if values.get("syntax") == QuantumInstructionSet.QSHARP and len(arguments) > 1:
-            raise ValueError(
+            raise ClassiqValueError(
                 f"Q# programs supports only one group of arguments. {len(arguments)} given"
             )
 
@@ -87,7 +93,7 @@ class QuantumProgram(QuantumBaseProgram):
             synthesis_execution_data is not None
             and values.get("syntax") is not QuantumInstructionSet.QASM
         ):
-            raise ValueError("Only QASM supports the requested configuration")
+            raise ClassiqValueError("Only QASM supports the requested configuration")
 
         return synthesis_execution_data
 
@@ -96,9 +102,9 @@ class QuantumProgram(QuantumBaseProgram):
         file_path: Union[str, Path],
         syntax: Optional[Union[str, QuantumInstructionSet]] = None,
         arguments: MultipleArguments = (),
-    ) -> QuantumProgram:
+    ) -> QuantumCode:
         path = Path(file_path)
         code = path.read_text()
         if syntax is None:
             syntax = QuantumInstructionSet.from_suffix(path.suffix.lstrip("."))
-        return QuantumProgram(syntax=syntax, code=code, arguments=arguments)
+        return QuantumCode(syntax=syntax, code=code, arguments=arguments)

classiq/interface/executor/quantum_instruction_set.py

@@ -1,4 +1,5 @@
 from classiq._internals.enum_utils import StrEnum
+from classiq.exceptions import ClassiqValueError
 
 
 class QuantumInstructionSet(StrEnum):
@@ -14,4 +15,4 @@ class QuantumInstructionSet(StrEnum):
             return QuantumInstructionSet.QSHARP
         if suffix == "ionq":
             return QuantumInstructionSet.IONQ
-        raise ValueError("Illegal suffix")
+        raise ClassiqValueError("Illegal suffix")

classiq/interface/executor/register_initialization.py

@@ -30,9 +30,7 @@ class RegisterInitialization(pydantic.BaseModel):
         initial_condition: int = values.get("initial_condition", 0)
         name: str = values.get("name", "")
 
-        initial_condition_length = number_utils.size(
-            initial_condition, machine_precision=number_utils.MAX_FRACTION_PLACES
-        )
+        initial_condition_length = number_utils.size(initial_condition)
         register_length = len(qubits)
         if initial_condition_length > register_length:
             raise ClassiqStateInitializationError(

classiq/interface/executor/result.py

@@ -17,7 +17,7 @@ import pydantic
 from pydantic import BaseModel
 from typing_extensions import TypeAlias
 
-from classiq.interface.executor.quantum_program import OutputQubitsMap, Qubits
+from classiq.interface.executor.quantum_code import OutputQubitsMap, Qubits
 from classiq.interface.generator.arith import number_utils
 from classiq.interface.generator.complex_type import Complex
 from classiq.interface.generator.functions.classical_type import QmodPyObject
@@ -44,6 +44,9 @@ class SampledState(BaseModel):
     state: ParsedState
     shots: MeasuredShots
 
+    def __repr__(self) -> str:
+        return f"{self.state}: {self.shots}"
+
 
 ParsedCounts: TypeAlias = List[SampledState]
 
@@ -97,6 +100,28 @@ def get_sampled_state(
     return None
 
 
+def reduce_parsed_states(
+    parsed_states: ParsedStates, outputs: Tuple[Name, ...]
+) -> ParsedStates:
+    return {
+        state: {
+            output: value for output, value in parsed_state.items() if output in outputs
+        }
+        for state, parsed_state in parsed_states.items()
+    }
+
+
+def get_parsed_counts(counts: Counts, parsed_states: ParsedStates) -> ParsedCounts:
+    parsed_counts: ParsedCounts = []
+    for bitstring, count in counts.items():
+        parsed_state = parsed_states[bitstring]
+        if sampled_state := get_sampled_state(parsed_counts, parsed_state):
+            sampled_state.shots += count
+        else:
+            parsed_counts.append(SampledState(state=parsed_state, shots=count))
+    return sorted(parsed_counts, key=lambda k: k.shots, reverse=True)
+
+
 class ExecutionDetails(BaseModel, QmodPyObject):
     vendor_format_result: Dict[str, Any] = pydantic.Field(
         ..., description="Result in proprietary vendor format"
@@ -155,14 +180,7 @@ class ExecutionDetails(BaseModel, QmodPyObject):
 
     @property
     def parsed_counts(self) -> ParsedCounts:
-        parsed_counts: ParsedCounts = []
-        for bitstring, count in self.counts.items():
-            parsed_state = self.parsed_states[bitstring]
-            if sampled_state := get_sampled_state(parsed_counts, parsed_state):
-                sampled_state.shots += count
-            else:
-                parsed_counts.append(SampledState(state=parsed_state, shots=count))
-        return sorted(parsed_counts, key=lambda k: k.shots, reverse=True)
+        return get_parsed_counts(self.counts, self.parsed_states)
 
     @property
     def parsed_state_vector(self) -> Optional[ParsedStateVector]:
@@ -223,6 +241,17 @@ class ExecutionDetails(BaseModel, QmodPyObject):
             reduced_counts[reduced_strs] += state_count
         return dict(reduced_counts)
 
+    def parsed_counts_of_outputs(
+        self, output_names: Union[Name, Tuple[Name, ...]]
+    ) -> ParsedCounts:
+        if isinstance(output_names, Name):
+            output_names = (output_names,)
+        if any(name not in self.output_qubits_map for name in output_names):
+            raise ClassiqError(_UNAVAILABLE_OUTPUT_ERROR_MSG)
+
+        reduced_parsed_states = reduce_parsed_states(self.parsed_states, output_names)
+        return get_parsed_counts(self.counts, reduced_parsed_states)
+
     def register_output_from_qubits(self, qubits: Tuple[int, ...]) -> Dict[float, int]:
         register_output: Dict[float, int] = {}
         value_from_str_bin = functools.partial(
@@ -273,7 +302,9 @@ class EstimationResults(VersionedModel):
     def __len__(self) -> int:
         return len(self.results)
 
-    def __iter__(self) -> Iterator[EstimationResult]:  # type: ignore
+    def __iter__(self) -> Iterator[EstimationResult]:  # type: ignore[override]
+        # TODO This is a bug waiting to happen. We change the meaning of
+        # __iter__ in a derived class.
         return iter(self.results)
 
     def __getitem__(self, index: int) -> EstimationResult:

classiq/interface/executor/vqe_result.py

@@ -18,7 +18,7 @@ Solution = Tuple[int, ...]
 class SolverResult(BaseModel):
     energy: float
     # TODO: add time units (like seconds)
-    time: Optional[float]
+    time: Optional[float] = None
     solution: Optional[Solution]
 
 

classiq/interface/finance/function_input.py

@@ -3,12 +3,15 @@ from typing import Any, Dict, Optional, Union
 import pydantic
 
 from classiq.interface.generator.expressions.enums.finance_functions import (
+    FINANCE_FUNCTION_STRING,
     FinanceFunctionType,
 )
 from classiq.interface.helpers.custom_pydantic_types import (
     PydanticNonZeroProbabilityFloat,
 )
 
+from classiq.exceptions import ClassiqValueError
+
 
 class FunctionCondition(pydantic.BaseModel):
     threshold: float
@@ -22,8 +25,9 @@ class FunctionCondition(pydantic.BaseModel):
 
 
 class FinanceFunctionInput(pydantic.BaseModel):
-    f: Union[int, str, FinanceFunctionType] = pydantic.Field(
-        description="A callable function to solve the model"
+    f: FinanceFunctionType = pydantic.Field(
+        description="An enumeration of the wanted financial function: VaR, expected "
+        "shortfall, European call options or x^2"
     )
     variable: str = pydantic.Field(
         default="x", description="Variable/s of the function"
@@ -45,13 +49,20 @@ class FinanceFunctionInput(pydantic.BaseModel):
         description="The required probability on the tail of the distribution (1 - percentile)",
     )
 
+    @pydantic.validator("f", pre=True)
+    def _convert_f_if_str(cls, f: Any) -> FinanceFunctionType:
+        # Keep this for backwards-compatible string support
+        if f in FINANCE_FUNCTION_STRING:
+            return FINANCE_FUNCTION_STRING[f]
+        return f
+
     @pydantic.validator("use_chebyshev_polynomial_approximation")
     def _validate_polynomial_flag(
         cls, use_chebyshev_flag: bool, values: Dict[str, Any]
     ) -> bool:
         if use_chebyshev_flag ^ (values.get("polynomial_degree") is None):
             return use_chebyshev_flag
-        raise ValueError(
+        raise ClassiqValueError(
             "Degree must be positive and use_chebyshev_polynomial_approximation set to True"
         )
 
@@ -72,7 +83,9 @@ class FinanceFunctionInput(pydantic.BaseModel):
         values: Dict[str, Any],
     ) -> Optional[PydanticNonZeroProbabilityFloat]:
         if values.get("f") == FinanceFunctionType.SHORTFALL and not tail_probability:
-            raise ValueError("Tail probability must be set for expected shortfall")
+            raise ClassiqValueError(
+                "Tail probability must be set for expected shortfall"
+            )
         return tail_probability
 
     class Config:

classiq/interface/finance/gaussian_model_input.py

@@ -1,5 +1,5 @@
 import math
-from typing import List, Optional, Tuple
+from typing import List, Literal, Optional, Tuple
 
 import pydantic
 
@@ -8,6 +8,8 @@ from classiq.interface.helpers.custom_pydantic_types import PydanticProbabilityF
 
 
 class GaussianModelInput(FinanceModelInput):
+    kind: Literal["gaussian"] = pydantic.Field(default="gaussian")
+
     num_qubits: pydantic.PositiveInt = pydantic.Field(
         description="The number of qubits represent"
         "the latent normal random variable Z (Resolution of "

classiq/interface/finance/log_normal_model_input.py

@@ -1,4 +1,4 @@
-from typing import Tuple
+from typing import Literal, Tuple
 
 import numpy as np
 import pydantic
@@ -7,6 +7,8 @@ from classiq.interface.finance.model_input import FinanceModelInput
 
 
 class LogNormalModelInput(FinanceModelInput):
+    kind: Literal["log_normal"] = pydantic.Field(default="log_normal")
+
     num_qubits: pydantic.PositiveInt = pydantic.Field(
         description="Number of qubits to represent the probability."
     )

classiq/interface/finance/model_input.py

@@ -7,6 +7,8 @@ from classiq.interface.helpers.hashable_pydantic_base_model import (
 
 
 class FinanceModelInput(HashablePydanticBaseModel):
+    kind: str
+
     @property
     def num_output_qubits(self) -> int:
         return 0

classiq/interface/generator/amplitude_loading.py

@@ -20,6 +20,7 @@ from classiq.interface.generator.function_params import (
 from classiq.interface.helpers.custom_pydantic_types import PydanticExpressionStr
 
 from classiq._internals.enum_utils import StrEnum
+from classiq.exceptions import ClassiqValueError
 
 AMPLITUDE_IO_NAME = "AMPLITUDE"
 TARGET_OUTPUT_NAME = "TARGET"
@@ -66,14 +67,17 @@ class AmplitudeLoading(FunctionParams):
         not_allowed = literals.intersection(FORBIDDEN_LITERALS)
         variables = literals.difference(SUPPORTED_FUNC_NAMES)
         if not_allowed:
-            raise ValueError(f"The following names: {not_allowed} are not allowed")
+            raise ClassiqValueError(
+                f"The following names: {not_allowed} are not allowed"
+            )
 
         if len(variables) != 1:
-            raise ValueError(f"{variables} must contain exactly single variable")
+            raise ClassiqValueError(f"{variables} must contain exactly single variable")
         return values
 
     def _create_ios(self) -> None:
         self._inputs = {
+            TARGET_OUTPUT_NAME: RegisterUserInput(name=TARGET_OUTPUT_NAME, size=1),
             AMPLITUDE_IO_NAME: RegisterUserInput(
                 name=AMPLITUDE_IO_NAME, size=self.size
             ),
@@ -82,7 +86,6 @@ class AmplitudeLoading(FunctionParams):
             TARGET_OUTPUT_NAME: RegisterUserInput(name=TARGET_OUTPUT_NAME, size=1),
             **self._inputs,
         }
-        self._create_zero_input_registers({TARGET_OUTPUT_NAME: 1})
 
     @property
     def variable(self) -> str:

classiq/interface/generator/application_apis/__init__.py

@@ -2,6 +2,7 @@ from classiq.interface.generator.builtin_api_builder import (
     populate_builtin_declarations,
 )
 
+from .arithmetic_declarations import *  # noqa: F403
 from .chemistry_declarations import *  # noqa: F403
 from .combinatorial_optimization_declarations import *  # noqa: F403
 from .entangler_declarations import *  # noqa: F403

classiq/interface/generator/application_apis/arithmetic_declarations.py

@@ -0,0 +1,14 @@
+from classiq.interface.generator.functions.classical_function_declaration import (
+    ClassicalFunctionDeclaration,
+)
+from classiq.interface.generator.functions.classical_type import Integer, Real
+
+qft_const_adder_phase = ClassicalFunctionDeclaration(
+    name="qft_const_adder_phase",
+    param_decls={
+        "bit_index": Integer(),
+        "value": Integer(),
+        "reg_len": Integer(),
+    },
+    return_type=Real(),
+)

classiq/interface/generator/arith/argument_utils.py

@@ -6,10 +6,10 @@ from classiq.interface.generator.arith.register_user_input import RegisterArithm
 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 +18,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:
@@ -46,3 +46,13 @@ 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=machine_precision
+    )

classiq/interface/generator/arith/arithmetic.py

@@ -21,6 +21,8 @@ from classiq.interface.model.quantum_type import (
     register_info_to_quantum_type,
 )
 
+from classiq.exceptions import ClassiqValueError
+
 ARITHMETIC_EXPRESSION_TARGET_NAME: str = "arithmetic_target"
 ARITHMETIC_EXPRESSION_RESULT_NAME: str = "expression_result"
 
@@ -47,7 +49,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 = {

classiq/interface/generator/arith/arithmetic_arg_type_validator.py

@@ -2,23 +2,16 @@ from typing import Callable, Dict, List
 
 from typing_extensions import TypeAlias
 
-from classiq.interface.generator.arith.argument_utils import (
-    RegisterOrConst,
-    fraction_places,
-)
+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)
 
 
@@ -30,8 +23,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)

classiq/interface/generator/arith/arithmetic_expression_abc.py

@@ -17,6 +17,9 @@ from classiq.interface.generator.arith.arithmetic_expression_validator import (
 from classiq.interface.generator.arith.arithmetic_result_builder import (
     validate_arithmetic_result_type,
 )
+from classiq.interface.generator.arith.machine_precision import (
+    DEFAULT_MACHINE_PRECISION,
+)
 from classiq.interface.generator.arith.register_user_input import RegisterArithmeticInfo
 from classiq.interface.generator.arith.uncomputation_methods import UncomputationMethods
 from classiq.interface.generator.expressions.expression_constants import (
@@ -36,7 +39,7 @@ ValidDefinitions: TypeAlias = Union[
 
 class ArithmeticExpressionABC(abc.ABC, FunctionParams):
     uncomputation_method: UncomputationMethods = UncomputationMethods.optimized
-    machine_precision: pydantic.NonNegativeInt = number_utils.MAX_FRACTION_PLACES
+    machine_precision: pydantic.NonNegativeInt = DEFAULT_MACHINE_PRECISION
     expression: PydanticExpressionStr
     definitions: Dict[str, ValidDefinitions]
     qubit_count: Optional[pydantic.NonNegativeInt] = None

classiq/interface/generator/arith/arithmetic_expression_parser.py

@@ -19,7 +19,9 @@ from classiq.interface.generator.arith.ast_node_rewrite import (
 from classiq.exceptions import ClassiqArithmeticError
 
 _MULTIPLE_RESULTS_ERROR_MESSAGE: str = "Expression cannot contain multiple result"
-_TRIVIAL_ARITHMETIC_ERROR_MESSAGE: str = "Expression must be nontrivial"
+_UNEXPECTED_ARITHMETIC_ERROR_MESSAGE: str = (
+    "Unexpected arithmetic error: trivial expression. Please contact support."
+)
 _ALLOWED_MULTI_ARGUMENT_FUNCTIONS = ("min", "max")
 Node = Union[str, float, int]
 
@@ -34,6 +36,10 @@ class ExpressionVisitor(ExpressionValidator):
         super().__init__(supported_nodes, expression_type, supported_functions)
         self.graph = nx.DiGraph()
 
+    @classmethod
+    def rewrite_ast(cls, expression_ast: AST) -> AST:
+        return AstNodeRewrite().visit(expression_ast)
+
     def visit_Compare(self, node: ast.Compare) -> None:
         self.validate_Compare(node)
         self.update_graph(node, node.left, node.comparators[0])
@@ -122,7 +128,7 @@ class InDegreeLimiter:
         if num_results > 1:
             raise ClassiqArithmeticError(_MULTIPLE_RESULTS_ERROR_MESSAGE)
         elif num_results == 0:
-            raise ClassiqArithmeticError(_TRIVIAL_ARITHMETIC_ERROR_MESSAGE)
+            raise ClassiqArithmeticError(_UNEXPECTED_ARITHMETIC_ERROR_MESSAGE)
         return graph