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

classiq/model/function_handler.pyi

@@ -40,114 +40,115 @@ class FunctionHandler(abc.ABC, metaclass=abc.ABCMeta):
     def output_wires(self) -> WireNameDict: ...
     def create_inputs(self, inputs: Mapping[IOName, QRegGenericAlias]) -> Dict[IOName, QReg]: ...
     def set_outputs(self, outputs: Mapping[IOName, QReg]) -> None: ...
-    def apply(self, function_name: Union[str, SynthesisQuantumFunctionDeclaration, QuantumFunction], in_wires: Optional[SupportedInputArgs] = ..., out_wires: Optional[SupportedInputArgs] = ..., is_inverse: bool = ..., strict_zero_ios: bool = ..., release_by_inverse: bool = ..., control_states: Optional[Union[ControlState, Iterable[ControlState]]] = ..., should_control: bool = ..., power: int = ..., call_name: Optional[str] = ..., parameters_dict: Optional[Dict[str, ParameterFloatType]] = ...) -> Dict[IOName, QReg]: ...
+    def apply(self, function_name: Union[str, SynthesisQuantumFunctionDeclaration, QuantumFunction], in_wires: Optional[SupportedInputArgs] = None, out_wires: Optional[SupportedInputArgs] = None, is_inverse: bool = False, strict_zero_ios: bool = True, release_by_inverse: bool = False, control_states: Optional[Union[ControlState, Iterable[ControlState]]] = None, should_control: bool = True, power: int = 1, call_name: Optional[str] = None, parameters_dict: Optional[Dict[str, ParameterFloatType]] = None) -> Dict[IOName, QReg]: ...
     def release_qregs(self, qregs: Union[QReg, Collection[QReg]]) -> None: ...
     def __getattr__(self, item: str) -> Callable[..., Any]: ...
     def __dir__(self) -> List[str]: ...
     def include_library(self, library: FunctionLibrary) -> None: ...
     @abc.abstractmethod
     def create_library(self) -> None: ...
