classiq 0.34.0__py3-none-any.whl → 0.35.0__py3-none-any.whl

classiq/interface/model/quantum_expressions/quantum_expression.py

@@ -4,6 +4,7 @@ from typing import Dict, List, Mapping, Optional, Set, Union
 
 import pydantic
 
+from classiq.interface.generator.expressions.expression import Expression
 from classiq.interface.generator.expressions.sympy_supported_expressions import (
     SYMPY_SUPPORTED_EXPRESSIONS,
 )
@@ -30,12 +31,13 @@ class VarRefCollector(ast.NodeVisitor):
 
 
 class QuantumExpressionOperation(QuantumOperation):
-    expr_str: str = pydantic.Field(
-        description="The expression in terms of quantum variables"
-    )
+    expression: Expression = pydantic.Field()
     result_var: HandleBinding = pydantic.Field(
         description="The variable storing the expression result"
     )
+    _var_handles: List[HandleBinding] = pydantic.PrivateAttr(
+        default_factory=list,
+    )
     _var_types: Dict[str, QuantumType] = pydantic.PrivateAttr(
         default_factory=dict,
     )
@@ -45,9 +47,10 @@ class QuantumExpressionOperation(QuantumOperation):
 
     @property
     def var_handles(self) -> List[HandleBinding]:
-        vrc = VarRefCollector()
-        vrc.visit(ast.parse(self.expr_str))
-        return [HandleBinding(name=name) for name in vrc.var_names]
+        return self._var_handles
+
+    def set_var_handles(self, var_handles: List[HandleBinding]) -> None:
+        self._var_handles = var_handles
 
     @property
     def var_types(self) -> Dict[str, QuantumType]:

classiq/interface/server/routes.py

@@ -5,6 +5,8 @@ EXECUTION_PREFIX = "/execution"
 
 SYNTHESIS_SERVICE_PREFIX = "/synthesis/v1"
 
+EXECUTION_SERVICE_PREFIX = "/execution/v1"
+
 ANALYZER_CIRCUIT_PAGE = "circuit"
 DEFAULT_IDE_FE_APP = "https://platform.classiq.io/"
 
@@ -53,6 +55,7 @@ TASKS_UCC_OPERATORS_SUFFIX = "/tasks/ucc_operators"
 
 EXECUTION_JOBS_SUFFIX = "/jobs"
 EXECUTION_JOBS_FULL_PATH = EXECUTION_PREFIX + EXECUTION_JOBS_SUFFIX
+EXECUTION_SERVICE_JOBS_FULL_PATH = EXECUTION_SERVICE_PREFIX + EXECUTION_JOBS_SUFFIX
 EXECUTE_QUANTUM_PROGRAM_FULL_PATH = LEGACY_EXECUTE_PREFIX + QUANTUM_PROGRAM_SUFFIX
 EXECUTE_ESTIMATE_FULL_PATH = LEGACY_EXECUTE_PREFIX + ESTIMATE_SUFFIX
 

classiq/model/function_handler.pyi

@@ -47,107 +47,108 @@ class FunctionHandler(abc.ABC, metaclass=abc.ABCMeta):
     def include_library(self, library: FunctionLibrary) -> None: ...
     @abc.abstractmethod
     def create_library(self) -> None: ...
-    def HadamardTransform(self, params: HadamardTransform, in_wires: Optional[Dict[str, Wire]] = None) -> Dict[str, Wire]: ...
-    def RShift(self, params: RShift, in_wires: Optional[Dict[str, Wire]] = None) -> Dict[str, Wire]: ...
-    def RGate(self, params: RGate, in_wires: Optional[Dict[str, Wire]] = None) -> Dict[str, Wire]: ...
-    def LogicalAnd(self, params: LogicalAnd, in_wires: Optional[Dict[str, Wire]] = None) -> Dict[str, Wire]: ...
-    def HardwareEfficientAnsatz(self, params: HardwareEfficientAnsatz, in_wires: Optional[Dict[str, Wire]] = None) -> Dict[str, Wire]: ...
-    def NotEqual(self, params: NotEqual, in_wires: Optional[Dict[str, Wire]] = None) -> Dict[str, Wire]: ...
-    def LinearGCI(self, params: LinearGCI, in_wires: Optional[Dict[str, Wire]] = None) -> Dict[str, Wire]: ...
-    def GreaterThan(self, params: GreaterThan, in_wires: Optional[Dict[str, Wire]] = None) -> Dict[str, Wire]: ...
-    def GreaterEqual(self, params: GreaterEqual, in_wires: Optional[Dict[str, Wire]] = None) -> Dict[str, Wire]: ...
-    def LessThan(self, params: LessThan, in_wires: Optional[Dict[str, Wire]] = None) -> Dict[str, Wire]: ...
-    def LessEqual(self, params: LessEqual, in_wires: Optional[Dict[str, Wire]] = None) -> Dict[str, Wire]: ...
-    def CRZGate(self, params: CRZGate, in_wires: Optional[Dict[str, Wire]] = None) -> Dict[str, Wire]: ...
-    def CPhaseGate(self, params: CPhaseGate, in_wires: Optional[Dict[str, Wire]] = None) -> Dict[str, Wire]: ...
-    def ExponentialStatePreparation(self, params: ExponentialStatePreparation, in_wires: Optional[Dict[str, Wire]] = None) -> Dict[str, Wire]: ...
-    def HVA(self, params: HVA, in_wires: Optional[Dict[str, Wire]] = None) -> Dict[str, Wire]: ...
-    def RZGate(self, params: RZGate, in_wires: Optional[Dict[str, Wire]] = None) -> Dict[str, Wire]: ...
-    def FinancePayoff(self, params: FinancePayoff, in_wires: Optional[Dict[str, Wire]] = None) -> Dict[str, Wire]: ...
-    def Exponentiation(self, params: Exponentiation, in_wires: Optional[Dict[str, Wire]] = None) -> Dict[str, Wire]: ...
-    def UnitaryGate(self, params: UnitaryGate, in_wires: Optional[Dict[str, Wire]] = None) -> Dict[str, Wire]: ...
-    def QSVMFeatureMap(self, params: QSVMFeatureMap, in_wires: Optional[Dict[str, Wire]] = None) -> Dict[str, Wire]: ...
+    def BellStatePreparation(self, params: BellStatePreparation, in_wires: Optional[Dict[str, Wire]] = None) -> Dict[str, Wire]: ...
     def CyclicShift(self, params: CyclicShift, in_wires: Optional[Dict[str, Wire]] = None) -> Dict[str, Wire]: ...
