mqt\.core\.mlir\._generate_benchmark$:

mqt\.core\.mlir\.(?:QC|QCO)Program\.bind_parameters$:
    \from collections.abc import Mapping, Sequence
    \from typing import Any, Self, SupportsFloat
    \import numpy
    def bind_parameters(
        self,
        values: Mapping[
            str,
            SupportsFloat
            | Sequence[SupportsFloat]
            | numpy.ndarray[tuple[int], numpy.dtype[numpy.floating[Any] | numpy.integer[Any]]],
        ],
        *,
        copy: bool = False,
    ) -> Self:
        \doc

mqt\.core\.mlir\.JeffProgram\.from_segments$:
    \from collections.abc import Sequence
    @staticmethod
    def from_segments(
        segments: Sequence[bytes | bytearray | memoryview | np.ndarray],
    ) -> JeffProgram:
        \doc

mqt\.core\.mlir\.JeffProgram\.to_segment_views$:
    def to_segment_views(self) -> list[memoryview]:
        \doc

mqt\.core\.qdmi\.(?:Job|Device|Device\.Site)\.query_custom_property$:
    \from typing import overload
    @overload
    def query_custom_property(self, custom_property: CustomProperty, value_type: type[str]) -> str | None: ...
    @overload
    def query_custom_property(self, custom_property: CustomProperty, value_type: type[bool]) -> bool | None: ...
    @overload
    def query_custom_property(self, custom_property: CustomProperty, value_type: type[int]) -> int | None: ...
    @overload
    def query_custom_property(self, custom_property: CustomProperty, value_type: type[float]) -> float | None: ...
    @overload
    def query_custom_property(self, custom_property: CustomProperty, value_type: type[bytes]) -> bytes | None: ...
    @overload
    def query_custom_property(
        self, custom_property: CustomProperty, value_type: type[str | bool | int | float | bytes]
    ) -> str | bool | int | float | bytes | None:
        \doc

mqt\.core\.qdmi\.Job\.get_custom_result$:
    \from typing import overload
    @overload
    def get_custom_result(self, custom_property: CustomProperty, value_type: type[str]) -> str | None: ...
    @overload
    def get_custom_result(self, custom_property: CustomProperty, value_type: type[bool]) -> bool | None: ...
    @overload
    def get_custom_result(self, custom_property: CustomProperty, value_type: type[int]) -> int | None: ...
    @overload
    def get_custom_result(self, custom_property: CustomProperty, value_type: type[float]) -> float | None: ...
    @overload
    def get_custom_result(self, custom_property: CustomProperty, value_type: type[bytes]) -> bytes | None: ...
    @overload
    def get_custom_result(
        self, custom_property: CustomProperty, value_type: type[str | bool | int | float | bytes]
    ) -> str | bool | int | float | bytes | None:
        \doc

mqt\.core\.qdmi\.Device\.Operation\.query_custom_property$:
    \from typing import overload
    @overload
    def query_custom_property(
        self,
        custom_property: CustomProperty,
        value_type: type[str],
        sites: Sequence[Device.Site] = ...,
        params: Sequence[float] = ...,
    ) -> str | None: ...
    @overload
    def query_custom_property(
        self,
        custom_property: CustomProperty,
        value_type: type[bool],
        sites: Sequence[Device.Site] = ...,
        params: Sequence[float] = ...,
    ) -> bool | None: ...
    @overload
    def query_custom_property(
        self,
        custom_property: CustomProperty,
        value_type: type[int],
        sites: Sequence[Device.Site] = ...,
        params: Sequence[float] = ...,
    ) -> int | None: ...
    @overload
    def query_custom_property(
        self,
        custom_property: CustomProperty,
        value_type: type[float],
        sites: Sequence[Device.Site] = ...,
        params: Sequence[float] = ...,
    ) -> float | None: ...
    @overload
    def query_custom_property(
        self,
        custom_property: CustomProperty,
        value_type: type[bytes],
        sites: Sequence[Device.Site] = ...,
        params: Sequence[float] = ...,
    ) -> bytes | None: ...
    @overload
    def query_custom_property(
        self,
        custom_property: CustomProperty,
        value_type: type[str | bool | int | float | bytes],
        sites: Sequence[Device.Site] = ...,
        params: Sequence[float] = ...,
    ) -> str | bool | int | float | bytes | None:
        \doc

