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

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_lambda_function.py

@@ -32,7 +32,7 @@ class QuantumLambdaFunction(ASTNode):
         default=None
     )
 
-    _py_callable: Callable = pydantic.PrivateAttr(default=None)
+    _py_callable: Callable = pydantic.PrivateAttr(default=None)  # type: ignore[assignment]
 
     @property
     def py_callable(self) -> Callable:

classiq/interface/model/quantum_statement.py

@@ -4,7 +4,6 @@ from typing import Any, Callable, Optional
 from uuid import UUID, uuid4
 
 import pydantic
-from pydantic import ConfigDict
 from typing_extensions import Self
 
 from classiq.interface.ast_node import ASTNode
@@ -21,7 +20,6 @@ from classiq.interface.model.handle_binding import (
 
 class QuantumStatement(ASTNode):
     kind: str
-    model_config = ConfigDict(extra="forbid")
     uuid: UUID = pydantic.Field(
         description="A unique identifier for this operation", default_factory=uuid4
     )
@@ -29,12 +27,12 @@ class QuantumStatement(ASTNode):
     def model_copy(
         self,
         *,
-        update: Optional[dict[str, Any]] = None,
+        update: Optional[Mapping[str, Any]] = None,
         deep: bool = False,
         keep_uuid: bool = False,
     ) -> Self:
         if not keep_uuid:
-            update = update or dict()
+            update = dict(update) if update is not None else dict()
             update.setdefault("uuid", uuid4())
         return super().model_copy(update=update, deep=deep)
 

classiq/interface/model/quantum_type.py

@@ -1,7 +1,7 @@
 from typing import TYPE_CHECKING, Any, Literal, Optional
 
 import pydantic
-from pydantic import BaseModel, ConfigDict, Field
+from pydantic import BaseModel, Field
 from typing_extensions import Self
 
 from classiq.interface.ast_node import HashableASTNode
@@ -35,8 +35,6 @@ if TYPE_CHECKING:
 
 
 class QuantumType(HashableASTNode):
-    model_config = ConfigDict(extra="forbid")
-
     _size_in_bits: Optional[int] = pydantic.PrivateAttr(default=None)
 
     def _update_size_in_bits_from_declaration(self) -> None:
@@ -84,10 +82,17 @@ 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 []
 
+    def without_symbolic_attributes(self) -> Self:
+        return self
+
 
 class QuantumScalar(QuantumType):
     def get_proxy(self, handle: "HandleBinding") -> QmodQScalarProxy:
@@ -109,6 +114,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 +162,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 +269,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
@@ -272,6 +293,18 @@ class QuantumBitvector(QuantumType):
             length = 1
         return length * self.element_type.minimal_size_in_bits
 
+    def without_symbolic_attributes(self) -> "QuantumBitvector":
+        length = (
+            None
+            if self.length is None
+            or not self.length.is_evaluated()
+            or not self.length.is_constant()
+            else self.length
+        )
+        return QuantumBitvector(
+            element_type=self.element_type.without_symbolic_attributes(), length=length
+        )
+
 
 class QuantumNumeric(QuantumScalar):
     kind: Literal["qnum"]
@@ -311,6 +344,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 +360,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 +437,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 = []
@@ -431,6 +500,36 @@ class QuantumNumeric(QuantumScalar):
     def minimal_size_in_bits(self) -> int:
         return self.size_in_bits if self.has_size_in_bits else 1
 
+    def without_symbolic_attributes(self) -> "QuantumNumeric":
+        size = (
+            None
+            if self.size is None
+            or not self.size.is_evaluated()
+            or not self.size.is_constant()
+            else self.size
+        )
+        is_signed = (
+            None
+            if self.is_signed is None
+            or not self.is_signed.is_evaluated()
+            or not self.is_signed.is_constant()
+            else self.is_signed
+        )
+        fraction_digits = (
+            None
+            if self.fraction_digits is None
+            or not self.fraction_digits.is_evaluated()
+            or not self.fraction_digits.is_constant()
+            else self.fraction_digits
+        )
+        if size is None or is_signed is None or fraction_digits is None:
+            is_signed = fraction_digits = None
+        qnum = QuantumNumeric(
+            size=size, is_signed=is_signed, fraction_digits=fraction_digits
+        )
+        qnum.set_bounds(self.get_bounds())
+        return qnum
+
 
 class RegisterQuantumType(BaseModel):
     quantum_types: "ConcreteQuantumType"

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

@@ -101,6 +101,7 @@ __all__ = [
     "inplace_c_modular_multiply",
     "inplace_prepare_complex_amplitudes",
     "inplace_prepare_int",
+    "inplace_prepare_sparse_amplitudes",
     "lcu",
     "lcu_pauli",
     "linear_pauli_rotations",
@@ -116,6 +117,8 @@ __all__ = [
     "prepare_exponential_state",
     "prepare_ghz_state",
     "prepare_int",
+    "prepare_linear_amplitudes",
+    "prepare_sparse_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,
@@ -24,6 +24,7 @@ from classiq.qmod.builtins.operations import (
     control,
     if_,
     inplace_add,
+    inplace_xor,
     repeat,
     within_apply,
 )
@@ -324,7 +325,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 +334,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 +359,8 @@ def inplace_prepare_complex_amplitudes(
         target: The quantum variable to act upon.
     """
     inplace_prepare_amplitudes(magnitudes, 0, target)
-    _load_phases(phases, target)
+    if not np.allclose(phases, 0, atol=1e-12):
+        apply_phase_table(phases, target)
 
 
 @qfunc
@@ -469,3 +471,178 @@ 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)
+
+
+@qfunc
+def swap_states(a: int, b: int, target: QArray) -> None:
+    """
+    Swap 2 computational basis states a and b, leave all other states untouched.
+
+    Args:
+        a: 1st state number.
+        b: 2nd state number.
+        target: The quantum variable to act upon.
+    """
+    assert a != b, "a and b should be different"
+    diff = a ^ b
+    diff_indices = [i for i in range(target.len) if (diff >> i) & 1]
+    anchor = diff_indices[0]
+    anchor_bit = (a >> anchor) & 1
+
+    # a hack for the binding (should be improved after we have cast
+    target_without_anchor = []
+    if anchor > 0:
+        target_without_anchor.append(target[0:anchor])
+    if anchor < target.len - 1:
+        target_without_anchor.append(target[anchor + 1 : target.len])
+
+    @qfunc
+    def _xor_if_equal(n: CInt, ctrl: QNum, target: QBit) -> None:
+        target ^= ctrl == n
+
+    def _remove_bit(x: int, j: int) -> int:
+        """
+        Remove bit j from integer x (0 = least significant bit)
+        and shift higher bits down.
+        """
+        low = x & ((1 << j) - 1)  # bits below j
+        high = x >> (j + 1)  # bits above j
+        return low | (high << j)
+
+    within_apply(
+        # make the states equal except the anchor qubit
+        lambda: [
+            inplace_xor(target[anchor] != anchor_bit, target[i])
+            for i in diff_indices[1:]
+        ],
+        # do the actual swapping
+        lambda: _xor_if_equal(
+            _remove_bit(a, anchor), target_without_anchor, target[anchor]
+        ),
+    )
+
+
+@qfunc
+def inplace_prepare_sparse_amplitudes(
+    states: list[int], amplitudes: list[complex], target: QArray
+) -> None:
+    """
+    [Qmod Classiq-library function]
+
+    Prepares a quantum state with the given (complex) amplitudes. The input is given sparse format, as a list of non-zero states and their corresponding amplitudes.
+    Notice that the function is only suitable sparse states. Inspired by https://arxiv.org/abs/2310.19309.
+
+    For example, `inplace_prepare_sparse_amplitudes([1, 8], [np.sqrt(0.5), np.sqrt(0.5)], target)` will prepare the state sqrt(0.5)|1> + sqrt(0.5)|8>
+    on the target variable, assuming it starts in the |0> state.
+
+    Complexity: Asymptotic gate complexity is $O(dn)$ where d is the number of states and n is the target number of qubits.
+
+    Args:
+        states: A list of distinct computational basis indices to populate. Each integer corresponds to the basis state in the computational basis.
+        amplitudes: A list of complex amplitudes for the corresponding entries in `states`. Must have the same length as `states`.
+        target: The quantum variable on which the state is to be prepared. Its size must be sufficient to represent all states in `states`.
+    """
+    assert len(amplitudes) == len(
+        states
+    ), "amplitudes and states should have the same size"
+    assert (
+        max(list(states)) <= 2**target.len
+    ), "the target quantum variable is not large enough to populate all states"
+    assert len(set(states)) == len(states), "all states should be distinct"
+
+    # prepare a dense state
+    dense_size = max(int(np.ceil(np.log2(len(states)))), 1)
+    dense_amplitudes = np.zeros(2**dense_size, dtype=complex)
+
+    ## make sure the states with number smaller than the dense state size are located in their place already
+    for i, state in enumerate(states):
+        if state < len(dense_amplitudes):
+            dense_amplitudes[state] = amplitudes[i]
+
+    ## make a swap list for all other states
+    swap_list = []
+    free_index = 0
+    for i, state in enumerate(states):
+        if state < len(dense_amplitudes):
+            continue  # already populated
+        while dense_amplitudes[free_index]:
+            free_index += 1  # index is not free
+
+        dense_amplitudes[free_index] = amplitudes[i]
+        swap_list.append((free_index, state))
+        free_index += 1
+
+    inplace_prepare_complex_amplitudes(
+        np.abs(dense_amplitudes), np.angle(dense_amplitudes), target[0:dense_size]
+    )
+
+    # swap all required states
+    sparse_size = max(int(np.ceil(np.log2(max(list(states) + [1])))), 1)
+    for a, b in swap_list:
+        swap_states(a, b, target[0:sparse_size])
+
+
+@qfunc
+def prepare_sparse_amplitudes(
+    states: list[int], amplitudes: list[complex], out: Output[QArray]
+) -> None:
+    """
+    [Qmod Classiq-library function]
+
+    Initializes and prepares a quantum state with the given (complex) amplitudes. The input is given sparse format, as a list of non-zero states and their corresponding amplitudes.
+    Notice that the function is only suitable sparse states. Inspired by https://arxiv.org/abs/2310.19309.
+
+    For example, `prepare_sparse_amplitudes([1, 8], [np.sqrt(0.5), np.sqrt(0.5)], out)` will and allocate it to be of size 4 qubits, and
+    prepare it in the state sqrt(0.5)|1> + sqrt(0.5)|8>.
+
+    Complexity: Asymptotic gate complexity is $O(dn)$ where d is the number of states and n is the required number of qubits.
+
+    Args:
+        states: A list of distinct computational basis indices to populate. Each integer corresponds to the basis state in the computational basis.
+        amplitudes: A list of complex amplitudes for the corresponding entries in `states`. Must have the same length as `states`.
+        out: The allocated quantum variable.
+    """
+    allocate(max(int(np.ceil(np.log2(max(states)))), 1), out)
+    inplace_prepare_sparse_amplitudes(states, amplitudes, out)

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",
 ]