-    def StatePreparation(self, params: StatePreparation, in_wires: Optional[Dict[str, Wire]] = None) -> Dict[str, Wire]: ...
-    def LShift(self, params: LShift, in_wires: Optional[Dict[str, Wire]] = None) -> Dict[str, Wire]: ...
-    def BitwiseAnd(self, params: BitwiseAnd, in_wires: Optional[Dict[str, Wire]] = None) -> Dict[str, Wire]: ...
-    def UniformDistributionStatePreparation(self, params: UniformDistributionStatePreparation, in_wires: Optional[Dict[str, Wire]] = None) -> Dict[str, Wire]: ...
-    def XGate(self, params: XGate, in_wires: Optional[Dict[str, Wire]] = None) -> Dict[str, Wire]: ...
-    def RYGate(self, params: RYGate, in_wires: Optional[Dict[str, Wire]] = None) -> Dict[str, Wire]: ...
-    def Negation(self, params: Negation, in_wires: Optional[Dict[str, Wire]] = None) -> Dict[str, Wire]: ...
-    def MCPhaseGate(self, params: MCPhaseGate, in_wires: Optional[Dict[str, Wire]] = None) -> Dict[str, Wire]: ...
-    def Subtractor(self, params: Subtractor, in_wires: Optional[Dict[str, Wire]] = None) -> Dict[str, Wire]: ...
-    def HartreeFock(self, params: HartreeFock, in_wires: Optional[Dict[str, Wire]] = None) -> Dict[str, Wire]: ...
-    def Finance(self, params: Finance, in_wires: Optional[Dict[str, Wire]] = None) -> Dict[str, Wire]: ...
-    def Identity(self, params: Identity, in_wires: Optional[Dict[str, Wire]] = None) -> Dict[str, Wire]: ...
-    def Mcu(self, params: Mcu, in_wires: Optional[Dict[str, Wire]] = None) -> Dict[str, Wire]: ...
-    def HypercubeEntangler(self, params: HypercubeEntangler, in_wires: Optional[Dict[str, Wire]] = None) -> Dict[str, Wire]: ...
-    def C3XGate(self, params: C3XGate, in_wires: Optional[Dict[str, Wire]] = None) -> Dict[str, Wire]: ...
-    def CYGate(self, params: CYGate, in_wires: Optional[Dict[str, Wire]] = None) -> Dict[str, Wire]: ...
-    def CZGate(self, params: CZGate, in_wires: Optional[Dict[str, Wire]] = None) -> Dict[str, Wire]: ...
-    def UGate(self, params: UGate, in_wires: Optional[Dict[str, Wire]] = None) -> Dict[str, Wire]: ...
-    def RandomizedBenchmarking(self, params: RandomizedBenchmarking, in_wires: Optional[Dict[str, Wire]] = None) -> Dict[str, Wire]: ...
-    def PhaseEstimation(self, params: PhaseEstimation, in_wires: Optional[Dict[str, Wire]] = None) -> Dict[str, Wire]: ...
-    def InequalityMixer(self, params: InequalityMixer, in_wires: Optional[Dict[str, Wire]] = None) -> Dict[str, Wire]: ...
-    def Sign(self, params: Sign, in_wires: Optional[Dict[str, Wire]] = None) -> Dict[str, Wire]: ...
     def CommutingPauliExponentiation(self, params: CommutingPauliExponentiation, in_wires: Optional[Dict[str, Wire]] = None) -> Dict[str, Wire]: ...