mqt\.core\.mlir\.CompilerTarget\.__init__$:
    \from collections.abc import Sequence
    \from typing import overload
    @overload
    def __init__(
        self,
        num_sites: int,
        *,
        connectivity: CompilerTarget.Connectivity,
        native_operations: CompilerTarget.NativeOperations,
        duration_unit: CompilerTarget.DurationUnit | None = None,
    ) -> None: ...
    @overload
    def __init__(
        self,
        name: str,
        num_sites: int,
        *,
        connectivity: CompilerTarget.Connectivity,
        native_operations: CompilerTarget.NativeOperations,
        duration_unit: CompilerTarget.DurationUnit | None = None,
    ) -> None: ...
    @overload
    def __init__(
        self,
        sites: Sequence[CompilerTarget.Site],
        *,
        connectivity: CompilerTarget.Connectivity,
        native_operations: CompilerTarget.NativeOperations,
        duration_unit: CompilerTarget.DurationUnit | None = None,
    ) -> None: ...
    @overload
    def __init__(
        self,
        name: str,
        sites: Sequence[CompilerTarget.Site],
        *,
        connectivity: CompilerTarget.Connectivity,
        native_operations: CompilerTarget.NativeOperations,
        duration_unit: CompilerTarget.DurationUnit | None = None,
    ) -> None: ...

mqt\.core\.mlir\.CompilerTarget\.OperationCapability\.__init__$:
    \from collections.abc import Sequence
    def __init__(
        self,
        name: str,
        arity: int | CompilerTarget.OperationArity,
        num_parameters: int,
        site_tuples: Sequence[CompilerTarget.SiteTuple | Sequence[int]] | None = None,
        duration: int | None = None,
        fidelity: float | None = None,
        *,
        fixed_parameters: Sequence[float | None] = (),
        canonical_name: str | None = None,
        parameter_bounds: Sequence[tuple[float, float] | None] = (),
    ) -> None:
        \doc

mqt\.core\.mlir\.CompilerTarget\.from_device$:
    \from mqt.core.qdmi import Device
    @staticmethod
    def from_device(device: Device) -> CompilerTarget:
        \doc

mqt\.core\.mlir\.CompilerTarget\.from_device_id$:
    @staticmethod
    def from_device_id(device_id: str, *, driver_path: str | os.PathLike[str] | None = None, token: str | None = None, auth_file: str | os.PathLike[str] | None = None, auth_url: str | None = None, username: str | None = None, password: str | None = None, project_id: str | None = None, custom1: str | None = None, custom2: str | None = None, custom3: str | None = None, custom4: str | None = None, custom5: str | None = None) -> CompilerTarget:
        \doc

mqt\.core\.mlir\.__prefix__$:
    \from typing import TypeAlias, TypedDict, Unpack
    \from typing_extensions import TypeVar
    _CompilerInput: TypeAlias = str | os.PathLike[str] | qiskit.circuit.QuantumCircuit | QCProgram | QCOProgram | JeffProgram | OpenQASMProgram
    _CompilerTarget: TypeAlias = CompilerTarget | TargetEnvironment | qiskit.providers.BackendV2 | qiskit.transpiler.Target | mqt.core.qdmi.Device | str
    _CompilerOutput: TypeAlias = qiskit.circuit.QuantumCircuit | QCProgram | QCOProgram | JeffProgram | OpenQASMProgram | QIRProgram | IQMJSONProgram
    _ProgramT = TypeVar("_ProgramT", qiskit.circuit.QuantumCircuit, QCProgram, QCOProgram, JeffProgram, OpenQASMProgram)
    _CompilerInputT = TypeVar("_CompilerInputT", str, os.PathLike[str], qiskit.circuit.QuantumCircuit, QCProgram, QCOProgram, JeffProgram, OpenQASMProgram)
    _SourceT = TypeVar("_SourceT", str, os.PathLike[str])
    _TargetResult: TypeAlias = _CompilerOutput | CompiledProgram
    _TargetResultT_co = TypeVar("_TargetResultT_co", bound=_TargetResult, default=_TargetResult, covariant=True)

    class _CompileOptions(TypedDict, total=False, closed=True):
        copy: bool
        qco_pipeline: str
        options: CompilationOptions | None
        ignore_input_layout: bool
        include_output_layout: bool

