classiq 0.91.0__py3-none-any.whl → 0.92.0__py3-none-any.whl

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,
@@ -278,6 +283,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/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/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/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:
     """
@@ -748,6 +763,7 @@ __all__ = [
     "power",
     "repeat",
     "reset_bounds",
+    "skip_control",
     "within_apply",
 ]
 

classiq/qmod/native/pretty_printer.py

@@ -78,6 +78,7 @@ from classiq.interface.model.quantum_type import (
     QuantumNumeric,
 )
 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.variable_declaration_statement import (
     VariableDeclarationStatement,
@@ -311,6 +312,13 @@ class DSLPrettyPrinter(ModelVisitor):
         control += "\n"
         return control
 
+    def visit_SkipControl(self, op: SkipControl) -> str:
+        sc = f"{self._indent}skip_control {{\n"
+        sc += self._visit_body(op.body)
+        sc += f"{self._indent}}}"
+        sc += "\n"
+        return sc
+
     def visit_PhaseOperation(self, op: PhaseOperation) -> str:
         theta = f", {self.visit(op.theta)}" if op.theta.expr != "1.0" else ""
         phase = f"{self._indent}phase ({self.visit(op.expression)}{theta});\n"

classiq/qmod/pretty_print/pretty_printer.py

@@ -78,6 +78,7 @@ from classiq.interface.model.quantum_type import (
     QuantumNumeric,
 )
 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.variable_declaration_statement import (
     VariableDeclarationStatement,
@@ -459,6 +460,10 @@ class PythonPrettyPrinter(ModelVisitor):
         )
         return f"{self._indent}control({self.visit(op.expression)}, {self._visit_body(op.body)}{control_else})\n"
 
+    def visit_SkipControl(self, op: SkipControl) -> str:
+        self._imports["skip_control"] = 1
+        return f"{self._indent}skip_control({self._visit_body(op.body)})\n"
+
     def visit_PhaseOperation(self, op: PhaseOperation) -> str:
         self._imports["phase"] = 1
         theta = f", {self.visit(op.theta)}" if op.theta.expr != "1.0" else ""

classiq/qmod/quantum_expandable.py

@@ -472,6 +472,34 @@ def _prepare_args(
     return result
 
 
+def _validate_argument_names(
+    decl: QuantumFunctionDeclaration, arg_list: list[Any], kwargs: dict[str, Any]
+) -> None:
+    params = decl.positional_arg_declarations
+    param_names = {
+        mangle_keyword(param.name) for param in params if param.name is not None
+    }
+    pos_arg_names = {
+        mangle_keyword(param.name)
+        for param in params[: len(arg_list)]
+        if param.name is not None
+    }
+    for kwarg_name in kwargs:
+        if kwarg_name not in param_names:
+            raise ClassiqValueError(
+                f"{decl.name}() got an unexpected keyword argument {kwarg_name!r}"
+            )
+        if kwarg_name in pos_arg_names:
+            raise ClassiqValueError(
+                f"{decl.name}() got multiple values for argument {kwarg_name!r}"
+            )
+    total_args = len(arg_list) + len(kwargs)
+    if total_args != len(params):
+        raise ClassiqValueError(
+            f"{decl.name}() takes {len(params)} arguments but {total_args} were given"
+        )
+
+
 def _create_quantum_function_call(
     decl_: QuantumFunctionDeclaration,
     index_: Optional[Union[CParamScalar, int]] = None,
@@ -479,24 +507,10 @@ def _create_quantum_function_call(
     *args: Any,
     **kwargs: Any,
 ) -> QuantumFunctionCall:
-    arg_decls = decl_.positional_arg_declarations
     arg_list = list(args)
+    _validate_argument_names(decl_, arg_list, kwargs)
     prepared_args = _prepare_args(decl_, arg_list, kwargs)
 
-    if kwargs:
-        bad_kwarg = next(iter(kwargs))
-        if not all(arg_decl.name == bad_kwarg for arg_decl in arg_decls):
-            raise ClassiqValueError(
-                f"{decl_.name}() got an unexpected keyword argument {bad_kwarg!r}"
-            )
-        else:
-            raise ClassiqValueError(
-                f"{decl_.name}() got multiple values for argument {bad_kwarg!r}"
-            )
-    if arg_list:
-        raise ClassiqValueError(
-            f"{decl_.name}() takes {len(arg_decls)} arguments but {len(args)} were given"
-        )
     function_ident: Union[str, OperandIdentifier] = decl_.name
     if index_ is not None:
         function_ident = OperandIdentifier(

classiq/synthesis.py

@@ -69,7 +69,7 @@ def synthesize(
 ) -> QuantumProgram:
     """
     Synthesize a model with the Classiq engine to receive a quantum program.
-    [More details](https://docs.classiq.io/latest/reference-manual/synthesis/)
+    [More details](https://docs.classiq.io/latest/sdk-reference/synthesis/#classiq.synthesize)
 
     Args:
         model: The entry point of the Qmod model - a qfunc named 'main' (or alternatively the output of 'create_model').

{classiq-0.91.0.dist-info → classiq-0.92.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: classiq
-Version: 0.91.0
+Version: 0.92.0
 Summary: Classiq's Python SDK for quantum computing
 License: Proprietary
 Keywords: quantum computing,quantum circuits,quantum algorithms,QAD,QDL
@@ -29,9 +29,11 @@ Classifier: Typing :: Typed
 Provides-Extra: analyzer-sdk
 Provides-Extra: chemistry
 Provides-Extra: qml
+Provides-Extra: qsp
 Requires-Dist: ConfigArgParse (>=1.5.3,<2.0.0)
 Requires-Dist: Pyomo (>=6.9,<6.10)
 Requires-Dist: black (>=24.0,<25.0)
+Requires-Dist: cvxpy ; extra == "qsp"
 Requires-Dist: httpx (>=0.23.0,<1)
 Requires-Dist: ipywidgets ; extra == "analyzer-sdk"
 Requires-Dist: jupyterlab ; extra == "analyzer-sdk"
@@ -49,6 +51,7 @@ Requires-Dist: pandas (>=1.4.0,<3.0.0)
 Requires-Dist: plotly (>=5.7.0,<6.0.0)
 Requires-Dist: pydantic (>=2.10.4,<3.0.0)
 Requires-Dist: pydantic-settings (>=2.4.0,<3.0.0)
+Requires-Dist: pyqsp ; extra == "qsp"
 Requires-Dist: scipy (>=1.10.0,<2.0.0) ; python_version < "3.12"
 Requires-Dist: scipy (>=1.11.0,<2.0.0) ; python_version >= "3.12"
 Requires-Dist: sympy (>=1.13.0,<2.0.0)