-    def Equal(self, params: Equal, in_wires: Optional[Dict[str, Wire]] = None) -> Dict[str, Wire]: ...
-    def AmplitudeLoading(self, params: AmplitudeLoading, in_wires: Optional[Dict[str, Wire]] = None) -> Dict[str, Wire]: ...
-    def ComputationalBasisStatePreparation(self, params: ComputationalBasisStatePreparation, in_wires: Optional[Dict[str, Wire]] = None) -> Dict[str, Wire]: ...
-    def GridEntangler(self, params: GridEntangler, in_wires: Optional[Dict[str, Wire]] = None) -> Dict[str, Wire]: ...
-    def RXGate(self, params: RXGate, in_wires: Optional[Dict[str, Wire]] = None) -> Dict[str, Wire]: ...
-    def WStatePreparation(self, params: WStatePreparation, in_wires: Optional[Dict[str, Wire]] = None) -> Dict[str, Wire]: ...
-    def Mcx(self, params: Mcx, in_wires: Optional[Dict[str, Wire]] = None) -> Dict[str, Wire]: ...
+    def UnitaryGate(self, params: UnitaryGate, in_wires: Optional[Dict[str, Wire]] = None) -> Dict[str, Wire]: ...
+    def RYGate(self, params: RYGate, in_wires: Optional[Dict[str, Wire]] = None) -> Dict[str, Wire]: ...
+    def RZZGate(self, params: RZZGate, in_wires: Optional[Dict[str, Wire]] = None) -> Dict[str, Wire]: ...
+    def CHGate(self, params: CHGate, in_wires: Optional[Dict[str, Wire]] = None) -> Dict[str, Wire]: ...
+    def CSXGate(self, params: CSXGate, in_wires: Optional[Dict[str, Wire]] = None) -> Dict[str, Wire]: ...
+    def LogicalAnd(self, params: LogicalAnd, in_wires: Optional[Dict[str, Wire]] = None) -> Dict[str, Wire]: ...
+    def Exponentiation(self, params: Exponentiation, in_wires: Optional[Dict[str, Wire]] = None) -> Dict[str, Wire]: ...
+    def BitwiseXor(self, params: BitwiseXor, in_wires: Optional[Dict[str, Wire]] = None) -> Dict[str, Wire]: ...
+    def LinearPauliRotations(self, params: LinearPauliRotations, in_wires: Optional[Dict[str, Wire]] = None) -> Dict[str, Wire]: ...
     def RYYGate(self, params: RYYGate, in_wires: Optional[Dict[str, Wire]] = None) -> Dict[str, Wire]: ...
-    def SwapGate(self, params: SwapGate, in_wires: Optional[Dict[str, Wire]] = None) -> Dict[str, Wire]: ...
-    def BellStatePreparation(self, params: BellStatePreparation, in_wires: Optional[Dict[str, Wire]] = None) -> Dict[str, Wire]: ...
     def GroverOperator(self, params: GroverOperator, in_wires: Optional[Dict[str, Wire]] = None) -> Dict[str, Wire]: ...
+    def FinanceModels(self, params: FinanceModels, in_wires: Optional[Dict[str, Wire]] = None) -> Dict[str, Wire]: ...
     def AmplitudeEstimation(self, params: AmplitudeEstimation, in_wires: Optional[Dict[str, Wire]] = None) -> Dict[str, Wire]: ...
-    def PiecewiseLinearRotationAmplitudeLoading(self, params: PiecewiseLinearRotationAmplitudeLoading, in_wires: Optional[Dict[str, Wire]] = None) -> Dict[str, Wire]: ...
+    def HadamardTransform(self, params: HadamardTransform, in_wires: Optional[Dict[str, Wire]] = None) -> Dict[str, Wire]: ...
+    def RXGate(self, params: RXGate, in_wires: Optional[Dict[str, Wire]] = None) -> Dict[str, Wire]: ...
+    def Subtractor(self, params: Subtractor, in_wires: Optional[Dict[str, Wire]] = None) -> Dict[str, Wire]: ...
+    def QSVMFeatureMap(self, params: QSVMFeatureMap, in_wires: Optional[Dict[str, Wire]] = None) -> Dict[str, Wire]: ...
+    def HypercubeEntangler(self, params: HypercubeEntangler, in_wires: Optional[Dict[str, Wire]] = None) -> Dict[str, Wire]: ...
     def QFT(self, params: QFT, in_wires: Optional[Dict[str, Wire]] = None) -> Dict[str, Wire]: ...
+    def CRYGate(self, params: CRYGate, in_wires: Optional[Dict[str, Wire]] = None) -> Dict[str, Wire]: ...
+    def AmplitudeLoading(self, params: AmplitudeLoading, in_wires: Optional[Dict[str, Wire]] = None) -> Dict[str, Wire]: ...
+    def CCXGate(self, params: CCXGate, in_wires: Optional[Dict[str, Wire]] = None) -> Dict[str, Wire]: ...
+    def CRXGate(self, params: CRXGate, in_wires: Optional[Dict[str, Wire]] = None) -> Dict[str, Wire]: ...
     def YGate(self, params: YGate, in_wires: Optional[Dict[str, Wire]] = None) -> Dict[str, Wire]: ...
-    def TwoDimensionalEntangler(self, params: TwoDimensionalEntangler, in_wires: Optional[Dict[str, Wire]] = None) -> Dict[str, Wire]: ...
+    def GHZStatePreparation(self, params: GHZStatePreparation, in_wires: Optional[Dict[str, Wire]] = None) -> Dict[str, Wire]: ...
     def ZGate(self, params: ZGate, in_wires: Optional[Dict[str, Wire]] = None) -> Dict[str, Wire]: ...
     def HGate(self, params: HGate, in_wires: Optional[Dict[str, Wire]] = None) -> Dict[str, Wire]: ...
