Block Encoding

BlockEncoding

Describes a block encoding of a matrix A. A unitary U is an (alpha, block_size, epsilon)-block-encoding of A if: A = alpha * (<0|^block_size (x) I) U (|0>^block_size (x) I) Methods:

Name	Description
from_unitary
from_dense_diagonals	Block encoding of a matrix given by dense diagonals, via amplitude loading + LCU.
from_constant_diags	Block encoding of a matrix given by constant diagonals, via LCU.
from_sparse_pauli_op	Block encoding of a Hamiltonian, given as a sparse Pauli operator, via LCU.
from_matrix	Block encoding of an arbitrary matrix via Pauli decomposition and LCU.
from_sparse_oracles	Block encoding of an s-sparse matrix via sparsity + amplitude oracles.
weighted_sum	Block encoding of sum_j coefficients[j] * A_j via a single LCU.
product	Block encoding of a product with logarithmic flag overhead.
tensor_product	Block encoding of A1 (x) A2 of two block encodings acting on disjoint data subsystems.
inverse	Block encoding of A^ via QSVT polynomial inversion.
qubitize	Qubitization walk operator W = R * U (Low-Chuang); powers of W give Chebyshev polynomials of the encoded matrix via Qmod’s `power`.
bound_call
to_matrix	Reconstruct the encoded matrix A, up to a global phase, via statevector simulation.

Attributes:

Name	Type	Description
`unitary`	`Callable[..., None]`
`block_size`	`int`
`alpha`	`float`
`epsilon`	`float`
`data_size`	`int`	Number of qubits the data register `A` acts on.
`hermitian_be`	`bool`	Whether the unitary `U` itself (not the encoded matrix `A`) is Hermitian. Needed e.g. for qubitization’s walk operator, which requires a Hermitian `U` to be a product of two reflections.

from_unitary

from_unitary(
cls: ,
unitary: QCallable,
block_size: int,
alpha: float,
data_size: int,
hermitian_be: bool = False
) -> BlockEncoding

Parameters:

Name	Type	Default
`cls`	“	required
`unitary`	`QCallable`	required
`block_size`	`int`	required
`alpha`	`float`	required
`data_size`	`int`	required
`hermitian_be`	`bool`	False

from_dense_diagonals

from_dense_diagonals(
cls: ,
diagonals: Sequence[tuple[Sequence[float], int]],
hermitian_be: bool | None = None
) -> BlockEncoding

Block encoding of a matrix given by dense diagonals, via amplitude loading + LCU. Parameters:

Name	Type	Default
`cls`	“	required
`diagonals`	`Sequence[tuple[Sequence[float], int]]`	required
`hermitian_be`	`bool \| None`	None

from_constant_diags

from_constant_diags(
cls: ,
diagonals: Sequence[tuple[float, int]],
cyclic: bool = False,
size: int,
hermitian_be: bool | None = None
) -> BlockEncoding

Block encoding of a matrix given by constant diagonals, via LCU. Parameters:

Name	Type	Default
`cls`	“	required
`diagonals`	`Sequence[tuple[float, int]]`	required
`cyclic`	`bool`	False
`size`	`int`	required
`hermitian_be`	`bool \| None`	None

from_sparse_pauli_op

from_sparse_pauli_op(
cls: ,
pauli_op: SparsePauliOp,
graycode: bool = False,
hermitian_be: bool | None = None
) -> BlockEncoding

Block encoding of a Hamiltonian, given as a sparse Pauli operator, via LCU. Parameters:

Name	Type	Default
`cls`	“	required
`pauli_op`	`SparsePauliOp`	required
`graycode`	`bool`	False
`hermitian_be`	`bool \| None`	None

from_matrix

from_matrix(
cls: ,
mat: np.ndarray,
hermitian_be: bool | None = None
) -> BlockEncoding

Block encoding of an arbitrary matrix via Pauli decomposition and LCU. Parameters:

Name	Type	Default
`cls`	“	required
`mat`	`np.ndarray`	required
`hermitian_be`	`bool \| None`	None

from_sparse_oracles

from_sparse_oracles(
cls: ,
oracle_amplitude: QCallable,
oracle_column: QCallable,
sparsity: int,
data_size: int,
hermitian_be: bool = False
) -> BlockEncoding

Block encoding of an s-sparse matrix via sparsity + amplitude oracles. Parameters:

