classiq 0.39.0__py3-none-any.whl → 0.41.0__py3-none-any.whl

classiq/interface/model/statement_block.py

@@ -1,5 +1,8 @@
 from typing import List, Union
 
+from pydantic import Field
+from typing_extensions import Annotated
+
 from classiq.interface.model.bind_operation import BindOperation
 from classiq.interface.model.classical_if import ClassicalIf
 from classiq.interface.model.control import Control
@@ -13,7 +16,6 @@ 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 QuantumIf
 from classiq.interface.model.quantum_lambda_function import QuantumLambdaFunction
 from classiq.interface.model.repeat import Repeat
 from classiq.interface.model.variable_declaration_statement import (
@@ -21,26 +23,27 @@ from classiq.interface.model.variable_declaration_statement import (
 )
 from classiq.interface.model.within_apply_operation import WithinApply
 
-ConcreteQuantumStatement = Union[
-    QuantumFunctionCall,
-    ArithmeticOperation,
-    AmplitudeLoadingOperation,
-    VariableDeclarationStatement,
-    BindOperation,
-    InplaceBinaryOperation,
-    Control,
-    Repeat,
-    Power,
-    Invert,
-    ClassicalIf,
-    QuantumIf,
-    WithinApply,
+ConcreteQuantumStatement = Annotated[
+    Union[
+        QuantumFunctionCall,
+        ArithmeticOperation,
+        AmplitudeLoadingOperation,
+        VariableDeclarationStatement,
+        BindOperation,
+        InplaceBinaryOperation,
+        Repeat,
+        Power,
+        Invert,
+        ClassicalIf,
+        Control,
+        WithinApply,
+    ],
+    Field(..., discriminator="kind"),
 ]
 
 StatementBlock = List[ConcreteQuantumStatement]
 
 Control.update_forward_refs(StatementBlock=StatementBlock)
-QuantumIf.update_forward_refs(StatementBlock=StatementBlock)
 QuantumLambdaFunction.update_forward_refs(StatementBlock=StatementBlock)
 Repeat.update_forward_refs(StatementBlock=StatementBlock)
 Power.update_forward_refs(StatementBlock=StatementBlock)

classiq/interface/model/validations/handles_validator.py

@@ -61,8 +61,14 @@ class HandleValidator(HandleValidationBase):
             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)
+
+        if isinstance(op, QuantumFunctionCall) and op.synthesis_data.is_inverse:
+            self._handle_inputs(op.wiring_outputs)
+            self._handle_outputs(op.wiring_inputs)
+        else:
+            self._handle_inputs(op.wiring_inputs)
+            self._handle_outputs(op.wiring_outputs)
+
         self._handle_inouts(op.wiring_inouts)
 
     def handle_variable_declaration(

classiq/interface/model/variable_declaration_statement.py

@@ -1,3 +1,5 @@
+from typing import Literal
+
 from classiq.interface.model.quantum_statement import QuantumStatement
 from classiq.interface.model.quantum_variable_declaration import (
     QuantumVariableDeclaration,
@@ -5,4 +7,4 @@ from classiq.interface.model.quantum_variable_declaration import (
 
 
 class VariableDeclarationStatement(QuantumStatement, QuantumVariableDeclaration):
-    pass
+    kind: Literal["VariableDeclarationStatement"]

classiq/interface/model/within_apply_operation.py

@@ -1,4 +1,4 @@
-from typing import TYPE_CHECKING
+from typing import TYPE_CHECKING, Literal
 
 from classiq.interface.model.quantum_statement import QuantumOperation
 
@@ -7,5 +7,7 @@ if TYPE_CHECKING:
 
 
 class WithinApply(QuantumOperation):
+    kind: Literal["WithinApply"]
+
     compute: "StatementBlock"
     action: "StatementBlock"

classiq/interface/server/routes.py

@@ -1,6 +1,5 @@
 ANALYZER_PREFIX = "/analyzer"
 CHEMISTRY_PREFIX = "/chemistry"
-LEGACY_EXECUTE_PREFIX = "/execute"
 EXECUTION_PREFIX = "/execution"
 CONVERSION_PREFIX = "/conversion"
 
@@ -22,8 +21,6 @@ ANALYZER_OPTIONAL_DEVICES = "/graphs/available_devices"
 ANALYZER_OPTIONAL_DEVICES_FULL_PATH = ANALYZER_PREFIX + ANALYZER_OPTIONAL_DEVICES
 
 TASKS_SUFFIX = "/tasks"
-QUANTUM_PROGRAM_SUFFIX = "/quantum_program"
-ESTIMATE_SUFFIX = "/estimate"
 RB = "/rb"
 ANALYZER_DATA_TASK = f"{TASKS_SUFFIX}/data"
 ANALYZER_QASM_TASK = f"{TASKS_SUFFIX}/qasm"
@@ -60,8 +57,6 @@ EXECUTION_JOBS_FULL_PATH = EXECUTION_PREFIX + EXECUTION_JOBS_SUFFIX
 EXECUTION_JOBS_NON_VERSIONED_FULL_PATH = (
     EXECUTION_NON_VERSIONED_PREFIX + EXECUTION_JOBS_SUFFIX
 )
-EXECUTE_QUANTUM_PROGRAM_FULL_PATH = LEGACY_EXECUTE_PREFIX + QUANTUM_PROGRAM_SUFFIX
-EXECUTE_ESTIMATE_FULL_PATH = LEGACY_EXECUTE_PREFIX + ESTIMATE_SUFFIX
 
 ANALYZER_FULL_PATH = ANALYZER_PREFIX + TASKS_SUFFIX
 ANALYZER_RB_FULL_PATH = ANALYZER_PREFIX + TASK_RB_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
 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",

classiq/qmod/builtins/classical_execution_primitives.py

@@ -2,7 +2,12 @@ from typing import Dict, List, Optional, Union
 
 from classiq.interface.executor.execution_preferences import QaeWithQpeEstimationMethod
 from classiq.interface.executor.iqae_result import IQAEResult
-from classiq.interface.executor.result import EstimationResult, ExecutionDetails
+from classiq.interface.executor.result import (
+    EstimationResult,
+    EstimationResults,
+    ExecutionDetails,
+    MultipleExecutionDetails,
+)
 from classiq.interface.executor.vqe_result import VQESolverResult
 from classiq.interface.generator.expressions.enums import Optimizer
 from classiq.interface.generator.functions.qmod_python_interface import QmodPyStruct
@@ -31,16 +36,29 @@ def sample(  # type: ignore[return]
     _raise_error("sample")
 
 
+def batch_sample(  # type: ignore[return]
+    batch_execution_params: List[ExecutionParams],
+) -> MultipleExecutionDetails:
+    _raise_error("batch_sample")
+
+
 def estimate(  # type: ignore[return]
     hamiltonian: List[QmodPyStruct], execution_params: Optional[ExecutionParams] = None
 ) -> EstimationResult:
     _raise_error("estimate")
 
 
+def batch_estimate(  # type: ignore[return]
+    hamiltonian: List[QmodPyStruct],
+    batch_execution_params: List[ExecutionParams],
+) -> EstimationResults:
+    _raise_error("batch_estimate")
+
+
 def vqe(  # type: ignore[return]
     hamiltonian: List[QmodPyStruct],
     maximize: bool,
-    initial_point: List[int],
+    initial_point: List[float],
     optimizer: Optimizer,
     max_iteration: int,
     tolerance: float,
@@ -87,7 +105,9 @@ __all__ = [
     "ExecutionParams",
     "save",
     "sample",
+    "batch_sample",
     "estimate",
+    "batch_estimate",
     "vqe",
     "qae_with_qpe_result_post_processing",
     "qsvm_full_run",

classiq/qmod/builtins/classical_functions.py

@@ -1,69 +1,64 @@
 # 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: QParam[int],
-    value: QParam[int],
-    reg_len: QParam[int],
-) -> QParam[float]:
-    return symbolic_function(bit_index, value, reg_len, return_type=QParam[float])
+    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
     )