-    def CHGate(self, params: CHGate, in_wires: Optional[Dict[str, Wire]] = None) -> Dict[str, Wire]: ...
-    def CustomFunction(self, params: CustomFunction, in_wires: Optional[Dict[str, Wire]] = None) -> Dict[str, Wire]: ...
-    def CSXGate(self, params: CSXGate, in_wires: Optional[Dict[str, Wire]] = None) -> Dict[str, Wire]: ...
-    def SGate(self, params: SGate, in_wires: Optional[Dict[str, Wire]] = None) -> Dict[str, Wire]: ...
+    def iSwapGate(self, params: iSwapGate, in_wires: Optional[Dict[str, Wire]] = None) -> Dict[str, Wire]: ...
+    def C4XGate(self, params: C4XGate, in_wires: Optional[Dict[str, Wire]] = None) -> Dict[str, Wire]: ...
+    def UGate(self, params: UGate, in_wires: Optional[Dict[str, Wire]] = None) -> Dict[str, Wire]: ...
+    def Arithmetic(self, params: Arithmetic, in_wires: Optional[Dict[str, Wire]] = None) -> Dict[str, Wire]: ...
+    def TwoDimensionalEntangler(self, params: TwoDimensionalEntangler, in_wires: Optional[Dict[str, Wire]] = None) -> Dict[str, Wire]: ...
+    def ComputationalBasisStatePreparation(self, params: ComputationalBasisStatePreparation, in_wires: Optional[Dict[str, Wire]] = None) -> Dict[str, Wire]: ...
+    def LShift(self, params: LShift, in_wires: Optional[Dict[str, Wire]] = None) -> Dict[str, Wire]: ...
+    def StatePreparation(self, params: StatePreparation, in_wires: Optional[Dict[str, Wire]] = None) -> Dict[str, Wire]: ...
+    def BitwiseOr(self, params: BitwiseOr, in_wires: Optional[Dict[str, Wire]] = None) -> Dict[str, Wire]: ...
+    def SwapGate(self, params: SwapGate, in_wires: Optional[Dict[str, Wire]] = None) -> Dict[str, Wire]: ...
+    def RandomizedBenchmarking(self, params: RandomizedBenchmarking, in_wires: Optional[Dict[str, Wire]] = None) -> Dict[str, Wire]: ...
+    def FinancePayoff(self, params: FinancePayoff, in_wires: Optional[Dict[str, Wire]] = None) -> Dict[str, Wire]: ...
+    def ArithmeticOracle(self, params: ArithmeticOracle, in_wires: Optional[Dict[str, Wire]] = None) -> Dict[str, Wire]: ...
+    def RXXGate(self, params: RXXGate, in_wires: Optional[Dict[str, Wire]] = None) -> Dict[str, Wire]: ...
     def IGate(self, params: IGate, in_wires: Optional[Dict[str, Wire]] = None) -> Dict[str, Wire]: ...
-    def RZZGate(self, params: RZZGate, in_wires: Optional[Dict[str, Wire]] = None) -> Dict[str, Wire]: ...
-    def SuzukiTrotter(self, params: SuzukiTrotter, in_wires: Optional[Dict[str, Wire]] = None) -> Dict[str, Wire]: ...
-    def SXGate(self, params: SXGate, in_wires: Optional[Dict[str, Wire]] = None) -> Dict[str, Wire]: ...
+    def SGate(self, params: SGate, in_wires: Optional[Dict[str, Wire]] = None) -> Dict[str, Wire]: ...
     def SdgGate(self, params: SdgGate, in_wires: Optional[Dict[str, Wire]] = None) -> Dict[str, Wire]: ...
+    def CPhaseGate(self, params: CPhaseGate, in_wires: Optional[Dict[str, Wire]] = None) -> Dict[str, Wire]: ...
+    def SXGate(self, params: SXGate, in_wires: Optional[Dict[str, Wire]] = None) -> Dict[str, Wire]: ...
     def SXdgGate(self, params: SXdgGate, in_wires: Optional[Dict[str, Wire]] = None) -> Dict[str, Wire]: ...
-    def GHZStatePreparation(self, params: GHZStatePreparation, in_wires: Optional[Dict[str, Wire]] = None) -> Dict[str, Wire]: ...
+    def GridEntangler(self, params: GridEntangler, in_wires: Optional[Dict[str, Wire]] = None) -> Dict[str, Wire]: ...
+    def NotEqual(self, params: NotEqual, in_wires: Optional[Dict[str, Wire]] = None) -> Dict[str, Wire]: ...
+    def CRZGate(self, params: CRZGate, in_wires: Optional[Dict[str, Wire]] = None) -> Dict[str, Wire]: ...
     def TGate(self, params: TGate, in_wires: Optional[Dict[str, Wire]] = None) -> Dict[str, Wire]: ...
+    def CustomFunction(self, params: CustomFunction, in_wires: Optional[Dict[str, Wire]] = None) -> Dict[str, Wire]: ...
     def TdgGate(self, params: TdgGate, in_wires: Optional[Dict[str, Wire]] = None) -> Dict[str, Wire]: ...
