classiq 0.87.0__py3-none-any.whl → 0.88.0__py3-none-any.whl

classiq/execution/execution_session.py

@@ -340,6 +340,7 @@ class ExecutionSession:
         initial_params: ExecutionParams,
         max_iteration: int,
         quantile: float = 1.0,
+        tolerance: Optional[float] = None,
     ) -> list[tuple[float, ExecutionParams]]:
         """
         Minimizes the given cost function using the quantum program.
@@ -355,6 +356,7 @@ class ExecutionSession:
                     - The value is either a float or a list of floats.
             max_iteration: The maximum number of iterations for the minimization.
             quantile: The quantile to use for cost estimation.
+            tolerance: The tolerance for the minimization.
         Returns:
             A list of tuples, each containing the estimated cost and the corresponding parameters for that iteration.
             `cost` is a float, and `parameters` is a dictionary matching the execution parameter format.
@@ -365,6 +367,7 @@ class ExecutionSession:
             initial_params=initial_params,
             max_iteration=max_iteration,
             quantile=quantile,
+            tolerance=tolerance,
             _check_deprecation=False,
         )
         result = job.get_minimization_result(_http_client=self._async_client)
@@ -379,6 +382,7 @@ class ExecutionSession:
         initial_params: ExecutionParams,
         max_iteration: int,
         quantile: float = 1.0,
+        tolerance: Optional[float] = None,
         *,
         _check_deprecation: bool = True,
     ) -> ExecutionJob:
@@ -400,6 +404,7 @@ class ExecutionSession:
                     - The value is either a float or a list of floats.
             max_iteration: The maximum number of iterations for the minimization.
             quantile: The quantile to use for cost estimation.
+            tolerance: The tolerance for the minimization.
 
         Returns:
             The execution job.
@@ -424,6 +429,7 @@ class ExecutionSession:
                 initial_params=_initial_params,
                 max_iteration=max_iteration,
                 quantile=quantile,
+                tolerance=tolerance,
             )
         else:
             _cost_function = self._hamiltonian_to_pauli_operator(cost_function)
@@ -432,6 +438,7 @@ class ExecutionSession:
                 initial_params=_initial_params,
                 max_iteration=max_iteration,
                 quantile=quantile,
+                tolerance=tolerance,
             )
 
         execution_primitives_input = PrimitivesInput(minimize=minimize)
@@ -545,10 +552,18 @@ class ExecutionSession:
             name: create_qvar_from_quantum_type(reg.quantum_types, name)
             for name, reg in circuit_output_types.items()
         }
-        for name in inspect.signature(qmod_expression_creator).parameters.keys():
+        creator_parameters = inspect.signature(
+            qmod_expression_creator
+        ).parameters.keys()
+        for name in creator_parameters:
             if name not in symbolic_output:
                 raise ClassiqValueError(
-                    f"The provided QVar: {name} does not match the model outputs: {tuple(circuit_output_types.keys())}. "
+                    f"Expected cost function with parameters {tuple(symbolic_output.keys())} corresponding to the quantum program outputs, but found '{name}'. "
+                )
+        for name in symbolic_output:
+            if name not in creator_parameters:
+                raise ClassiqValueError(
+                    f"Expected cost function with parameter '{name}' corresponding to the quantum program outputs. "
                 )
 
         qmod_expression = qmod_expression_creator(**symbolic_output)

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

classiq/interface/execution/primitives.py

@@ -17,6 +17,7 @@ class MinimizeCostInput(BaseModel, json_encoders=CUSTOM_ENCODERS):
     initial_params: Arguments
     max_iteration: int
     quantile: float
+    tolerance: Optional[float]
 
 
 class MinimizeClassicalCostInput(MinimizeCostInput):

classiq/interface/generator/application_apis/__init__.py

@@ -6,7 +6,6 @@ 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
-from .finance_declarations import *  # noqa: F403
 from .qsvm_declarations import *  # noqa: F403
 
 populate_builtin_declarations(vars().values())

classiq/interface/generator/expressions/atomic_expression_functions.py

@@ -4,8 +4,6 @@ CLASSIQ_BUILTIN_CLASSICAL_FUNCTIONS = {
     "hypercube_entangler_graph",
     "grid_entangler_graph",
     "qft_const_adder_phase",
-    "log_normal_finance_post_process",
-    "gaussian_finance_post_process",
     "molecule_problem_to_hamiltonian",
     "fock_hamiltonian_problem_to_hamiltonian",
     "molecule_ground_state_solution_post_process",

classiq/interface/generator/function_param_list.py

@@ -33,7 +33,6 @@ from classiq.interface.generator.entangler_params import (
     HypercubeEntangler,
     TwoDimensionalEntangler,
 )
-from classiq.interface.generator.finance import Finance, FinanceModels, FinancePayoff
 from classiq.interface.generator.function_param_library import FunctionParamLibrary
 from classiq.interface.generator.hadamard_transform import HadamardTransform
 from classiq.interface.generator.hamiltonian_evolution.exponentiation import (
@@ -106,9 +105,6 @@ function_param_library: FunctionParamLibrary = FunctionParamLibrary(
             CyclicShift,
             Modulo,
             TwoDimensionalEntangler,
-            Finance,
-            FinanceModels,
-            FinancePayoff,
             HypercubeEntangler,
             GridEntangler,
             Mcx,

classiq/interface/generator/functions/classical_type.py

@@ -144,6 +144,14 @@ class ClassicalArray(ClassicalType):
     def has_length(self) -> bool:
         return self.length is not None and self.length.is_evaluated()
 
+    @property
+    def has_constant_length(self) -> bool:
+        return (
+            self.length is not None
+            and self.length.is_evaluated()
+            and self.length.is_constant()
+        )
+
     @property
     def length_value(self) -> int:
         if not self.has_length:

classiq/interface/generator/functions/type_name.py

@@ -101,6 +101,12 @@ class TypeName(ClassicalType, QuantumType):
             field_type.is_evaluated for field_type in self.fields.values()
         )
 
+    @property
+    def is_constant(self) -> bool:
+        return self.has_fields and all(
+            field_type.is_constant for field_type in self.fields.values()
+        )
+
     @property
     def has_classical_struct_decl(self) -> bool:
         return self._classical_struct_decl is not None

classiq/interface/generator/transpiler_basis_gates.py

@@ -57,11 +57,15 @@ EXTRA_TWO_QUBIT_GATES: BasisGates = frozenset(
     )
 )
 
+NON_UNITARY_GATES: BasisGates = frozenset(("if_else",))
+
 TWO_QUBIT_GATES = BASIC_TWO_QUBIT_GATES | EXTRA_TWO_QUBIT_GATES
 
 THREE_QUBIT_GATES: BasisGates = frozenset(("ccx", "cswap"))
 DEFAULT_BASIS_GATES: BasisGates = SINGLE_QUBIT_GATES | BASIC_TWO_QUBIT_GATES
-ALL_GATES: BasisGates = SINGLE_QUBIT_GATES | TWO_QUBIT_GATES | THREE_QUBIT_GATES
+ALL_GATES: BasisGates = (
+    SINGLE_QUBIT_GATES | TWO_QUBIT_GATES | THREE_QUBIT_GATES | NON_UNITARY_GATES
+)
 
 ROUTING_TWO_QUBIT_BASIS_GATES: BasisGates = frozenset(
     ("cx", "ecr", "rzx", "ryy", "rxx", "rzz", "cy", "cz", "cp", "swap")

classiq/interface/generator/types/builtin_enum_declarations.py

@@ -132,13 +132,6 @@ class FermionMapping(IntEnum):
     FAST_BRAVYI_KITAEV = 3
 
 
-class FinanceFunctionType(IntEnum):
-    VAR = 0
-    SHORTFALL = 1
-    X_SQUARE = 2
-    EUROPEAN_CALL_OPTION = 3
-
-
 class LadderOperator(IntEnum):
     PLUS = 0
     MINUS = 1
@@ -171,7 +164,6 @@ class QSVMFeatureMapEntanglement(IntEnum):
 __all__ = [
     "Element",
     "FermionMapping",
-    "FinanceFunctionType",
     "LadderOperator",
     "Optimizer",
     "Pauli",

classiq/interface/model/classical_if.py

@@ -3,6 +3,8 @@ import operator
 from collections.abc import Mapping
 from typing import TYPE_CHECKING, Literal
 
+import pydantic
+
 from classiq.interface.ast_node import ASTNodeType, reset_lists
 from classiq.interface.generator.expressions.expression import Expression
 from classiq.interface.model.handle_binding import ConcreteHandleBinding, HandleBinding
@@ -18,6 +20,9 @@ class ClassicalIf(QuantumOperation):
     condition: Expression
     then: "StatementBlock"
     else_: "StatementBlock"
+    _condition_wiring_inouts: dict[str, HandleBinding] = pydantic.PrivateAttr(
+        default_factory=dict
+    )
 
     def _as_back_ref(self: ASTNodeType) -> ASTNodeType:
         return reset_lists(self, ["then", "else_"])
@@ -40,14 +45,17 @@ class ClassicalIf(QuantumOperation):
 
     @property
     def wiring_inouts(self) -> Mapping[str, ConcreteHandleBinding]:
-        return functools.reduce(
-            operator.ior,
-            (
-                op.wiring_inouts
-                for op in (*self.then, *self.else_)
-                if isinstance(op, QuantumOperation)
-            ),
-            dict(),
+        return (
+            functools.reduce(
+                operator.ior,
+                (
+                    op.wiring_inouts
+                    for op in (*self.then, *self.else_)
+                    if isinstance(op, QuantumOperation)
+                ),
+                dict(),
+            )
+            | self._condition_wiring_inouts
         )
 
     @property

classiq/interface/model/classical_parameter_declaration.py

@@ -33,6 +33,10 @@ class AnonClassicalParameterDeclaration(Parameter):
             }
         )
 
+    @property
+    def qmod_type_name(self) -> str:
+        return self.classical_type.qmod_type_name
+
 
 class ClassicalParameterDeclaration(AnonClassicalParameterDeclaration):
     name: str

classiq/interface/model/port_declaration.py

@@ -44,6 +44,18 @@ class AnonPortDeclaration(Parameter):
             raise ClassiqInternalError
         return PortDeclaration(**{**self.__dict__, "name": new_name})
 
+    @property
+    def qmod_type_name(self) -> str:
+        prefix = ""
+        suffix = ""
+        if self.type_modifier in (TypeModifier.Const, TypeModifier.Permutable):
+            prefix += f"{self.type_modifier.name}["
+            suffix += "]"
+        if self.direction != PortDeclarationDirection.Inout:
+            prefix += f"{self.direction.name}["
+            suffix += "]"
+        return f"{prefix}{self.quantum_type.qmod_type_name}{suffix}"
+
 
 class PortDeclaration(AnonPortDeclaration):
     name: str

classiq/interface/model/quantum_function_declaration.py

@@ -190,6 +190,18 @@ class AnonQuantumOperandDeclaration(AnonQuantumFunctionDeclaration):
     def is_generative(self) -> bool:
         return self._is_generative
 
+    @property
+    def qmod_type_name(self) -> str:
+        if self.is_list:
+            type_name = "QCallableList"
+        else:
+            type_name = "QCallable"
+        if len(self.positional_arg_declarations) == 0:
+            params = ""
+        else:
+            params = f"[{', '.join(param.qmod_type_name for param in self.positional_arg_declarations)}]"
+        return f"{type_name}{params}"
+
 
 AnonQuantumFunctionDeclaration.model_rebuild()
 

classiq/interface/model/quantum_type.py

@@ -84,6 +84,10 @@ class QuantumType(HashableASTNode):
     def is_evaluated(self) -> bool:
         raise NotImplementedError
 
+    @property
+    def is_constant(self) -> bool:
+        raise NotImplementedError
+
     @property
     def expressions(self) -> list[Expression]:
         return []
@@ -109,6 +113,9 @@ class QuantumScalar(QuantumType):
     def fraction_digits_value(self) -> int:
         raise NotImplementedError
 
+    def get_bounds(self) -> Optional[tuple[float, float]]:
+        return None
+
     def get_effective_bounds(
         self, machine_precision: Optional[int] = None
     ) -> tuple[float, float]:
@@ -154,6 +161,10 @@ class QuantumBit(QuantumScalar):
     def is_evaluated(self) -> bool:
         return True
 
+    @property
+    def is_constant(self) -> bool:
+        return True
+
     @property
     def has_sign(self) -> bool:
         return True
@@ -257,6 +268,15 @@ class QuantumBitvector(QuantumType):
             and self.element_type.is_evaluated
         )
 
+    @property
+    def is_constant(self) -> bool:
+        return (
+            self.length is not None
+            and self.length.is_evaluated()
+            and self.length.is_constant()
+            and self.element_type.is_constant
+        )
+
     @property
     def expressions(self) -> list[Expression]:
         exprs = self.element_type.expressions
@@ -311,6 +331,14 @@ class QuantumNumeric(QuantumScalar):
     def has_sign(self) -> bool:
         return self.is_signed is not None
 
+    @property
+    def has_constant_sign(self) -> bool:
+        return (
+            self.is_signed is not None
+            and self.is_signed.is_evaluated()
+            and self.is_signed.is_constant()
+        )
+
     @property
     def sign_value(self) -> bool:
         return False if self.is_signed is None else self.is_signed.to_bool_value()
@@ -319,6 +347,14 @@ class QuantumNumeric(QuantumScalar):
     def has_fraction_digits(self) -> bool:
         return self.fraction_digits is not None
 
+    @property
+    def has_constant_fraction_digits(self) -> bool:
+        return (
+            self.fraction_digits is not None
+            and self.fraction_digits.is_evaluated()
+            and self.fraction_digits.is_constant()
+        )
+
     @property
     def fraction_digits_value(self) -> int:
         return (
@@ -388,6 +424,26 @@ class QuantumNumeric(QuantumScalar):
             self.fraction_digits is not None and not self.fraction_digits.is_evaluated()
         )
 
+    @property
+    def is_constant(self) -> bool:
+        if (
+            self.size is None
+            or not self.size.is_evaluated()
+            or not self.size.is_constant()
+        ):
+            return False
+        if self.is_signed is not None and (
+            not self.is_signed.is_evaluated() or not self.is_signed.is_constant()
+        ):
+            return False
+        return not (
+            self.fraction_digits is not None
+            and (
+                not self.fraction_digits.is_evaluated()
+                or not self.fraction_digits.is_constant()
+            )
+        )
+
     @property
     def expressions(self) -> list[Expression]:
         exprs = []

classiq/interface/pretty_print/expression_to_qmod.py

@@ -141,24 +141,10 @@ class ASTToQMODCode:
                 if len(node.args) != 2:
                     raise PrettyPrinterError("Error parsing array access.")
                 return f"{self.ast_to_code(node.args[0])}[{self.ast_to_code(node.args[1])}]"
-            elif len(node.keywords) > 0:
-                # struct instance
-                keywords = node.keywords
-                initializer_list = self.indent_items(
-                    lambda: [
-                        f"{keyword.arg}={self._cleaned_ast_to_code(keyword.value)}"
-                        for keyword in keywords
-                        if keyword.arg is not None
-                    ]
-                )
-                return f"{func} {{{initializer_list}}}"
             else:
-                args = [self._cleaned_ast_to_code(arg) for arg in node.args]
-                kwargs = [
-                    f"{kwarg.arg}={self._cleaned_ast_to_code(kwarg.value)}"
-                    for kwarg in node.keywords
-                ]
-                return "{}({})".format(func, ", ".join(args + kwargs))
+                return "{}({})".format(
+                    func, ", ".join(self._cleaned_ast_to_code(arg) for arg in node.args)
+                )
         elif isinstance(node, ast.Expr):
             return self._cleaned_ast_to_code(node.value)
         else:

classiq/model_expansions/quantum_operations/allocate.py

@@ -78,7 +78,7 @@ class AllocateEmitter(Emitter[Allocate]):
         target: QuantumSymbol,
         op_update_dict: dict[str, Expression],
     ) -> None:
-        if target.quantum_type.is_evaluated:
+        if target.quantum_type.has_size_in_bits:
             expr = str(target.quantum_type.size_in_bits)
         elif self._allow_symbolic_attrs:
             expr = f"{target.handle}.size"

classiq/model_expansions/quantum_operations/handle_evaluator.py

@@ -19,11 +19,5 @@ class HandleEvaluator(Emitter[QuantumOperation]):
         if not isinstance(handle, HandleBinding):
             return False
         evaluated_handle = self._interpreter.evaluate(handle).value.handle.collapse()
-        if handle == evaluated_handle:
-            return False
-        op = op.model_copy(
-            update={self._handle_name: evaluated_handle, "back_ref": op.uuid}
-        )
-        self._interpreter.add_to_debug_info(op)
-        self._interpreter.emit(op)
-        return True
+        setattr(op, self._handle_name, evaluated_handle)
+        return False

classiq/open_library/functions/__init__.py

@@ -116,6 +116,7 @@ __all__ = [
     "prepare_exponential_state",
     "prepare_ghz_state",
     "prepare_int",
+    "prepare_linear_amplitudes",
     "prepare_uniform_interval_state",
     "prepare_uniform_trimmed_state",
     "projector_controlled_double_phase",

classiq/open_library/functions/lcu.py

@@ -3,7 +3,7 @@ from typing import Literal
 import numpy as np
 
 from classiq.open_library.functions.state_preparation import (
-    _load_phases,
+    apply_phase_table,
 )
 from classiq.open_library.functions.utility_functions import switch
 from classiq.qmod.builtins.functions import IDENTITY, X, Y, Z, inplace_prepare_state
@@ -73,7 +73,7 @@ def lcu(
                 iteration=lambda i: control(block == i, lambda: unitaries[i]()),
             ),
             # TODO: replace to sparse constant phase
-            _load_phases(phases, block),
+            apply_phase_table(phases, block),
         ],
     )
 

classiq/open_library/functions/state_preparation.py

@@ -13,8 +13,8 @@ from classiq.open_library.functions.utility_functions import (
 from classiq.qmod.builtins.functions import (
     CX,
     IDENTITY,
+    PHASE,
     RY,
-    RZ,
     H,
     X,
     inplace_prepare_amplitudes,
@@ -324,7 +324,7 @@ def _classical_hadamard_transform(arr: list[float]) -> np.ndarray:
 
 
 @qfunc
-def _load_phases(
+def apply_phase_table(
     phases: list[float],
     target: QArray[QBit, Literal["log(get_field(phases, 'len'), 2)"]],
 ) -> None:
@@ -333,10 +333,10 @@ def _load_phases(
     for i in range(1, len(alphas) - 1):
         gray = _graycode(i)
         next_gray = _graycode(i + 1)
-        RZ(alphas[gray], target[_msb(gray)])
+        PHASE(alphas[gray], target[_msb(gray)])
         CX(target[_control_qubit(i)], target[_msb(next_gray)])
 
-    RZ(alphas[_graycode(len(phases) - 1)], target[target.len - 1])
+    PHASE(alphas[_graycode(len(phases) - 1)], target[target.len - 1])
 
 
 @qfunc
@@ -358,7 +358,7 @@ def inplace_prepare_complex_amplitudes(
         target: The quantum variable to act upon.
     """
     inplace_prepare_amplitudes(magnitudes, 0, target)
