classiq 0.91.1__py3-none-any.whl → 0.93.0__py3-none-any.whl

classiq/interface/generator/generated_circuit_data.py

@@ -148,6 +148,7 @@ class StatementType(StrEnum):
     REPEAT = "repeat"
     BLOCK = "block"
     IF = "if"
+    SKIP_CONTROL = "skip control"
 
 
 # Mapping between statement kind (or sub-kind) and statement type (visualization name)
@@ -170,6 +171,7 @@ STATEMENTS_NAME: dict[str, StatementType] = {
     "Repeat": StatementType.REPEAT,
     "Block": StatementType.BLOCK,
     "ClassicalIf": StatementType.IF,
+    "SkipControl": StatementType.SKIP_CONTROL,
 }
 
 
@@ -197,9 +199,6 @@ class FunctionDebugInfoInterface(pydantic.BaseModel):
     @property
     def name(self) -> str:
         generated_name = self.generated_function.name if self.generated_function else ""
-        # Temp fix for remaining old "supported" statements - power
-        if generated_name == StatementType.POWER:
-            return generated_name
 
         back_ref = self.first_back_ref
         if back_ref is None:
@@ -235,10 +234,6 @@ class FunctionDebugInfoInterface(pydantic.BaseModel):
 
     @property
     def level(self) -> OperationLevel:
-        # Temp fix for remaining old "supported" statements - power
-        if self.name == StatementType.POWER:
-            return OperationLevel.QMOD_STATEMENT
-
         if self.first_back_ref is None:
             # we use ENGINE_FUNCTION_CALL in case where there's not back ref
             return OperationLevel.ENGINE_FUNCTION_CALL
@@ -300,15 +295,8 @@ class FunctionDebugInfoInterface(pydantic.BaseModel):
 
         updated_children: list[FunctionDebugInfoInterface] = []
         for child in self.children:
-            updated_child = child.white_new_absolute_qubits(self.absolute_qubits)
-            if updated_child.override_debug_info is None:
-                updated_child = updated_child.propagate_absolute_qubits()
-            else:
-                updated_child.override_debug_info = (
-                    updated_child.override_debug_info.white_new_absolute_qubits(
-                        absolute_qubits=self.absolute_qubits
-                    ).propagate_absolute_qubits()
-                )
+            updated_child = child._write_new_absolute_qubits(self.absolute_qubits)
+            updated_child = updated_child.propagate_absolute_qubits()
             updated_children.append(updated_child)
 
         return self.model_copy(
@@ -318,7 +306,7 @@ class FunctionDebugInfoInterface(pydantic.BaseModel):
             )
         )
 