-    def iSwapGate(self, params: iSwapGate, in_wires: Optional[Dict[str, Wire]] = None) -> Dict[str, Wire]: ...
-    def QDrift(self, params: QDrift, in_wires: Optional[Dict[str, Wire]] = None) -> Dict[str, Wire]: ...
-    def CustomOracle(self, params: CustomOracle, in_wires: Optional[Dict[str, Wire]] = None) -> Dict[str, Wire]: ...
-    def BitwiseXor(self, params: BitwiseXor, in_wires: Optional[Dict[str, Wire]] = None) -> Dict[str, Wire]: ...
+    def HVA(self, params: HVA, in_wires: Optional[Dict[str, Wire]] = None) -> Dict[str, Wire]: ...
+    def PhaseGate(self, params: PhaseGate, in_wires: Optional[Dict[str, Wire]] = None) -> Dict[str, Wire]: ...
+    def WeightedAdder(self, params: WeightedAdder, in_wires: Optional[Dict[str, Wire]] = None) -> Dict[str, Wire]: ...
     def Modulo(self, params: Modulo, in_wires: Optional[Dict[str, Wire]] = None) -> Dict[str, Wire]: ...
-    def LogicalOr(self, params: LogicalOr, in_wires: Optional[Dict[str, Wire]] = None) -> Dict[str, Wire]: ...
+    def Mcu(self, params: Mcu, in_wires: Optional[Dict[str, Wire]] = None) -> Dict[str, Wire]: ...
+    def BitwiseInvert(self, params: BitwiseInvert, in_wires: Optional[Dict[str, Wire]] = None) -> Dict[str, Wire]: ...
+    def MCPhaseGate(self, params: MCPhaseGate, in_wires: Optional[Dict[str, Wire]] = None) -> Dict[str, Wire]: ...
+    def Adder(self, params: Adder, in_wires: Optional[Dict[str, Wire]] = None) -> Dict[str, Wire]: ...
+    def Negation(self, params: Negation, in_wires: Optional[Dict[str, Wire]] = None) -> Dict[str, Wire]: ...
+    def UniformDistributionStatePreparation(self, params: UniformDistributionStatePreparation, in_wires: Optional[Dict[str, Wire]] = None) -> Dict[str, Wire]: ...
+    def InequalityMixer(self, params: InequalityMixer, in_wires: Optional[Dict[str, Wire]] = None) -> Dict[str, Wire]: ...
+    def HardwareEfficientAnsatz(self, params: HardwareEfficientAnsatz, in_wires: Optional[Dict[str, Wire]] = None) -> Dict[str, Wire]: ...
     def Multiplier(self, params: Multiplier, in_wires: Optional[Dict[str, Wire]] = None) -> Dict[str, Wire]: ...
+    def RGate(self, params: RGate, in_wires: Optional[Dict[str, Wire]] = None) -> Dict[str, Wire]: ...
+    def PhaseEstimation(self, params: PhaseEstimation, in_wires: Optional[Dict[str, Wire]] = None) -> Dict[str, Wire]: ...
+    def Equal(self, params: Equal, in_wires: Optional[Dict[str, Wire]] = None) -> Dict[str, Wire]: ...
+    def CXGate(self, params: CXGate, in_wires: Optional[Dict[str, Wire]] = None) -> Dict[str, Wire]: ...
+    def SuzukiTrotter(self, params: SuzukiTrotter, in_wires: Optional[Dict[str, Wire]] = None) -> Dict[str, Wire]: ...
+    def Identity(self, params: Identity, in_wires: Optional[Dict[str, Wire]] = None) -> Dict[str, Wire]: ...
+    def GroverDiffuser(self, params: GroverDiffuser, in_wires: Optional[Dict[str, Wire]] = None) -> Dict[str, Wire]: ...
+    def UCC(self, params: UCC, in_wires: Optional[Dict[str, Wire]] = None) -> Dict[str, Wire]: ...
+    def ExponentialStatePreparation(self, params: ExponentialStatePreparation, in_wires: Optional[Dict[str, Wire]] = None) -> Dict[str, Wire]: ...
+    def GreaterThan(self, params: GreaterThan, in_wires: Optional[Dict[str, Wire]] = None) -> Dict[str, Wire]: ...
+    def GreaterEqual(self, params: GreaterEqual, in_wires: Optional[Dict[str, Wire]] = None) -> Dict[str, Wire]: ...
+    def LessThan(self, params: LessThan, in_wires: Optional[Dict[str, Wire]] = None) -> Dict[str, Wire]: ...
+    def LessEqual(self, params: LessEqual, in_wires: Optional[Dict[str, Wire]] = None) -> Dict[str, Wire]: ...
+    def BitwiseAnd(self, params: BitwiseAnd, in_wires: Optional[Dict[str, Wire]] = None) -> Dict[str, Wire]: ...
+    def CustomOracle(self, params: CustomOracle, in_wires: Optional[Dict[str, Wire]] = None) -> Dict[str, Wire]: ...
+    def LogicalOr(self, params: LogicalOr, in_wires: Optional[Dict[str, Wire]] = None) -> Dict[str, Wire]: ...
+    def Mcx(self, params: Mcx, in_wires: Optional[Dict[str, Wire]] = None) -> Dict[str, Wire]: ...
+    def Power(self, params: Power, in_wires: Optional[Dict[str, Wire]] = None) -> Dict[str, Wire]: ...
+    def Sign(self, params: Sign, in_wires: Optional[Dict[str, Wire]] = None) -> Dict[str, Wire]: ...
     def Min(self, params: Min, in_wires: Optional[Dict[str, Wire]] = None) -> Dict[str, Wire]: ...
