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

classiq/interface/model/repeat.py

@@ -0,0 +1,13 @@
+from typing import TYPE_CHECKING
+
+from classiq.interface.generator.expressions.expression import Expression
+from classiq.interface.model.quantum_statement import QuantumOperation
+
+if TYPE_CHECKING:
+    from classiq.interface.model.statement_block import StatementBlock
+
+
+class Repeat(QuantumOperation):
+    iter_var: str
+    count: Expression
+    body: "StatementBlock"

classiq/interface/model/resolvers/function_call_resolver.py

@@ -1,11 +1,16 @@
+import itertools
 from typing import Any, Mapping
 
 from classiq.interface.generator.visitor import Visitor
+from classiq.interface.model.control import Control
+from classiq.interface.model.invert import Invert
 from classiq.interface.model.native_function_definition import NativeFunctionDefinition
 from classiq.interface.model.quantum_function_call import QuantumFunctionCall
 from classiq.interface.model.quantum_function_declaration import (
     QuantumFunctionDeclaration,
 )
+from classiq.interface.model.repeat import Repeat
+from classiq.interface.model.within_apply_operation import WithinApply
 
 
 class FunctionCallResolver(Visitor):
@@ -15,6 +20,22 @@ class FunctionCallResolver(Visitor):
     ) -> None:
         self._quantum_function_dict = quantum_function_dict
 
+    def visit_Invert(self, invert: Invert) -> None:
+        for fc in invert.body:
+            self.visit(fc)
+
+    def visit_Repeat(self, repeat: Repeat) -> None:
+        for fc in repeat.body:
+            self.visit(fc)
+
+    def visit_Control(self, control: Control) -> None:
+        for fc in control.body:
+            self.visit(fc)
+
+    def visit_WithinApply(self, within_apply: WithinApply) -> None:
+        for fc in itertools.chain(within_apply.compute, within_apply.action):
+            self.visit(fc)
+
     def visit_QuantumFunctionCall(self, fc: QuantumFunctionCall) -> None:
         fc.resolve_function_decl(self._quantum_function_dict, check_operands=True)
         self.visit_BaseModel(fc)

classiq/interface/model/statement_block.py

@@ -1,7 +1,11 @@
 from typing import List, Union
 
 from classiq.interface.model.bind_operation import BindOperation
+from classiq.interface.model.classical_if import ClassicalIf
+from classiq.interface.model.control import Control
 from classiq.interface.model.inplace_binary_operation import InplaceBinaryOperation
+from classiq.interface.model.invert import Invert
+from classiq.interface.model.power import Power
 from classiq.interface.model.quantum_expressions.amplitude_loading_operation import (
     AmplitudeLoadingOperation,
 )
@@ -9,12 +13,12 @@ from classiq.interface.model.quantum_expressions.arithmetic_operation import (
     ArithmeticOperation,
 )
 from classiq.interface.model.quantum_function_call import QuantumFunctionCall
-from classiq.interface.model.quantum_if_operation import QuantumIfOperation
 from classiq.interface.model.quantum_lambda_function import QuantumLambdaFunction
+from classiq.interface.model.repeat import Repeat
 from classiq.interface.model.variable_declaration_statement import (
     VariableDeclarationStatement,
 )