-    def white_new_absolute_qubits(
+    def _write_new_absolute_qubits(
         self, absolute_qubits: tuple[int, ...]
     ) -> "FunctionDebugInfoInterface":
         return self.model_copy(

classiq/interface/generator/transpiler_basis_gates.py

@@ -61,7 +61,7 @@ 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"))
+THREE_QUBIT_GATES: BasisGates = frozenset(("ccx", "cswap", "ccz"))
 DEFAULT_BASIS_GATES: BasisGates = SINGLE_QUBIT_GATES | BASIC_TWO_QUBIT_GATES
 ALL_GATES: BasisGates = (
     SINGLE_QUBIT_GATES | TWO_QUBIT_GATES | THREE_QUBIT_GATES | NON_UNITARY_GATES

classiq/interface/helpers/versioned_model.py

@@ -2,12 +2,10 @@ from typing import Any
 
 import pydantic
 
-from classiq.interface._version import VERSION
 from classiq.interface.interface_version import INTERFACE_VERSION
 
 
 class VersionedModel(pydantic.BaseModel):
-    version: str = pydantic.Field(default=VERSION)
     interface_version: str = pydantic.Field(default="0")
 
     @pydantic.model_validator(mode="before")

classiq/interface/interface_version.py

@@ -1 +1 @@
-INTERFACE_VERSION = "12"
+INTERFACE_VERSION = "13"

classiq/interface/model/bind_operation.py

@@ -1,9 +1,6 @@
 from collections.abc import Mapping, Sequence
 from typing import Literal
 
-import pydantic
-
-from classiq.interface.exceptions import ClassiqValueError
 from classiq.interface.model.handle_binding import ConcreteHandleBinding, HandleBinding
 from classiq.interface.model.quantum_statement import HandleMetadata, QuantumOperation
 
@@ -49,12 +46,3 @@ class BindOperation(QuantumOperation):
             )
             for handle in self.out_handles
         ]
-
-    @pydantic.field_validator("in_handles", "out_handles")
-    @classmethod
-    def validate_handle(cls, handles: list[HandleBinding]) -> list[HandleBinding]:
-        for handle in handles:
-            if not handle.is_bindable():
-                raise ClassiqValueError(f"Cannot bind '{handle}'")
-
-        return handles

classiq/interface/model/handle_binding.py

@@ -382,6 +382,9 @@ FieldHandleBinding.model_rebuild()
 class HandlesList(ASTNode):
     handles: list["GeneralHandle"]
 
+    def __str__(self) -> str:
+        return f"[{', '.join(map(str, self.handles))}]"
+
 
 GeneralHandle = Union[ConcreteHandleBinding, HandlesList]
 HandlesList.model_rebuild()

classiq/interface/model/skip_control.py

@@ -0,0 +1,11 @@
+from typing import TYPE_CHECKING, Literal
+
+from classiq.interface.model.quantum_statement import QuantumOperation
+
+if TYPE_CHECKING:
+    from classiq.interface.model.statement_block import StatementBlock
+
+
+class SkipControl(QuantumOperation):
+    kind: Literal["SkipControl"]
+    body: "StatementBlock"

classiq/interface/model/statement_block.py

@@ -22,6 +22,7 @@ from classiq.interface.model.quantum_expressions.arithmetic_operation import (
 from classiq.interface.model.quantum_function_call import QuantumFunctionCall
 from classiq.interface.model.quantum_lambda_function import QuantumLambdaFunction
 from classiq.interface.model.repeat import Repeat
+from classiq.interface.model.skip_control import SkipControl
 from classiq.interface.model.variable_declaration_statement import (
     VariableDeclarationStatement,
 )
@@ -53,6 +54,7 @@ ConcreteQuantumStatement = Annotated[
         Action,
         Uncompute,
         SetBoundsStatement,
+        SkipControl,
     ],
     Field(..., discriminator="kind"),
 ]
@@ -69,3 +71,4 @@ WithinApply.model_rebuild()
 ClassicalIf.model_rebuild()
 NativeFunctionDefinition.model_rebuild()
 PhaseOperation.model_rebuild()
+SkipControl.model_rebuild()

classiq/interface/server/routes.py

@@ -25,7 +25,6 @@ RB = "/rb"
 ANALYZER_DATA_TASK = f"{TASKS_SUFFIX}/data"
 ANALYZER_QASM_TASK = f"{TASKS_SUFFIX}/qasm"
 ANALYZER_GET_VISUAL_MODEL = "/get_visual_model"
-ANALYZER_GET_IDE_DATA = "/get_ide_data"
 IDE_EVENT_TASK = f"{TASKS_SUFFIX}/event"
 DATA_DOG_EVENT_TASK = f"{TASKS_SUFFIX}/data_dog_event"
 
@@ -33,14 +32,12 @@ ANALYZER_DATA_TASK_UPLOAD_FILE = f"{TASKS_SUFFIX}/data/file_upload"
 ANALYZER_DATA_FULL_PATH = f"{ANALYZER_PREFIX}{ANALYZER_DATA_TASK}"
 ANALYZER_QASM_FULL_PATH = f"{ANALYZER_PREFIX}{ANALYZER_QASM_TASK}"
 ANALYZER_GET_VISUAL_MODEL_FULL_PATH = f"{ANALYZER_PREFIX}{ANALYZER_GET_VISUAL_MODEL}"
-ANALYZER_GET_IDE_DATA_FULL_PATH = f"{ANALYZER_PREFIX}{ANALYZER_GET_IDE_DATA}"
 IDE_EVENT_TASK_FULL_PATH = f"{ANALYZER_PREFIX}{IDE_EVENT_TASK}"
 DATA_DOG_EVENT_TASK_FULL_PATH = f"{ANALYZER_PREFIX}{DATA_DOG_EVENT_TASK}"
 
 IDE_QASM_TASK = f"{TASKS_SUFFIX}/generated_circuit_from_qasm"
 IDE_QASM_FULL_PATH = f"{ANALYZER_PREFIX}{IDE_QASM_TASK}"
 TASKS_GENERATE_SUFFIX = TASKS_SUFFIX + "/generate"
-TASKS_VISUALIZE_SUFFIX = TASKS_SUFFIX + "/visualize"
 TASKS_VISUAL_MODEL_SUFFIX = TASKS_SUFFIX + "/visual_model"
 TASKS_SOLVE_SUFFIX = "/tasks/solve"
 

classiq/model_expansions/interpreters/generative_interpreter.py

@@ -13,6 +13,7 @@ from classiq.interface.generator.functions.builtins.internal_operators import (
     INVERT_OPERATOR_NAME,
     POWER_OPERATOR_NAME,
     REPEAT_OPERATOR_NAME,
+    SKIP_CONTROL_OPERATOR_NAME,
     WITHIN_APPLY_NAME,
 )
 from classiq.interface.model.allocate import Allocate
@@ -43,6 +44,7 @@ from classiq.interface.model.quantum_lambda_function import (
 )
 from classiq.interface.model.quantum_statement import QuantumStatement
 from classiq.interface.model.repeat import Repeat
+from classiq.interface.model.skip_control import SkipControl
 from classiq.interface.model.variable_declaration_statement import (
     VariableDeclarationStatement,
 )
@@ -84,6 +86,9 @@ from classiq.model_expansions.quantum_operations.handle_evaluator import HandleE
 from classiq.model_expansions.quantum_operations.repeat_block_evaluator import (
     RepeatBlockEvaluator,
 )
+from classiq.model_expansions.quantum_operations.skip_control_verifier import (
+    SkipControlVerifier,
+)
 from classiq.model_expansions.scope import Evaluated, Scope
 from classiq.model_expansions.scope_initialization import (
     add_constants_to_scope,
@@ -240,7 +245,9 @@ class GenerativeInterpreter(BaseInterpreter):
     def emit_variable_declaration(
         self, variable_declaration: VariableDeclarationStatement
     ) -> None:
-        VariableDeclarationStatementEmitter(self).emit(variable_declaration)
+        VariableDeclarationStatementEmitter(
+            self, allow_symbolic_vars=self._symbolic_parameters_switch
+        ).emit(variable_declaration)
 
     @emit.register
     def emit_classical_if(self, classical_if: ClassicalIf) -> None:
@@ -278,6 +285,16 @@ class GenerativeInterpreter(BaseInterpreter):
     def emit_invert(self, invert: Invert) -> None:
         BlockEvaluator(self, INVERT_OPERATOR_NAME, "body").emit(invert)
 
+    @emit.register
+    def emit_skip_control(self, skip_control: SkipControl) -> None:
+        CompositeEmitter[SkipControl](
+            self,
+            [
+                SkipControlVerifier(self),
+                BlockEvaluator(self, SKIP_CONTROL_OPERATOR_NAME, "body"),
+            ],
+        ).emit(skip_control)
+
     @emit.register
     def _emit_repeat(self, repeat: Repeat) -> None:
         self.emit_repeat(repeat)

classiq/model_expansions/quantum_operations/assignment_result_processor.py

@@ -62,6 +62,12 @@ class AssignmentResultProcessor(Emitter[QuantumAssignmentOperation]):
         if isinstance(result_symbol, ClassicalSymbol):
             return False
         result_type = result_symbol.quantum_type
+        if not isinstance(result_type, QuantumScalar):
+            raise ClassiqExpansionError(
+                f"Cannot assign into a non-scalar quantum variable "
+                f"{str(result_symbol.handle)!r} of type "
+                f"{result_type.raw_qmod_type_name}"
+            )
 
         if not (
             isinstance(op, ArithmeticOperation)

classiq/model_expansions/quantum_operations/bind.py

@@ -25,6 +25,12 @@ if TYPE_CHECKING:
     from classiq.model_expansions.interpreters.base_interpreter import BaseInterpreter
 
 
+BIND_PATH_EXPR_MESSAGE = (
+    "Cannot use variable part (subscript, slice, or field access) in the source or "
+    "destination of a 'bind' statement"
+)
+
+
 class BindEmitter(Emitter[BindOperation]):
     def __init__(
         self, interpreter: "BaseInterpreter", allow_symbolic_size: bool = False
@@ -60,6 +66,7 @@ class BindEmitter(Emitter[BindOperation]):
         evaluated_outputs: list[Evaluated] = [
             self._interpreter.evaluate(arg) for arg in bind.out_handles
         ]
+        self._validate_var_types(evaluated_inputs + evaluated_outputs)
         self._validate_handle_states(evaluated_inputs, evaluated_outputs)
         inputs: list[QuantumSymbol] = [
             input.as_type(QuantumSymbol) for input in evaluated_inputs
@@ -71,6 +78,13 @@ class BindEmitter(Emitter[BindOperation]):
         outputs = evaluate_types_in_quantum_symbols(outputs, self._current_scope)
         return inputs, outputs
 
+    def _validate_var_types(self, vars: list[Evaluated]) -> None:
+        path_expr_vars = [
+            var.value for var in vars if not var.value.handle.is_bindable()
+        ]
+        if len(path_expr_vars) > 0:
+            raise ClassiqExpansionError(BIND_PATH_EXPR_MESSAGE)
+
     def _validate_handle_states(
         self, inputs: list[Evaluated], outputs: list[Evaluated]
     ) -> None:

classiq/model_expansions/quantum_operations/skip_control_verifier.py

@@ -0,0 +1,20 @@
+from classiq.interface.exceptions import ClassiqExpansionError
+from classiq.interface.helpers.backward_compatibility import zip_strict
+from classiq.interface.model.skip_control import SkipControl
+
+from classiq.model_expansions.function_builder import FunctionContext
+from classiq.model_expansions.quantum_operations.emitter import Emitter
+
+
+class SkipControlVerifier(Emitter[SkipControl]):
+    def emit(self, skip_control: SkipControl, /) -> bool:
+        for op, block in list(
+            zip_strict(self._builder._operations, self._builder._blocks, strict=True)
+        )[::-1]:
+            if isinstance(op, FunctionContext):
+                break
+            if block in ("action", "apply"):
+                raise ClassiqExpansionError(
+                    "skip_control cannot be used under within-apply's 'apply' block"
+                )
+        return False

classiq/model_expansions/quantum_operations/variable_decleration.py

@@ -3,6 +3,7 @@ from typing import TYPE_CHECKING, Union, cast
 from classiq.interface.exceptions import ClassiqExpansionError
 from classiq.interface.generator.functions.classical_type import ClassicalType
 from classiq.interface.generator.functions.concrete_types import ConcreteType
+from classiq.interface.helpers.text_utils import readable_list, s
 from classiq.interface.model.handle_binding import HandleBinding
 from classiq.interface.model.quantum_type import QuantumType
 from classiq.interface.model.variable_declaration_statement import (
@@ -13,11 +14,21 @@ from classiq.evaluators.parameter_types import (
     evaluate_type_in_classical_symbol,
     evaluate_type_in_quantum_symbol,
 )
+from classiq.evaluators.qmod_annotated_expression import QmodAnnotatedExpression
 from classiq.model_expansions.quantum_operations.emitter import Emitter
 from classiq.model_expansions.scope import ClassicalSymbol, Evaluated, QuantumSymbol
 
+if TYPE_CHECKING:
+    from classiq.model_expansions.interpreters.base_interpreter import BaseInterpreter
+
 
 class VariableDeclarationStatementEmitter(Emitter[VariableDeclarationStatement]):
+    def __init__(
+        self, interpreter: "BaseInterpreter", allow_symbolic_vars: bool = False
+    ) -> None:
+        super().__init__(interpreter)
+        self._allow_symbolic_vars = allow_symbolic_vars
+
     def emit(self, variable_declaration: VariableDeclarationStatement, /) -> bool:
         var_decl = variable_declaration.model_copy(
             update=dict(back_ref=variable_declaration.uuid)
@@ -29,36 +40,57 @@ class VariableDeclarationStatementEmitter(Emitter[VariableDeclarationStatement])
             )
         var_value: Union[QuantumSymbol, ClassicalSymbol]
         if variable_declaration.is_quantum:
-            if TYPE_CHECKING:
-                assert isinstance(var_decl.qmod_type, QuantumType)
-            updated_quantum_type = evaluate_type_in_quantum_symbol(
-                var_decl.qmod_type,
-                self._current_scope,
-                var_decl.name,
-            )
-            var_decl.qmod_type = updated_quantum_type
-            var_value = QuantumSymbol(
-                handle=HandleBinding(name=var_decl.name),
-                quantum_type=updated_quantum_type,
-            )
-            self._builder.current_block.captured_vars.init_var(
-                var_decl.name, self._builder.current_function
-            )
+            var_value = self._get_quantum_var(var_decl)
         else:
-            if TYPE_CHECKING:
-                assert isinstance(var_decl.qmod_type, ClassicalType)
-            updated_classical_type = evaluate_type_in_classical_symbol(
-                var_decl.qmod_type,
-                self._current_scope,
-                var_decl.name,
-            )
-            var_decl.qmod_type = cast(ConcreteType, updated_classical_type)
-            var_value = ClassicalSymbol(
-                handle=HandleBinding(name=var_decl.name),
-                classical_type=updated_classical_type,
-            )
+            var_value = self._get_classical_var(var_decl)
         self._current_scope[variable_declaration.name] = Evaluated(
             value=var_value, defining_function=self._builder.current_function
         )
         self.emit_statement(var_decl)
         return True
+
+    def _get_quantum_var(self, var_decl: VariableDeclarationStatement) -> QuantumSymbol:
+        updated_quantum_type = evaluate_type_in_quantum_symbol(
+            cast(QuantumType, var_decl.qmod_type),
+            self._current_scope,
+            var_decl.name,
+        )
+        if not self._allow_symbolic_vars:
+            symbolic_variables = list(
+                dict.fromkeys(
+                    classical_var.name
+                    for expr in updated_quantum_type.expressions
+                    if isinstance(expr_val := expr.value.value, QmodAnnotatedExpression)
+                    for classical_var in expr_val.get_classical_vars().values()
+                )
+            )
+            if len(symbolic_variables) > 0:
+                raise ClassiqExpansionError(
+                    f"Variable type is instantiated with non-compile-time "
+                    f"variable{s(symbolic_variables)} "
+                    f"{readable_list(symbolic_variables, quote=True)}"
+                )
+        var_decl.qmod_type = updated_quantum_type
+        var_value = QuantumSymbol(
+            handle=HandleBinding(name=var_decl.name),
+            quantum_type=updated_quantum_type,
+        )
+        self._builder.current_block.captured_vars.init_var(
+            var_decl.name, self._builder.current_function
+        )
+        return var_value
+
+    def _get_classical_var(
+        self, var_decl: VariableDeclarationStatement
+    ) -> ClassicalSymbol:
+        updated_classical_type = evaluate_type_in_classical_symbol(
+            cast(ClassicalType, var_decl.qmod_type),
+            self._current_scope,
+            var_decl.name,
+        )
+        var_decl.qmod_type = cast(ConcreteType, updated_classical_type)
+        var_value = ClassicalSymbol(
+            handle=HandleBinding(name=var_decl.name),
+            classical_type=updated_classical_type,
+        )
+        return var_value

classiq/open_library/functions/__init__.py

@@ -53,6 +53,7 @@ OPEN_LIBRARY_FUNCTIONS = [
     qsvt_inversion,
     qsvt_lcu,
     qsvt_lcu_step,
+    gqsp,
     qaoa_mixer_layer,
     qaoa_cost_layer,
     qaoa_layer,
@@ -94,6 +95,7 @@ __all__ = [
     "encode_on_bloch",
     "exact_amplitude_amplification",
     "full_hea",
+    "gqsp",
     "grover_diffuser",
     "grover_operator",
     "grover_search",

classiq/open_library/functions/discrete_sine_cosine_transform.py

@@ -13,6 +13,7 @@ from classiq.qmod.builtins.operations import (
 from classiq.qmod.qfunc import qfunc
 from classiq.qmod.qmod_variable import Const, Permutable, QArray, QBit, QNum
 from classiq.qmod.symbolic import pi
+from classiq.qmod.utilities import suppress_return_value
 
 
 def _b_operator(q: QBit) -> None:
@@ -27,7 +28,7 @@ def _qct_d_operator(x: Const[QNum], q: QBit) -> None:
 
 
 @qfunc
-def _qct_pi_operator(x: Permutable[QArray[QBit]], q: Const[QBit]) -> None:
+def _qct_pi_operator(x: Permutable[QNum], q: Const[QBit]) -> None:
     control(
         q == 1,
         lambda: [
@@ -65,8 +66,8 @@ def _d1_operator(x: QArray[QBit], q: QBit) -> None:
     PHASE(-omega_exp, q)
 
 
-def _pi2_operator(x: QArray[QBit], q: QBit) -> None:
-    control(q == 1, lambda: inplace_add(1, x))  # type:ignore[arg-type]
+def _pi2_operator(x: QNum, q: QBit) -> None:
+    control(q == 1, lambda: inplace_add(1, x)),  # type:ignore[arg-type]
 
 
 def _j_operator(q: QBit) -> None:
@@ -78,19 +79,23 @@ def _b_t_operator(q: QBit) -> None:
     S(q)
 
 
-def _d0dt_operator(x: QArray, q: QBit) -> None:
-    x_num: QNum = QNum(size=x.len)
-    bind(x, x_num)
+@suppress_return_value
+def _d0dt_operator(x: QNum, q: QBit) -> None:
     _b_t_operator(q)
-    control(x_num == 0, lambda: _j_operator(q))
-    bind(x_num, x)
+    control(x == 0, lambda: _j_operator(q))
 
 
 def _un_dag_operator(x: QArray[QBit], q: QBit) -> None:
     _d1_operator(x, q)
     invert(lambda: _qct_pi_operator(x, q))
-    _d0dt_operator(x, q)
-    invert(lambda: _pi2_operator(x, q))
+    x_num: QNum = QNum(size=x.len)
+    within_apply(
+        lambda: bind(x, x_num),
+        lambda: [
+            _d0dt_operator(x_num, q),
+            invert(lambda: _pi2_operator(x_num, q)),
+        ],
+    )
 
 
 @qfunc

classiq/open_library/functions/qsvt.py

@@ -1,7 +1,7 @@
-from classiq.qmod.builtins.functions.standard_gates import IDENTITY, RZ, H
+from classiq.qmod.builtins.functions.standard_gates import IDENTITY, RZ, H, U, X, Z
 from classiq.qmod.builtins.operations import control, if_, invert, repeat, within_apply
 from classiq.qmod.qfunc import qfunc
-from classiq.qmod.qmod_parameter import CArray, CReal
+from classiq.qmod.qmod_parameter import CArray, CInt, CReal
 from classiq.qmod.qmod_variable import QArray, QBit
 from classiq.qmod.quantum_callable import QCallable
 from classiq.qmod.symbolic import floor, min as qmin
@@ -267,8 +267,8 @@ def qsvt_lcu(
     Note: the two polynomials should have the same degree up to a difference of 1.
 
     Args:
-        phase_seq_odd: A sequence of phase angles of length d+1 for the odd polynomial.
-        phase_seq_even: A sequence of phase angles of length d+1 for the even polynomial.
+        phase_seq_odd: A sequence of phase angles of length d+(d%2) for the odd polynomial.
+        phase_seq_even: A sequence of phase angles of length d+(d+1)%2 for the even polynomial.
         proj_cnot_1: Projector-controlled-not unitary that locates the encoded matrix columns within U. Accepts a quantum variable of the same size as qvar, and a qubit that is set to |1> when the state is in the block.
         proj_cnot_2: Projector-controlled-not unitary that locates the encoded matrix rows within U. Accepts a quantum variable of the same size as qvar, and a qubit that is set to |1> when the state is in the block.
         u: A block encoded unitary matrix.
@@ -281,7 +281,7 @@ def qsvt_lcu(
         phase_seq_even[0], phase_seq_odd[0], proj_cnot_1, qvar, aux, lcu
     )
     repeat(
-        count=floor((qmin(phase_seq_odd.len, phase_seq_even.len)) / 2),
+        count=floor((qmin(phase_seq_odd.len - 1, phase_seq_even.len - 1)) / 2),
         iteration=lambda index: qsvt_lcu_step(
             phase_seq_even[2 * index + 1 : 2 * index + 3],
             phase_seq_odd[2 * index + 1 : 2 * index + 3],
@@ -310,7 +310,7 @@ def qsvt_lcu(
         then=lambda: (
             u(qvar),
             projector_controlled_double_phase(
-                phase_seq_even[phase_seq_even.len - 1],
+                phase_seq_even[phase_seq_even.len - 2],
                 phase_seq_odd[phase_seq_odd.len - 1],
                 proj_cnot_2,
                 qvar,
@@ -329,3 +329,57 @@ def qsvt_lcu(
         ),
     )
     H(aux)
+
+
+@qfunc
+def _gqsp_r_gate(theta: CReal, phi: CReal, _lambda: CReal, q: QBit) -> None:
+    """
+    Implements the R gate from the paper https://arxiv.org/abs/2308.01501 using the U gate.
+    """
+    within_apply(lambda: X(q), lambda: U(2 * theta, phi, _lambda, 0, q))
+    Z(q)
+
+
+@qfunc
+def gqsp(
+    u: QCallable, aux: QBit, phases: CArray[CArray[CReal], 3], negative_power: CInt  # type: ignore[valid-type]
+) -> None:
+    """
+     Implements Generalized Quantum Signal Processing (GQSP), which realizes a
+     (Laurent) polynomial transformation of degree d on the eigenvalues of the given
+     signal unitary `u`. The protocol is according to https://arxiv.org/abs/2308.01501
+     Fig.2.
+
+    Notes:
+    - The user is encouraged to use the function `gqsp_phases` to find `phases` that
+      correspond to the wanted polynomial transformation.
+    - Feasibility: the target polynomial must satisfy |P(e^{i*theta})| <= 1 for all
+      theta in [0, 2*pi). This ensures a unitary completion exists.
+    - Using `negative_power = m` (m >= 0) you can realize Laurent polynomials with
+      negative exponents: the implemented transform is equivalent to applying
+      z^{-m} * P(z) (i.e., shift the minimal degree to -m).
+      For ordinary (non-Laurent) polynomials, set `negative_power = 0`.
+
+    Args:
+        u: The signal unitary.
+        aux: Auxiliary qubit used for the phase rotations. Should start in |0>.
+        phases:  3 x (d+1) real array of angles: phases[0] = thetas, phases[1] = phis,
+                 phases[2] = lambdas.
+        negative_power: Integer m in [0, d]. Encodes the minimal Laurent power -m of
+                        the realized transformation.
+    """
+    degree = phases[0].len - 1
+    _gqsp_r_gate(phases[0][0], phases[1][0], phases[2][0], aux)
+    repeat(
+        degree,
+        lambda index: [
+            if_(
+                index + 1 <= degree - negative_power,
+                lambda: control(aux == 0, lambda: u()),
+                lambda: control(aux == 1, lambda: invert(u)),
+            ),
+            _gqsp_r_gate(
+                phases[0][index + 1], phases[1][index + 1], phases[2][index + 1], aux
+            ),
+        ],
+    )

classiq/qmod/builtins/operations.py

@@ -45,6 +45,7 @@ from classiq.interface.model.quantum_function_declaration import (
 )
 from classiq.interface.model.quantum_lambda_function import QuantumLambdaFunction
 from classiq.interface.model.repeat import Repeat
+from classiq.interface.model.skip_control import SkipControl
 from classiq.interface.model.statement_block import StatementBlock
 from classiq.interface.model.within_apply_operation import WithinApply
 
@@ -254,6 +255,20 @@ def control(
     QCallable.CURRENT_EXPANDABLE.append_statement_to_body(control_stmt)
 
 
+@suppress_return_value
+def skip_control(stmt_block: Union[QCallable, Callable[[], Statements]]) -> None:
+    _validate_operand(stmt_block)
+    assert QCallable.CURRENT_EXPANDABLE is not None
+    source_ref = get_source_ref(sys._getframe(1))
+    sc_stmt = SkipControl(
+        body=_operand_to_body(stmt_block, "stmt_block"),
+        source_ref=source_ref,
+    )
+    if is_generative_mode():
+        sc_stmt.set_generative_block("body", stmt_block)
+    QCallable.CURRENT_EXPANDABLE.append_statement_to_body(sc_stmt)
+
+
 @suppress_return_value
 def assign(expression: SymbolicExpr, target_var: QScalar) -> None:
     """
@@ -645,6 +660,14 @@ def _validate_operand(stmt_block: Any, num_params: int = 0) -> None:
         )
     if isinstance(stmt_block, QCallable):
         return
+    if not callable(stmt_block):
+        _raise_operand_error(
+            lambda operation_name, operand_arg_name: (
+                f"Argument {operand_arg_name!r} to {operation_name!r} must be a "
+                f"callable object"
+            ),
+            num_params,
+        )
     op_spec = inspect.getfullargspec(stmt_block)
     params = op_spec.args[: len(op_spec.args) - len(op_spec.defaults or ())]
     if len(params) > num_params or (
@@ -748,6 +771,7 @@ __all__ = [
     "power",
     "repeat",
     "reset_bounds",
+    "skip_control",
     "within_apply",
 ]
 

classiq/qmod/classical_variable.py

@@ -1,7 +1,7 @@
 import sys
 from typing import TYPE_CHECKING, Any
 
-from classiq.interface.exceptions import ClassiqInternalError
+from classiq.interface.exceptions import ClassiqInternalError, ClassiqTypeError
 from classiq.interface.generator.expressions.expression import Expression
 from classiq.interface.generator.functions.classical_type import Bool, ClassicalType
 from classiq.interface.model.handle_binding import HandleBinding
@@ -37,7 +37,9 @@ def declare_classical_variable(
 
 def assign_classical_variable(target: CParam, value: Any, frame_depth: int) -> None:
     if not isinstance(value, SYMBOLIC_TYPES):
-        raise TypeError(f"Invalid argument {value!r} for classical variable assignment")
+        raise ClassiqTypeError(
+            f"Invalid argument {value!r} for classical variable assignment"
+        )
 
     if TYPE_CHECKING:
         assert QCallable.CURRENT_EXPANDABLE is not None