Name	Type	Description	Default
`cls`	“		required
`oracle_amplitude`	`QCallable`	Amplitude oracle `oracle_amplitude(amp, ell, data)`.	required
`oracle_column`	`QCallable`	Sparsity oracle `oracle_column(ell, data)`.	required
`sparsity`	`int`	Number of nonzeros per row/column; must be a power of 2.	required
`data_size`	`int`	Number of qubits the data register acts on; not derivable from the oracles, which may be written generically for any size.	required
`hermitian_be`	`bool`	whether the block-encoding unitary itself is Hermitian; not derivable from arbitrary caller-supplied oracles, so this is trusted as given (default `False`).	False

weighted_sum

weighted_sum(
cls: ,
coefficients: Sequence[complex],
bes: Sequence[BlockEncoding],
hermitian_be: bool | None = None
) -> BlockEncoding

Block encoding of sum_j coefficients[j] * A_j via a single LCU. A nonzero phase on a coefficient is realized by lcu’s phase table (prepare_select/assign_phase_table) as a genuine relative phase between the LCU branches. Scaling factor: sum_j |coefficients[j] * alpha_j|. Block size: max_j(block_size_j) + max(ceil(log2(len(bes))), 1) (LCU select register). Error: 0 (exact encoding, given exact inputs). Parameters:

Name	Type	Description	Default
`cls`	“		required
`coefficients`	`Sequence[complex]`	Weight c_j applied to each block encoding’s matrix A_j.	required
`bes`	Sequence[BlockEncoding]	Block encodings to combine, one per coefficient.	required
`hermitian_be`	`bool \| None`	`None` (default) auto-infers it; pass `True`/`False` to override.	None

product

product(
cls: ,
bes: list[BlockEncoding],
hermitian_be: bool | None = None
) -> BlockEncoding

Block encoding of a product with logarithmic flag overhead. Parameters:

Name	Type	Default
`cls`	“	required
`bes`	list[BlockEncoding]	required
`hermitian_be`	`bool \| None`	None

tensor_product

tensor_product(
cls: ,
be1: BlockEncoding,
be2: BlockEncoding,
hermitian_be: bool | None = None
) -> BlockEncoding

Block encoding of A1 (x) A2 of two block encodings acting on disjoint data subsystems. See _block_encoding_tensor_product for the qubit ordering convention. Parameters:

Name	Type	Default
`cls`	“	required
`be1`	BlockEncoding	required
`be2`	BlockEncoding	required
`hermitian_be`	`bool \| None`	None

inverse

inverse(
self: ,
kappa: float,
degree: int | None = None,
eps: float | None = None,
hermitian_be: bool | None = None
) -> BlockEncoding

Block encoding of A^ via QSVT polynomial inversion. Parameters:

Name	Type	Default
`self`	“	required
`kappa`	`float`	required
`degree`	`int \| None`	None
`eps`	`float \| None`	None
`hermitian_be`	`bool \| None`	None

qubitize

qubitize(
self:
) -> BlockEncoding

Qubitization walk operator W = R * U (Low-Chuang); powers of W give Chebyshev polynomials of the encoded matrix via Qmod’s power. Parameters:

Name	Type	Description	Default
`self`	“		required

bound_call

bound_call(
self: ,
data: Any,
block: Any
) -> Callable[[], None]

Parameters:

Name	Type	Default
`self`	“	required
`data`	`Any`	required
`block`	`Any`	required

to_matrix

to_matrix(
self:
) -> np.ndarray

Reconstruct the encoded matrix A, up to a global phase, via statevector simulation. Note: The result is exact up to an overall global phase. Parameters:

Name	Type	Description	Default
`self`	“		required

Providers

Applications

Qmod

BlockEncoding

from_unitary

from_dense_diagonals

from_constant_diags

from_sparse_pauli_op

from_matrix

from_sparse_oracles

weighted_sum

product

tensor_product

inverse

qubitize

bound_call

to_matrix

​BlockEncoding

​from_unitary

​from_dense_diagonals

​from_constant_diags

​from_sparse_pauli_op

​from_matrix

​from_sparse_oracles

​weighted_sum

​product

​tensor_product

​inverse

​qubitize

​bound_call

​to_matrix

BlockEncoding

from_unitary

from_dense_diagonals

from_constant_diags

from_sparse_pauli_op

from_matrix

from_sparse_oracles

weighted_sum

product

tensor_product

inverse

qubitize

bound_call

to_matrix