-from classiq.interface.model.within_apply_operation import WithinApplyOperation
+from classiq.interface.model.within_apply_operation import WithinApply
 
 ConcreteQuantumStatement = Union[
     QuantumFunctionCall,
@@ -23,10 +27,20 @@ ConcreteQuantumStatement = Union[
     VariableDeclarationStatement,
     BindOperation,
     InplaceBinaryOperation,
-    QuantumIfOperation,
-    WithinApplyOperation,
+    Repeat,
+    Power,
+    Invert,
+    ClassicalIf,
+    Control,
+    WithinApply,
 ]
 
 StatementBlock = List[ConcreteQuantumStatement]
 
+Control.update_forward_refs(StatementBlock=StatementBlock)
 QuantumLambdaFunction.update_forward_refs(StatementBlock=StatementBlock)
+Repeat.update_forward_refs(StatementBlock=StatementBlock)
+Power.update_forward_refs(StatementBlock=StatementBlock)
+Invert.update_forward_refs(StatementBlock=StatementBlock)
+WithinApply.update_forward_refs(StatementBlock=StatementBlock)
+ClassicalIf.update_forward_refs(StatementBlock=StatementBlock)

classiq/interface/model/validations/handles_validator.py

@@ -1,7 +1,7 @@
 from typing import Dict, Mapping, Set, Union
 
 from classiq.interface.generator.function_params import PortDirection
-from classiq.interface.generator.functions.core_lib_declarations.quantum_operators import (
+from classiq.interface.generator.functions.builtins.quantum_operators import (
     APPLY_OPERATOR,
 )
 from classiq.interface.model.handle_binding import (
@@ -11,11 +11,8 @@ from classiq.interface.model.handle_binding import (
 )
 from classiq.interface.model.port_declaration import PortDeclaration
 from classiq.interface.model.quantum_function_call import QuantumFunctionCall
-from classiq.interface.model.quantum_lambda_function import (
-    QuantumLambdaFunction,
-    QuantumOperand,
-)
 from classiq.interface.model.quantum_statement import QuantumOperation
+from classiq.interface.model.statement_block import StatementBlock
 from classiq.interface.model.validation_handle import HandleState, ValidationHandle
 from classiq.interface.model.validations.handle_validation_base import (
     HandleValidationBase,
@@ -23,7 +20,7 @@ from classiq.interface.model.validations.handle_validation_base import (
 from classiq.interface.model.variable_declaration_statement import (
     VariableDeclarationStatement,
 )
-from classiq.interface.model.within_apply_operation import WithinApplyOperation
+from classiq.interface.model.within_apply_operation import WithinApply
 
 from classiq.exceptions import ClassiqValueError
 
@@ -60,8 +57,9 @@ class HandleValidator(HandleValidationBase):
 
     def handle_operation(self, op: QuantumOperation) -> None:
         if isinstance(op, QuantumFunctionCall) and op.function == APPLY_OPERATOR.name:
-            self._handle_apply(op.operands[APPLY_OPERATOR.operand_names[0]])
-        elif isinstance(op, WithinApplyOperation):
+            call_name = op.operands[APPLY_OPERATOR.operand_names[0]]
+            self._handle_apply([QuantumFunctionCall(function=call_name)])
+        elif isinstance(op, WithinApply):
             self._handle_apply(op.action)
         self._handle_inputs(op.wiring_inputs)
         self._handle_outputs(op.wiring_outputs)
@@ -133,12 +131,10 @@ class HandleValidator(HandleValidationBase):
                 f"Invalid use of inout handle {handle!r}, used both in slice or subscript and whole"
             )
 
-    def _handle_apply(self, operand: QuantumOperand) -> None:
-        if not isinstance(operand, QuantumLambdaFunction):
-            return
+    def _handle_apply(self, body: StatementBlock) -> None:
         local_variables: Set[str] = set()
         output_capturing_variables: Set[str] = set()
-        for statement in operand.body:
+        for statement in body:
             if isinstance(statement, VariableDeclarationStatement):
                 local_variables.add(statement.name)
             elif isinstance(statement, QuantumOperation):

classiq/interface/model/within_apply_operation.py

@@ -3,9 +3,9 @@ from typing import TYPE_CHECKING
 from classiq.interface.model.quantum_statement import QuantumOperation
 
 if TYPE_CHECKING:
-    from classiq.interface.model.quantum_lambda_function import QuantumOperand
+    from classiq.interface.model.statement_block import StatementBlock
 
 
-class WithinApplyOperation(QuantumOperation):
-    compute: "QuantumOperand"
-    action: "QuantumOperand"
+class WithinApply(QuantumOperation):
+    compute: "StatementBlock"
+    action: "StatementBlock"

classiq/interface/server/routes.py

@@ -78,10 +78,6 @@ FINANCE_GENERATE_MODEL_PATH = MODEL_GENERATE_PREFIX + "/finance"
 
 GROVER_GENERATE_MODEL_PATH = MODEL_GENERATE_PREFIX + "/grover"
 
-QMOD_PREFIX = ANALYZER_PREFIX + "/qmods"
-QMOD_METADATA_PATH = QMOD_PREFIX + "/metadata"
-QMOD_FILE_PATH = QMOD_PREFIX + "/file"
-
 CONVERSION_GENERATED_CIRCUIT_TO_EXECUTION_INPUT_SUFFIX = "/execution_input"
 CONVERSION_GENERATED_CIRCUIT_TO_EXECUTION_INPUT_FULL = (
     CONVERSION_PREFIX + CONVERSION_GENERATED_CIRCUIT_TO_EXECUTION_INPUT_SUFFIX

classiq/qmod/__init__.py

@@ -5,7 +5,7 @@ from .cfunc import cfunc
 from .expression_query import get_expression_numeric_attributes
 from .qfunc import qfunc
 from .qmod_constant import QConstant
-from .qmod_parameter import Array, QParam
+from .qmod_parameter import Array, CArray, CBool, CInt, CReal, QParam
 from .qmod_struct import struct
 from .qmod_variable import Input, Output, QArray, QBit, QNum
 from .quantum_callable import QCallable, QCallableList
@@ -13,8 +13,11 @@ from .quantum_function import create_model
 from .write_qmod import write_qmod
 
 __all__ = [
-    "QParam",
     "Array",
+    "CArray",
+    "CBool",
+    "CInt",
+    "CReal",
     "Input",
     "Output",
     "QArray",
@@ -23,6 +26,7 @@ __all__ = [
     "QCallable",
     "QCallableList",
     "QConstant",
+    "QParam",
     "struct",
     "qfunc",
     "cfunc",

classiq/qmod/builtins/classical_functions.py

@@ -1,78 +1,73 @@
 # This file was generated automatically - do not edit manually
 
-from typing import List
-
-from classiq.qmod.qmod_parameter import QParam
+from classiq.qmod.qmod_parameter import CArray, CBool, CInt, CReal
 from classiq.qmod.symbolic import symbolic_function
 
 from .structs import *
 
 
+def qft_const_adder_phase(
+    bit_index: CInt,
+    value: CInt,
+    reg_len: CInt,
+) -> CReal:
+    return symbolic_function(bit_index, value, reg_len, return_type=CReal)
+
+
 def molecule_problem_to_hamiltonian(
-    problem: QParam[MoleculeProblem],
-) -> QParam[List[PauliTerm]]:
-    return symbolic_function(problem, return_type=QParam[List[PauliTerm]])
+    problem: MoleculeProblem,
+) -> CArray[PauliTerm]:
+    return symbolic_function(problem, return_type=CArray[PauliTerm])
 
 
 def fock_hamiltonian_problem_to_hamiltonian(
-    problem: QParam[FockHamiltonianProblem],
-) -> QParam[List[PauliTerm]]:
-    return symbolic_function(problem, return_type=QParam[List[PauliTerm]])
+    problem: FockHamiltonianProblem,
+) -> CArray[PauliTerm]:
+    return symbolic_function(problem, return_type=CArray[PauliTerm])
 
 
 def grid_entangler_graph(
-    num_qubits: QParam[int],
-    schmidt_rank: QParam[int],
-    grid_randomization: QParam[bool],
-) -> QParam[List[List[int]]]:
+    num_qubits: CInt,
+    schmidt_rank: CInt,
+    grid_randomization: CBool,
+) -> CArray[CArray[CInt]]:
     return symbolic_function(
-        num_qubits,
-        schmidt_rank,
-        grid_randomization,
-        return_type=QParam[List[List[int]]],
+        num_qubits, schmidt_rank, grid_randomization, return_type=CArray[CArray[CInt]]
     )
 
 
 def hypercube_entangler_graph(
-    num_qubits: QParam[int],
-) -> QParam[List[List[int]]]:
-    return symbolic_function(num_qubits, return_type=QParam[List[List[int]]])
+    num_qubits: CInt,
+) -> CArray[CArray[CInt]]:
+    return symbolic_function(num_qubits, return_type=CArray[CArray[CInt]])
 
 
 def log_normal_finance_post_process(
-    finance_model: QParam[LogNormalModel],
-    estimation_method: QParam[FinanceFunction],
-    probability: QParam[float],
-) -> QParam[float]:
+    finance_model: LogNormalModel,
+    estimation_method: FinanceFunction,
+    probability: CReal,
+) -> CReal:
     return symbolic_function(
-        finance_model, estimation_method, probability, return_type=QParam[float]
+        finance_model, estimation_method, probability, return_type=CReal
     )
 
 
 def gaussian_finance_post_process(
-    finance_model: QParam[GaussianModel],
-    estimation_method: QParam[FinanceFunction],
-    probability: QParam[float],
-) -> QParam[float]:
+    finance_model: GaussianModel,
+    estimation_method: FinanceFunction,
+    probability: CReal,
+) -> CReal:
     return symbolic_function(
-        finance_model, estimation_method, probability, return_type=QParam[float]
+        finance_model, estimation_method, probability, return_type=CReal
     )
 
 
-def qft_const_adder_phase(
-    bit_index: QParam[int],
-    value: QParam[int],
-    reg_len: QParam[int],
-) -> QParam[float]:
-    return symbolic_function(bit_index, value, reg_len, return_type=QParam[float])
-
-
 __all__ = [
+    "qft_const_adder_phase",
     "molecule_problem_to_hamiltonian",
     "fock_hamiltonian_problem_to_hamiltonian",
     "grid_entangler_graph",
     "hypercube_entangler_graph",
     "log_normal_finance_post_process",
     "gaussian_finance_post_process",
-    "qft_const_adder_phase",
 ]