mqt\.core\.mlir\.PayloadSpecification\.__init__$:
    def __new__(
        cls,
        payload_format: PayloadFormat,
        capabilities: Sequence[ProgramCapability] = (),
        optional_capabilities_known: bool = False,
    ) -> PayloadSpecification[qiskit.circuit.QuantumCircuit | CompiledProgram]: ...

mqt\.core\.mlir\.PayloadSpecification\.from_program_format$:
    @staticmethod
    def from_program_format(program_format: mqt.core.qdmi.ProgramFormat) -> PayloadSpecification[CompiledProgram]:
        \doc

mqt\.core\.mlir\.TargetEnvironment\.__init__$:
    \from typing import overload
    @overload
    def __new__(cls, target: CompilerTarget, payload_specification: PayloadSpecification[qiskit.circuit.QuantumCircuit]) -> TargetEnvironment[qiskit.circuit.QuantumCircuit]: ...
    @overload
    def __new__(cls, target: CompilerTarget, payload_specification: PayloadSpecification) -> TargetEnvironment[_TargetResult]: ...

mqt\.core\.mlir\.TargetEnvironment\.payload_specification$:
    @property
    def payload_specification(self) -> PayloadSpecification[_TargetResultT_co]:
        \doc

mqt\.core\.mlir\.CompiledProgram\.payload_specification$:
    @property
    def payload_specification(self) -> PayloadSpecification[CompiledProgram]:
        \doc

mqt\.core\.mlir\._pennylane\.__prefix__$:
    \from mqt.core.mlir._qdmi import Context as _ExecutionContext

mqt\.core\.mlir\._qdmi\.Context\.environment$:
    @property
    def environment(self) -> mqt.core.mlir.TargetEnvironment[mqt.core.mlir.CompiledProgram]:
        \doc