-    _load_phases(phases, target)
+    apply_phase_table(phases, target)
 
 
 @qfunc
@@ -469,3 +469,45 @@ def prepare_basis_state(state: list[bool], arr: Output[QArray]) -> None:
     for idx, value in enumerate(state):
         if value:
             X(arr[idx])
+
+
+def linear_hadamard_walsh_coefficients(n: int) -> np.ndarray:
+    coeffs = np.zeros(n + 1)
+    coeffs[0] = 2 ** (n / 2) * ((2**n - 1) / 2)
+    for k in range(1, n + 1):
+        coeffs[k] = -(2 ** (k - 1 + n / 2) / 2)
+    return coeffs / np.linalg.norm(coeffs)
+
+
+@qfunc
+def _zero_ctrl_rot(ctrl: QNum, target: QBit, theta: CReal) -> None:
+    control(ctrl == 0, lambda: RY(theta, target))
+
+
+@qfunc
+def prepare_linear_amplitudes(x: QArray) -> None:
+    """ "
+    [Qmod Classiq-library function]
+
+    Initializes a quantum variable in a state with linear amplitudes:
+    $$|\\psi\rangle = \frac{1}{Z}\\sum_{x=0}^{2^n-1}{x|x\rangle}$$
+    Where $Z$ is a normalization constant.
+
+    Based on the paper https://quantum-journal.org/papers/q-2024-03-21-1297/pdf/
+
+    Args:
+        x: The quantum register to prepare.
+    """
+    coeffs = linear_hadamard_walsh_coefficients(x.size)  # type: ignore[arg-type]
+    thetas = np.zeros(x.size + 1)  # type: ignore[arg-type]
+    for i in range(x.size):  # type: ignore[arg-type]
+        thetas[i] = 2 * np.arcsin(
+            coeffs[i + 1] / np.sqrt(1 - np.linalg.norm(coeffs[1 : i + 1]) ** 2)
+        )
+    for k in range(x.len):
+        if k == 0:
+            RY(thetas[k], x[k])
+        else:
+            _zero_ctrl_rot(x[0:k], x[k], thetas[k])
+
+    hadamard_transform(x)