-    def BitwiseInvert(self, params: BitwiseInvert, in_wires: Optional[Dict[str, Wire]] = None) -> Dict[str, Wire]: ...
+    def LinearGCI(self, params: LinearGCI, in_wires: Optional[Dict[str, Wire]] = None) -> Dict[str, Wire]: ...
+    def CZGate(self, params: CZGate, in_wires: Optional[Dict[str, Wire]] = None) -> Dict[str, Wire]: ...
+    def CYGate(self, params: CYGate, in_wires: Optional[Dict[str, Wire]] = None) -> Dict[str, Wire]: ...
+    def WStatePreparation(self, params: WStatePreparation, in_wires: Optional[Dict[str, Wire]] = None) -> Dict[str, Wire]: ...
+    def C3XGate(self, params: C3XGate, in_wires: Optional[Dict[str, Wire]] = None) -> Dict[str, Wire]: ...
     def Max(self, params: Max, in_wires: Optional[Dict[str, Wire]] = None) -> Dict[str, Wire]: ...
-    def GroverDiffuser(self, params: GroverDiffuser, in_wires: Optional[Dict[str, Wire]] = None) -> Dict[str, Wire]: ...
-    def LinearPauliRotations(self, params: LinearPauliRotations, in_wires: Optional[Dict[str, Wire]] = None) -> Dict[str, Wire]: ...
-    def RangeMixer(self, params: RangeMixer, in_wires: Optional[Dict[str, Wire]] = None) -> Dict[str, Wire]: ...
-    def Arithmetic(self, params: Arithmetic, in_wires: Optional[Dict[str, Wire]] = None) -> Dict[str, Wire]: ...
-    def FinanceModels(self, params: FinanceModels, in_wires: Optional[Dict[str, Wire]] = None) -> Dict[str, Wire]: ...
-    def RXXGate(self, params: RXXGate, in_wires: Optional[Dict[str, Wire]] = None) -> Dict[str, Wire]: ...
+    def RZGate(self, params: RZGate, in_wires: Optional[Dict[str, Wire]] = None) -> Dict[str, Wire]: ...
+    def PiecewiseLinearRotationAmplitudeLoading(self, params: PiecewiseLinearRotationAmplitudeLoading, in_wires: Optional[Dict[str, Wire]] = None) -> Dict[str, Wire]: ...
+    def Finance(self, params: Finance, in_wires: Optional[Dict[str, Wire]] = None) -> Dict[str, Wire]: ...
+    def QDrift(self, params: QDrift, in_wires: Optional[Dict[str, Wire]] = None) -> Dict[str, Wire]: ...
+    def XGate(self, params: XGate, in_wires: Optional[Dict[str, Wire]] = None) -> Dict[str, Wire]: ...
     def PiecewiseLinearAmplitudeLoading(self, params: PiecewiseLinearAmplitudeLoading, in_wires: Optional[Dict[str, Wire]] = None) -> Dict[str, Wire]: ...
-    def CCXGate(self, params: CCXGate, in_wires: Optional[Dict[str, Wire]] = None) -> Dict[str, Wire]: ...
-    def CRYGate(self, params: CRYGate, in_wires: Optional[Dict[str, Wire]] = None) -> Dict[str, Wire]: ...
     def StatePropagator(self, params: StatePropagator, in_wires: Optional[Dict[str, Wire]] = None) -> Dict[str, Wire]: ...
-    def CRXGate(self, params: CRXGate, in_wires: Optional[Dict[str, Wire]] = None) -> Dict[str, Wire]: ...
-    def PhaseGate(self, params: PhaseGate, in_wires: Optional[Dict[str, Wire]] = None) -> Dict[str, Wire]: ...
-    def CXGate(self, params: CXGate, in_wires: Optional[Dict[str, Wire]] = None) -> Dict[str, Wire]: ...
-    def ArithmeticOracle(self, params: ArithmeticOracle, in_wires: Optional[Dict[str, Wire]] = None) -> Dict[str, Wire]: ...
-    def WeightedAdder(self, params: WeightedAdder, in_wires: Optional[Dict[str, Wire]] = None) -> Dict[str, Wire]: ...
-    def UCC(self, params: UCC, in_wires: Optional[Dict[str, Wire]] = None) -> Dict[str, Wire]: ...
-    def C4XGate(self, params: C4XGate, in_wires: Optional[Dict[str, Wire]] = None) -> Dict[str, Wire]: ...
-    def Adder(self, params: Adder, in_wires: Optional[Dict[str, Wire]] = None) -> Dict[str, Wire]: ...
-    def BitwiseOr(self, params: BitwiseOr, in_wires: Optional[Dict[str, Wire]] = None) -> Dict[str, Wire]: ...
+    def RShift(self, params: RShift, in_wires: Optional[Dict[str, Wire]] = None) -> Dict[str, Wire]: ...
+    def RangeMixer(self, params: RangeMixer, in_wires: Optional[Dict[str, Wire]] = None) -> Dict[str, Wire]: ...
+    def HartreeFock(self, params: HartreeFock, in_wires: Optional[Dict[str, Wire]] = None) -> Dict[str, Wire]: ...

classiq/qmod/__init__.py

@@ -1,5 +1,5 @@
-from .qmod_builtins import *  # noqa: F403
-from .qmod_builtins import __all__ as _builtins_all
+from .builtins import *  # noqa: F403
+from .builtins import __all__ as _builtins_all
 from .qmod_parameter import Array, QParam
 from .qmod_struct import QStruct
 from .qmod_variable import Input, Output, QArray, QBit, QFixed, QInt