-    def YGate(self, params: YGate, 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 Finance(self, params: Finance, 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 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 CommutingPauliExponentiation(self, params: CommutingPauliExponentiation, 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 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 UniformDistributionStatePreparation(self, params: UniformDistributionStatePreparation, 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 RYYGate(self, params: RYYGate, 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 Mcu(self, params: Mcu, 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 GridEntangler(self, params: GridEntangler, 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 Equal(self, params: Equal, 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 Negation(self, params: Negation, 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 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 RandomizedBenchmarking(self, params: RandomizedBenchmarking, 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 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 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 PhaseGate(self, params: PhaseGate, 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 IGate(self, params: IGate, 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 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 Exponentiation(self, params: Exponentiation, 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 SuzukiTrotter(self, params: SuzukiTrotter, 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 Modulo(self, params: Modulo, 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 RGate(self, params: RGate, 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 StatePropagator(self, params: StatePropagator, 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 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 GreaterThan(self, params: GreaterThan, 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 Arithmetic(self, params: Arithmetic, 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 PiecewiseLinearRotationAmplitudeLoading(self, params: PiecewiseLinearRotationAmplitudeLoading, 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 UCC(self, params: UCC, 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 SXGate(self, params: SXGate, 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 SXdgGate(self, params: SXdgGate, 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 RZGate(self, params: RZGate, 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 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 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 HypercubeEntangler(self, params: HypercubeEntangler, 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 XGate(self, params: XGate, 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 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 CustomOracle(self, params: CustomOracle, 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 LShift(self, params: LShift, 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 HVA(self, params: HVA, 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 SwapGate(self, params: SwapGate, 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 StatePreparation(self, params: StatePreparation, 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 RYGate(self, params: RYGate, 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 Adder(self, params: Adder, 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 StatePropagator(self, params: StatePropagator, 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 WeightedAdder(self, params: WeightedAdder, 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 BellStatePreparation(self, params: BellStatePreparation, 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 HardwareEfficientAnsatz(self, params: HardwareEfficientAnsatz, 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 CyclicShift(self, params: CyclicShift, 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 iSwapGate(self, params: iSwapGate, 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 ArithmeticOracle(self, params: ArithmeticOracle, 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 BitwiseOr(self, params: BitwiseOr, 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 QDrift(self, params: QDrift, 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 RXGate(self, params: RXGate, 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 HadamardTransform(self, params: HadamardTransform, 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 CommutingPauliExponentiation(self, params: CommutingPauliExponentiation, 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 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 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/{interface/model/clients/qmod/qmod_builtins.py → qmod/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
@@ -342,8 +240,8 @@ def unitary(
 
 @ExternalQFunc
 def add(
-    left: Input[QArray[QBit]],
-    right: Input[QArray[QBit]],
+    left: QArray[QBit],
+    right: QArray[QBit],
     result: Output[QArray[QBit, Literal["Max(len(left), len(right)) + 1"]]],
 ) -> None:
     pass
@@ -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'))"]],
@@ -425,38 +323,42 @@ def exponentiation_with_depth_constraint(
 
 @ExternalQFunc
 def qft_step(
-    num_qbits: QParam[int],
-    qbv: QArray[QBit, Literal["num_qbits"]],
+    target: QArray[QBit],
 ) -> None:
     pass
 
 
 @ExternalQFunc
 def qft(
-    num_qbits: QParam[int],
-    qbv: QArray[QBit, Literal["num_qbits"]],
+    target: QArray[QBit],
+) -> None:
+    pass
+
+
+@ExternalQFunc
+def standard_qpe(
+    precision: QParam[int],
+    unitary: QCallable,
+    phase: QArray[QBit, Literal["precision"]],
 ) -> None:
     pass
 
 
 @ExternalQFunc
 def qpe(
-    reg_size: QParam[int],
-    qpe_reg_size: QParam[int],
-    qfunc: QCallable[QArray[QBit, Literal["reg_size"]]],
-    x: QArray[QBit, Literal["reg_size"]],
-    q: QArray[QBit, Literal["qpe_reg_size"]],
+    precision: QParam[int],
+    unitary: QCallable,
+    phase: Output[QArray[QBit, Literal["precision"]]],
 ) -> None:
     pass
 
 
 @ExternalQFunc
 def single_pauli(
-    reg_size: QParam[int],
     slope: QParam[float],
     offset: QParam[float],
     q1_qfunc: QCallable[QParam[float], QBit],
-    x: QArray[QBit, Literal["reg_size"]],
+    x: QArray[QBit],
     q: QBit,
 ) -> None:
     pass
@@ -464,13 +366,11 @@ def single_pauli(
 
 @ExternalQFunc
 def linear_pauli_rotations(
-    reg_size: QParam[int],
-    num_state_qubits: QParam[int],
     bases: QParam[List[int]],
     slopes: QParam[List[float]],
     offsets: QParam[List[float]],
-    x: QArray[QBit, Literal["reg_size"]],
-    q: QArray[QBit, Literal["num_state_qubits"]],
+    x: QArray[QBit],
+    q: QArray[QBit],
 ) -> None:
     pass
 
@@ -515,17 +415,15 @@ def grover_operator(
 
 @ExternalQFunc
 def hadamard_transform(
-    num_qubits: QParam[int],
-    q: QArray[QBit, Literal["num_qubits"]],
+    target: QArray[QBit],
 ) -> None:
     pass
 
 
 @ExternalQFunc
 def apply_to_all(
-    num_qubits: QParam[int],
     gate_operand: QCallable[QBit],
-    q: QArray[QBit, Literal["num_qubits"]],
+    target: QArray[QBit],
 ) -> None:
     pass
 
@@ -550,40 +448,36 @@ def prepare_int(
 
 @ExternalQFunc
 def qaoa_mixer_layer(
-    num_qubits: QParam[int],
     b: QParam[float],
-    target: QArray[QBit, Literal["num_qubits"]],
+    target: QArray[QBit],
 ) -> None:
     pass
 
 
 @ExternalQFunc
 def qaoa_cost_layer(
-    num_qubits: QParam[int],
     g: QParam[float],
-    hamiltonian: QParam[List["PauliTerm"]],
+    hamiltonian: QParam[List[PauliTerm]],
     is_st: QParam[bool],
-    target: QArray[QBit, Literal["num_qubits"]],
+    target: QArray[QBit],
 ) -> None:
     pass
 
 
 @ExternalQFunc
 def qaoa_layer(
-    num_qubits: QParam[int],
     g: QParam[float],
     b: QParam[float],
-    hamiltonian: QParam[List["PauliTerm"]],
+    hamiltonian: QParam[List[PauliTerm]],
     is_st: QParam[bool],
-    target: QArray[QBit, Literal["num_qubits"]],
+    target: QArray[QBit],
 ) -> None:
     pass
 
 
 @ExternalQFunc
 def qaoa_init(
-    num_qubits: QParam[int],
-    target: QArray[QBit, Literal["num_qubits"]],
+    target: QArray[QBit],
 ) -> None:
     pass
 
@@ -592,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:
@@ -690,7 +584,7 @@ def power(
 
 @ExternalQFunc
 def molecule_ucc(
-    molecule_problem: QParam["MoleculeProblem"],
+    molecule_problem: QParam[MoleculeProblem],
     excitations: QParam[List[int]],
     qbv: QArray[
         QBit,
@@ -704,7 +598,7 @@ def molecule_ucc(
 
 @ExternalQFunc
 def molecule_hva(
-    molecule_problem: QParam["MoleculeProblem"],
+    molecule_problem: QParam[MoleculeProblem],
     reps: QParam[int],
     qbv: QArray[
         QBit,
@@ -718,7 +612,7 @@ def molecule_hva(
 
 @ExternalQFunc
 def molecule_hartree_fock(
-    molecule_problem: QParam["MoleculeProblem"],
+    molecule_problem: QParam[MoleculeProblem],
     qbv: QArray[
         QBit,
         Literal[
@@ -731,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,
@@ -745,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,
@@ -759,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[
@@ -772,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:
@@ -782,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[
@@ -797,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
@@ -812,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",
@@ -866,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",
+]