mqt\.core\.mlir\.compile_program$:
    \import mqt.core.plugins.qiskit.backend
    \from typing import overload, Literal
    \from collections.abc import Sequence
    @overload
    def compile_program(
        program: _CompilerInput,
        *,
        target: _CompilerTarget | None = None,
        output: Literal[OutputFormat.QC],
        **kwargs: Unpack[_CompileOptions],
    ) -> QCProgram: ...
    @overload
    def compile_program(
        program: _CompilerInput,
        *,
        target: _CompilerTarget | None = None,
        output: Literal[OutputFormat.QCO_OPTIMIZED],
        **kwargs: Unpack[_CompileOptions],
    ) -> QCOProgram: ...
    @overload
    def compile_program(
        program: _CompilerInput,
        *,
        target: None = None,
        output: Literal[OutputFormat.QC_IMPORT],
        **kwargs: Unpack[_CompileOptions],
    ) -> QCProgram: ...
    @overload
    def compile_program(
        program: _CompilerInput,
        *,
        target: None = None,
        output: Literal[OutputFormat.QCO],
        **kwargs: Unpack[_CompileOptions],
    ) -> QCOProgram: ...
    @overload
    def compile_program(
        program: _CompilerInput,
        *,
        target: _CompilerTarget | None = None,
        output: Literal[OutputFormat.OPENQASM2, OutputFormat.OPENQASM3],
        **kwargs: Unpack[_CompileOptions],
    ) -> OpenQASMProgram: ...
    @overload
    def compile_program(
        program: _CompilerInput,
        *,
        target: _CompilerTarget,
        output: Literal[OutputFormat.IQM_JSON],
        **kwargs: Unpack[_CompileOptions],
    ) -> IQMJSONProgram: ...
    @overload
    def compile_program(
        program: _CompilerInput,
        *,
        target: _CompilerTarget | None = None,
        output: Literal[OutputFormat.JEFF],
        **kwargs: Unpack[_CompileOptions],
    ) -> JeffProgram: ...
    @overload
    def compile_program(
        program: _CompilerInput,
        *,
        target: _CompilerTarget | None = None,
        output: Literal[OutputFormat.QIR_BASE, OutputFormat.QIR_ADAPTIVE],
        **kwargs: Unpack[_CompileOptions],
    ) -> QIRProgram: ...
    @overload
    def compile_program(
        program: _CompilerInput,
        *,
        target: _CompilerTarget | None = None,
        output: Literal[OutputFormat.QPY],
        **kwargs: Unpack[_CompileOptions],
    ) -> bytes: ...
    @overload
    def compile_program(
        program: _CompilerInput,
        *,
        target: _CompilerTarget | None = None,
        output: Literal[OutputFormat.QISKIT],
        **kwargs: Unpack[_CompileOptions],
    ) -> qiskit.circuit.QuantumCircuit: ...
    @overload
    def compile_program(
        program: _CompilerInput,
        *,
        target: mqt.core.plugins.qiskit.backend.QDMIBackend,
        output: None = None,
        **kwargs: Unpack[_CompileOptions],
    ) -> CompiledProgram: ...
    @overload
    def compile_program(
        program: _CompilerInput,
        *,
        target: qiskit.transpiler.Target,
        output: None = None,
        **kwargs: Unpack[_CompileOptions],
    ) -> qiskit.circuit.QuantumCircuit: ...
    @overload
    def compile_program(
        program: _CompilerInput,
        *,
        target: qiskit.providers.BackendV2 | qiskit.transpiler.Target,
        output: None = None,
        **kwargs: Unpack[_CompileOptions],
    ) -> qiskit.circuit.QuantumCircuit | CompiledProgram: ...
    @overload
    def compile_program(
        program: _CompilerInput,
        *,
        target: TargetEnvironment[_TargetResultT_co],
        output: None = None,
        **kwargs: Unpack[_CompileOptions],
    ) -> _TargetResultT_co: ...
    @overload
    def compile_program(
        program: _CompilerInput,
        *,
        target: mqt.core.qdmi.Device | str,
        output: None = None,
        **kwargs: Unpack[_CompileOptions],
    ) -> CompiledProgram: ...
    @overload
    def compile_program(
        program: _ProgramT,
        *,
        target: CompilerTarget | None = None,
        output: None = None,
        **kwargs: Unpack[_CompileOptions],
    ) -> _ProgramT: ...
    @overload
    def compile_program(
        program: str | os.PathLike[str],
        *,
        target: CompilerTarget | None = None,
        output: None = None,
        **kwargs: Unpack[_CompileOptions],
    ) -> QCProgram | JeffProgram | OpenQASMProgram: ...
    @overload
    def compile_program(
        program: _CompilerInput,
        *,
        target: _CompilerTarget | None = None,
        output: OutputFormat,
        **kwargs: Unpack[_CompileOptions],
    ) -> _CompilerOutput: ...

    @overload
    def compile_program(
        program: Sequence[_CompilerInputT],
        *,
        target: _CompilerTarget | None = None,
        output: Literal[OutputFormat.QC],
        **kwargs: Unpack[_CompileOptions],
    ) -> list[QCProgram]: ...
    @overload
    def compile_program(
        program: Sequence[_CompilerInputT],
        *,
        target: _CompilerTarget | None = None,
        output: Literal[OutputFormat.QCO_OPTIMIZED],
        **kwargs: Unpack[_CompileOptions],
    ) -> list[QCOProgram]: ...
    @overload
    def compile_program(
        program: Sequence[_CompilerInputT],
        *,
        target: None = None,
        output: Literal[OutputFormat.QC_IMPORT],
        **kwargs: Unpack[_CompileOptions],
    ) -> list[QCProgram]: ...
    @overload
    def compile_program(
        program: Sequence[_CompilerInputT],
        *,
        target: None = None,
        output: Literal[OutputFormat.QCO],
        **kwargs: Unpack[_CompileOptions],
    ) -> list[QCOProgram]: ...
    @overload
    def compile_program(
        program: Sequence[_CompilerInputT],
        *,
        target: _CompilerTarget | None = None,
        output: Literal[OutputFormat.OPENQASM2, OutputFormat.OPENQASM3],
        **kwargs: Unpack[_CompileOptions],
    ) -> list[OpenQASMProgram]: ...
    @overload
    def compile_program(
        program: Sequence[_CompilerInputT],
        *,
        target: _CompilerTarget,
        output: Literal[OutputFormat.IQM_JSON],
        **kwargs: Unpack[_CompileOptions],
    ) -> list[IQMJSONProgram]: ...
    @overload
    def compile_program(
        program: Sequence[_CompilerInputT],
        *,
        target: _CompilerTarget | None = None,
        output: Literal[OutputFormat.JEFF],
        **kwargs: Unpack[_CompileOptions],
    ) -> list[JeffProgram]: ...
    @overload
    def compile_program(
        program: Sequence[_CompilerInputT],
        *,
        target: _CompilerTarget | None = None,
        output: Literal[OutputFormat.QIR_BASE, OutputFormat.QIR_ADAPTIVE],
        **kwargs: Unpack[_CompileOptions],
    ) -> list[QIRProgram]: ...
    @overload
    def compile_program(
        program: Sequence[_CompilerInputT],
        *,
        target: _CompilerTarget | None = None,
        output: Literal[OutputFormat.QPY],
        **kwargs: Unpack[_CompileOptions],
    ) -> list[bytes]: ...
    @overload
    def compile_program(
        program: Sequence[_CompilerInputT],
        *,
        target: _CompilerTarget | None = None,
        output: Literal[OutputFormat.QISKIT],
        **kwargs: Unpack[_CompileOptions],
    ) -> list[qiskit.circuit.QuantumCircuit]: ...
    @overload
    def compile_program(
        program: Sequence[_CompilerInputT],
        *,
        target: mqt.core.plugins.qiskit.backend.QDMIBackend,
        output: None = None,
        **kwargs: Unpack[_CompileOptions],
    ) -> list[CompiledProgram]: ...
    @overload
    def compile_program(
        program: Sequence[_CompilerInputT],
        *,
        target: qiskit.transpiler.Target,
        output: None = None,
        **kwargs: Unpack[_CompileOptions],
    ) -> list[qiskit.circuit.QuantumCircuit]: ...
    @overload
    def compile_program(
        program: Sequence[_CompilerInputT],
        *,
        target: qiskit.providers.BackendV2 | qiskit.transpiler.Target,
        output: None = None,
        **kwargs: Unpack[_CompileOptions],
    ) -> list[qiskit.circuit.QuantumCircuit] | list[CompiledProgram]: ...
    @overload
    def compile_program(
        program: Sequence[_CompilerInputT],
        *,
        target: TargetEnvironment[_TargetResultT_co],
        output: None = None,
        **kwargs: Unpack[_CompileOptions],
    ) -> list[_TargetResultT_co]: ...
    @overload
    def compile_program(
        program: Sequence[_CompilerInputT],
        *,
        target: mqt.core.qdmi.Device | str,
        output: None = None,
        **kwargs: Unpack[_CompileOptions],
    ) -> list[CompiledProgram]: ...
    @overload
    def compile_program(
        program: Sequence[_ProgramT],
        *,
        target: CompilerTarget | None = None,
        output: None = None,
        **kwargs: Unpack[_CompileOptions],
    ) -> list[_ProgramT]: ...
    @overload
    def compile_program(
        program: Sequence[_SourceT],
        *,
        target: CompilerTarget | None = None,
        output: None = None,
        **kwargs: Unpack[_CompileOptions],
    ) -> list[QCProgram | JeffProgram | OpenQASMProgram]: ...
    @overload
    def compile_program(
        program: Sequence[_CompilerInputT],
        *,
        target: _CompilerTarget | None = None,
        output: OutputFormat,
        **kwargs: Unpack[_CompileOptions],
    ) -> list[_CompilerOutput]:
        \doc


mqt\.core\.mlir\.submit_program$:
    def submit_program(
        program: str | os.PathLike[str] | qiskit.circuit.QuantumCircuit | QCProgram | QCOProgram | JeffProgram | OpenQASMProgram | CompiledProgram,
        *,
        target: str | mqt.core.qdmi.Device,
        num_shots: int = 1024,
        program_format: mqt.core.qdmi.ProgramFormat | None = None,
        custom1: str | bool | float | bytes | None = None,
        custom2: str | bool | float | bytes | None = None,
        custom3: str | bool | float | bytes | None = None,
        custom4: str | bool | float | bytes | None = None,
        custom5: str | bool | float | bytes | None = None,
        options: CompilationOptions | None = None,
    ) -> mqt.core.qdmi.Job:
        \doc