classiq/qmod/builtins/__init__.py

@@ -1,5 +1,3 @@
-from classiq.interface.finance.function_input import FinanceFunctionInput
-
 from .classical_execution_primitives import *  # noqa: F403
 from .classical_execution_primitives import (
     __all__ as _builtin_classical_execution_primitives,
@@ -17,7 +15,6 @@ from .operations import __all__ as _builtin_operations
 from .structs import *  # noqa: F403
 from .structs import __all__ as _builtin_structs
 
-FinanceFunctionInput.model_rebuild()
 BUILTIN_CONSTANTS = [
     constant._get_constant_node()
     for constant in [

classiq/qmod/builtins/classical_functions.py

@@ -54,38 +54,10 @@ def hypercube_entangler_graph(
     )
 
 
-def gaussian_finance_post_process(
-    finance_model: GaussianModel,
-    estimation_method: FinanceFunction,
-    probability: CReal,
-) -> CReal:
-    return symbolic_function(
-        finance_model,
-        estimation_method,
-        probability,
-        return_type=CReal,  # type:ignore[type-abstract]
-    )
-
-
-def log_normal_finance_post_process(
-    finance_model: LogNormalModel,
-    estimation_method: FinanceFunction,
-    probability: CReal,
-) -> CReal:
-    return symbolic_function(
-        finance_model,
-        estimation_method,
-        probability,
-        return_type=CReal,  # type:ignore[type-abstract]
-    )
-
-
 __all__ = [
     "qft_const_adder_phase",
     "fock_hamiltonian_problem_to_hamiltonian",
     "molecule_problem_to_hamiltonian",
     "grid_entangler_graph",
     "hypercube_entangler_graph",
-    "gaussian_finance_post_process",
-    "log_normal_finance_post_process",
 ]