quri_parts.qsub.op module

class Ident(ns, local_name, params)

Bases: NamedTuple

Parameters:

  • ns (NameSpace)

  • local_name (str)

  • params (tuple[qsub.op.Param, ...])

ns: NameSpace

Alias for field number 0

local_name: str

Alias for field number 1

params: tuple[qsub.op.Param, ...]

Alias for field number 2

property base: qsub.op.BaseIdent
to_str(full=True, param_truncate=0)
Parameters:

  • full (bool)

  • param_truncate (int)

Return type:

str

class AbstractOp(*args, **kwargs)

Bases: Protocol

property base_id: qsub.op.BaseIdent
class Op(id: 'Ident', qubit_count: 'int', qregs: 'Sequence[QRegSpec]', reg_count: 'int' = 0, unitary: 'bool' = True, self_inverse: 'bool' = False)

Bases: object

Parameters:

  • id (Ident)

  • qubit_count (int)

  • qregs (Sequence[QRegSpec])

  • reg_count (int)

  • unitary (bool)

  • self_inverse (bool)

id: Ident
qubit_count: int
qregs: Sequence[QRegSpec]
reg_count: int = 0
unitary: bool = True
self_inverse: bool = False
static from_qregs(id, qregs, reg_count=0, unitary=True, self_inverse=False)
Parameters:

  • id (Ident)

  • qregs (Sequence[QRegSpec])

  • reg_count (int)

  • unitary (bool)

  • self_inverse (bool)

Return type:

Op

static from_qubit_count(id, qubit_count, reg_count=0, unitary=True, self_inverse=False)
Parameters:

  • id (Ident)

  • qubit_count (int)

  • reg_count (int)

  • unitary (bool)

  • self_inverse (bool)

Return type:

Op

property base_id: qsub.op.BaseIdent
class OpFactory(*args, **kwargs)

Bases: Protocol[Params]

property base_id: qsub.op.BaseIdent
class OpDef

Bases: object

ns: NameSpace = ('__default__', None)
name: str
params: tuple[qsub.op.Param, ...] = ()
qubit_count: int
reg_count: int = 0
unitary: bool = True
self_inverse: bool = False
qregs: Sequence[QRegSpec] | None = None
classmethod get_qregs()
Return type:

Sequence[QRegSpec]

op(op_def)
Parameters:

op_def (type[OpDef])

Return type:

Op

class UnitaryDef

Bases: OpDef

unitary: bool = True
class NonUnitaryDef

Bases: OpDef

unitary: bool = False
class ParametricMixin

Bases: Generic[Params]

qubit_count: int | None
reg_count: int | None = 0
self_inverse: bool = False
qregs: Sequence[QRegSpec] | None = None
qubit_count_fn(*params, **_)
Parameters:

  • params (Params.args)

  • _ (Params.kwargs)

Return type:

int

reg_count_fn(*params, **_)
Parameters:

  • params (Params.args)

  • _ (Params.kwargs)

Return type:

int

qregs_fn(*params, **_)
Parameters:

  • params (Params.args)

  • _ (Params.kwargs)

Return type:

Sequence[QRegSpec]

self_inverse_fn(*params, **_)
Parameters:

  • params (Params.args)

  • _ (Params.kwargs)

Return type:

bool

exception ParameterValidationError

Bases: Exception

class ParamOpDef

Bases: ParametricMixin[Params]

ns: NameSpace = ('__default__', None)
name: str
unitary: bool = True
validate_params(*params, **_)
Parameters:

  • params (Params.args)

  • _ (Params.kwargs)

Return type:

None

class ParamUnitaryDef

Bases: ParamOpDef[Params]

unitary: bool = True
class ParamNonUnitaryDef

Bases: ParamOpDef[Params]

unitary: bool = False
param_op(op_def)
Parameters:

op_def (type[ParamOpDef[(algo.optimizer.interface.Params,)]])

Return type:

OpFactory[(algo.optimizer.interface.Params,)]

class SimpleParamOp(base_id, qubit_count, reg_count=0, unitary=True, self_inverse=False, qregs=None)

Bases: ParametricMixin[Params]

Provides an easy way to create a parametric op (OpFactory) with fixed (i.e. not dependent on parameters) qubit_count and reg_count.

Parameters:

  • base_id (qsub.op.BaseIdent)

  • qubit_count (int | None)

  • reg_count (int | None)

  • unitary (bool)

  • self_inverse (bool)

  • qregs (Sequence[QRegSpec] | None)

base_id: BaseIdent
qubit_count: int | None
reg_count: int | None = 0
unitary: bool = True
self_inverse: bool = False
qregs: Sequence[QRegSpec] | None = None