classiq/qmod/builtins/__init__.py

@@ -0,0 +1,8 @@
+from .functions import *  # noqa: F403
+from .functions import __all__ as _builtin_functions
+from .operations import *  # noqa: F403
+from .operations import __all__ as _builtin_operations
+from .structs import *  # noqa: F403
+from .structs import __all__ as _builtin_structs
+
+__all__ = _builtin_structs + _builtin_functions + _builtin_operations

classiq/qmod/{qmod_builtins.py → builtins/functions.py}

@@ -1,115 +1,13 @@
+# This file was generated automatically - do not edit manually
+
 from typing import List, Literal
 
 from classiq.qmod.qmod_parameter import QParam
-from classiq.qmod.qmod_struct import QStruct
 from classiq.qmod.qmod_variable import Input, Output, QArray, QBit
 from classiq.qmod.quantum_callable import QCallable
 from classiq.qmod.quantum_function import ExternalQFunc
 
-
-@QStruct
-class PauliTerm:
-    pauli: List[int]
-    coefficient: float
-
-
-@QStruct
-class MoleculeProblem:
-    mapping: int
-    z2_symmetries: bool
-    molecule: "Molecule"
-    freeze_core: bool
-    remove_orbitals: List[int]
-
-
-@QStruct
-class Molecule:
-    atoms: List["ChemistryAtom"]
-    spin: int
-    charge: int
-
-
-@QStruct
-class ChemistryAtom:
-    element: int
-    position: "Position"
-
-
-@QStruct
-class Position:
-    x: float
-    y: float
-    z: float
-
-
-@QStruct
-class FockHamiltonianProblem:
-    mapping: int
-    z2_symmetries: bool
-    terms: List["LadderTerm"]
-    num_particles: List[int]
-
-
-@QStruct
-class LadderTerm:
-    coefficient: float
-    ops: List["LadderOp"]
-
-
-@QStruct
-class LadderOp:
-    op: int
-    index: int
-
-
-@QStruct
-class CombinatorialOptimizationSolution:
-    probability: float
-    cost: float
-    solution: List[int]
-    count: int
-
-
-@QStruct
-class GaussianModel:
-    num_qubits: int
-    normal_max_value: float
-    default_probabilities: List[float]
-    rhos: List[float]
-    loss: List[int]
-    min_loss: int
-
-
-@QStruct
-class LogNormalModel:
-    num_qubits: int
-    mu: float
-    sigma: float
-
-
-@QStruct
-class FinanceFunction:
-    f: int
-    threshold: float
-    larger: bool
-    polynomial_degree: int
-    use_chebyshev_polynomial_approximation: bool
-    tail_probability: float
-
-
-@QStruct
-class QsvmResult:
-    test_score: float
-    predicted_labels: List[float]
-
-
-@QStruct
-class QSVMFeatureMapPauli:
-    feature_dimension: int
-    reps: int
-    entanglement: int
-    alpha: float
-    paulis: List[List[int]]
+from .structs import *
 
 
 @ExternalQFunc
@@ -394,7 +292,7 @@ def single_pauli_exponent(
 
 @ExternalQFunc
 def suzuki_trotter(
-    pauli_operator: QParam[List["PauliTerm"]],
+    pauli_operator: QParam[List[PauliTerm]],
     evolution_coefficient: QParam[float],
     order: QParam[int],
     repetitions: QParam[int],
@@ -405,7 +303,7 @@ def suzuki_trotter(
 
 @ExternalQFunc
 def qdrift(
-    pauli_operator: QParam[List["PauliTerm"]],
+    pauli_operator: QParam[List[PauliTerm]],
     evolution_coefficient: QParam[float],
     num_qdrift: QParam[int],
     qbv: QArray[QBit, Literal["len(get_field(pauli_operator[0], 'pauli'))"]],
@@ -415,7 +313,7 @@ def qdrift(
 
 @ExternalQFunc
 def exponentiation_with_depth_constraint(
-    pauli_operator: QParam[List["PauliTerm"]],
+    pauli_operator: QParam[List[PauliTerm]],
     evolution_coefficient: QParam[float],
     max_depth: QParam[int],
     qbv: QArray[QBit, Literal["len(get_field(pauli_operator[0], 'pauli'))"]],
@@ -437,6 +335,15 @@ def qft(
     pass
 
 
+@ExternalQFunc
+def standard_qpe(
+    precision: QParam[int],
+    unitary: QCallable,
+    phase: QArray[QBit, Literal["precision"]],
+) -> None:
+    pass
+
+
 @ExternalQFunc
 def qpe(
     precision: QParam[int],
@@ -550,7 +457,7 @@ def qaoa_mixer_layer(
 @ExternalQFunc
 def qaoa_cost_layer(
     g: QParam[float],
-    hamiltonian: QParam[List["PauliTerm"]],
+    hamiltonian: QParam[List[PauliTerm]],
     is_st: QParam[bool],
     target: QArray[QBit],
 ) -> None:
@@ -561,7 +468,7 @@ def qaoa_cost_layer(
 def qaoa_layer(
     g: QParam[float],
     b: QParam[float],
-    hamiltonian: QParam[List["PauliTerm"]],
+    hamiltonian: QParam[List[PauliTerm]],
     is_st: QParam[bool],
     target: QArray[QBit],
 ) -> None:
@@ -579,7 +486,7 @@ def qaoa_init(
 def qaoa_penalty(
     num_qubits: QParam[int],
     params_list: QParam[List[float]],
-    hamiltonian: QParam[List["PauliTerm"]],
+    hamiltonian: QParam[List[PauliTerm]],
     is_st: QParam[bool],
     target: QArray[QBit, Literal["num_qubits"]],
 ) -> None:
@@ -677,7 +584,7 @@ def power(
 
 @ExternalQFunc
 def molecule_ucc(
-    molecule_problem: QParam["MoleculeProblem"],
+    molecule_problem: QParam[MoleculeProblem],
     excitations: QParam[List[int]],
     qbv: QArray[
         QBit,
@@ -691,7 +598,7 @@ def molecule_ucc(
 
 @ExternalQFunc
 def molecule_hva(
-    molecule_problem: QParam["MoleculeProblem"],
+    molecule_problem: QParam[MoleculeProblem],
     reps: QParam[int],
     qbv: QArray[
         QBit,
@@ -705,7 +612,7 @@ def molecule_hva(
 
 @ExternalQFunc
 def molecule_hartree_fock(
-    molecule_problem: QParam["MoleculeProblem"],
+    molecule_problem: QParam[MoleculeProblem],
     qbv: QArray[
         QBit,
         Literal[
@@ -718,7 +625,7 @@ def molecule_hartree_fock(
 
 @ExternalQFunc
 def fock_hamiltonian_ucc(
-    fock_hamiltonian_problem: QParam["FockHamiltonianProblem"],
+    fock_hamiltonian_problem: QParam[FockHamiltonianProblem],
     excitations: QParam[List[int]],
     qbv: QArray[
         QBit,
@@ -732,7 +639,7 @@ def fock_hamiltonian_ucc(
 
 @ExternalQFunc
 def fock_hamiltonian_hva(
-    fock_hamiltonian_problem: QParam["FockHamiltonianProblem"],
+    fock_hamiltonian_problem: QParam[FockHamiltonianProblem],
     reps: QParam[int],
     qbv: QArray[
         QBit,
@@ -746,7 +653,7 @@ def fock_hamiltonian_hva(
 
 @ExternalQFunc
 def fock_hamiltonian_hartree_fock(
-    fock_hamiltonian_problem: QParam["FockHamiltonianProblem"],
+    fock_hamiltonian_problem: QParam[FockHamiltonianProblem],
     qbv: QArray[
         QBit,
         Literal[
@@ -759,8 +666,8 @@ def fock_hamiltonian_hartree_fock(
 
 @ExternalQFunc
 def log_normal_finance(
-    finance_model: QParam["LogNormalModel"],
-    finance_function: QParam["FinanceFunction"],
+    finance_model: QParam[LogNormalModel],
+    finance_function: QParam[FinanceFunction],
     func_port: QArray[QBit, Literal["get_field(finance_model, 'num_qubits')"]],
     obj_port: QBit,
 ) -> None:
@@ -769,8 +676,8 @@ def log_normal_finance(
 
 @ExternalQFunc
 def gaussian_finance(
-    finance_model: QParam["GaussianModel"],
-    finance_function: QParam["FinanceFunction"],
+    finance_model: QParam[GaussianModel],
+    finance_function: QParam[FinanceFunction],
     func_port: QArray[
         QBit,
         Literal[
@@ -784,7 +691,7 @@ def gaussian_finance(
 
 @ExternalQFunc
 def pauli_feature_map(
-    feature_map: QParam["QSVMFeatureMapPauli"],
+    feature_map: QParam[QSVMFeatureMapPauli],
     qbv: QArray[QBit, Literal["get_field(feature_map, 'feature_dimension')"]],
 ) -> None:
     pass
@@ -799,20 +706,6 @@ def bloch_sphere_feature_map(
 
 
 __all__ = [
-    "PauliTerm",
-    "MoleculeProblem",
-    "Molecule",
-    "ChemistryAtom",
-    "Position",
-    "FockHamiltonianProblem",
-    "LadderTerm",
-    "LadderOp",
-    "CombinatorialOptimizationSolution",
-    "GaussianModel",
-    "LogNormalModel",
-    "FinanceFunction",
-    "QsvmResult",
-    "QSVMFeatureMapPauli",
     "H",
     "X",
     "Y",
@@ -853,6 +746,7 @@ __all__ = [
     "exponentiation_with_depth_constraint",
     "qft_step",
     "qft",
+    "standard_qpe",
     "qpe",
     "single_pauli",
     "linear_pauli_rotations",

classiq/qmod/builtins/operations.py

@@ -0,0 +1,19 @@
+from classiq.interface.model.bind_operation import BindOperation
+
+from classiq.qmod.qmod_variable import Input, Output, QVar
+from classiq.qmod.quantum_callable import QCallable
+
+
+def bind(source: Input[QVar], destination: Output[QVar]) -> None:
+    assert QCallable.CURRENT_EXPANDABLE is not None
+    QCallable.CURRENT_EXPANDABLE.append_statement_to_body(
+        BindOperation(
+            in_handle=source.get_handle_binding(),
+            out_handle=destination.get_handle_binding(),
+        )
+    )
+
+
+__all__ = [
+    "bind",
+]