Block system

qadence offers a block-based system to construct quantum circuits in a flexible manner.

AbstractBlock(tag=None, __array_priority__=1000) dataclass

Bases: ABC

Base class for both primitive and composite blocks.

ATTRIBUTE	DESCRIPTION
name	A human-readable name attached to the block type. Notice, this is the same for all the class instances so it cannot be used for identifying different blocks TYPE: str
qubit_support	The qubit support of the block expressed as a tuple of integers TYPE: tuple[int, ...]
tag	A tag identifying a particular instance of the block which can be used for identification and pretty printing TYPE: str | None
eigenvalues	The eigenvalues of the matrix representing the block. This is used mainly for primitive blocks and it's needed for generalized parameter shift rule computations. Currently unused. TYPE: list[float] | None

is_identity property

Identity predicate for blocks.

n_qubits()

The number of qubits in the whole system.

A block acting on qubit N would has at least n_qubits >= N + 1.

Source code in qadence/blocks/abstract.py

@abstractproperty
def n_qubits(self) -> int:
    """The number of qubits in the whole system.

    A block acting on qubit N would has at least n_qubits >= N + 1.
    """
    pass

n_supports()

The number of qubits the block is acting on.

Source code in qadence/blocks/abstract.py

@abstractproperty
def n_supports(self) -> int:
    """The number of qubits the block is acting on."""
    pass

qubit_support()

The indices of the qubit(s) the block is acting on.

Qadence uses the ordering [0..,N-1] for qubits.

Source code in qadence/blocks/abstract.py

@abstractproperty
def qubit_support(self) -> Tuple[int, ...]:
    """The indices of the qubit(s) the block is acting on.

    Qadence uses the ordering [0..,N-1] for qubits.
    """
    pass

Primitive blocks

ControlBlock(control, target_block, noise=None)

Bases: PrimitiveBlock

The abstract ControlBlock.

Source code in qadence/blocks/primitive.py

def __init__(
    self,
    control: tuple[int, ...],
    target_block: PrimitiveBlock,
    noise: NoiseHandler | None = None,
) -> None:
    self.control = control
    self.blocks = (target_block,)
    self.target = target_block.qubit_support

    # using tuple expansion because some control operations could
    # have multiple targets, e.g. CSWAP
    super().__init__((*control, *self.target), noise=noise)  # target_block.qubit_support[0]))

ParametricBlock(qubit_support, noise=None) dataclass

Bases: PrimitiveBlock

Parameterized primitive blocks.

Source code in qadence/blocks/primitive.py

def __init__(
    self,
    qubit_support: tuple[int, ...],
    noise: NoiseHandler | None = None,
):
    self._qubit_support = qubit_support
    self._noise = noise

num_parameters() abstractmethod

The number of parameters required by the block.

This is a class property since the number of parameters is defined automatically before instantiating the operation. Also, this could correspond to a larger number of actual user-facing parameters since any parameter expression is allowed

Examples: - RX operation has 1 parameter - U operation has 3 parameters - HamEvo has 2 parameters (generator and time evolution)

Source code in qadence/blocks/primitive.py

@abstractmethod
def num_parameters(cls) -> int:
    """The number of parameters required by the block.

    This is a class property since the number of parameters is defined
    automatically before instantiating the operation. Also, this could
    correspond to a larger number of actual user-facing parameters
    since any parameter expression is allowed

    Examples:
    - RX operation has 1 parameter
    - U operation has 3 parameters
    - HamEvo has 2 parameters (generator and time evolution)
    """
    pass

ParametricControlBlock(control, target_block, noise=None)

Bases: ParametricBlock

The abstract parametrized ControlBlock.

Source code in qadence/blocks/primitive.py

def __init__(
    self,
    control: tuple[int, ...],
    target_block: ParametricBlock,
    noise: NoiseHandler | None = None,
) -> None:
    self.blocks = (target_block,)
    self.control = control
    self.parameters = target_block.parameters
    super().__init__((*control, *target_block.qubit_support), noise=noise)

PrimitiveBlock(qubit_support, noise=None)

Bases: AbstractBlock

Primitive blocks represent elementary unitary operations.

Examples are single/multi-qubit gates or Hamiltonian evolution. See qadence.operations for a full list of primitive blocks.

Source code in qadence/blocks/primitive.py

def __init__(
    self,
    qubit_support: tuple[int, ...],
    noise: NoiseHandler | None = None,
):
    self._qubit_support = qubit_support
    self._noise = noise

digital_decomposition()

Decomposition into purely digital gates.

This method returns a decomposition of the Block in a combination of purely digital single-qubit and two-qubit 'gates', by manual/custom knowledge of how this can be done efficiently. :return:

Source code in qadence/blocks/primitive.py

def digital_decomposition(self) -> AbstractBlock:
    """Decomposition into purely digital gates.

    This method returns a decomposition of the Block in a
    combination of purely digital single-qubit and two-qubit
    'gates', by manual/custom knowledge of how this can be done efficiently.
    :return:
    """
    return self

ProjectorBlock(ket, bra, qubit_support, noise=None)

Bases: PrimitiveBlock

The abstract ProjectorBlock.

Arguments:

ket (str): The ket given as a bitstring.
bra (str): The bra given as a bitstring.
qubit_support (int | tuple[int]): The qubit_support of the block.

Source code in qadence/blocks/primitive.py

def __init__(
    self,
    ket: str,
    bra: str,
    qubit_support: int | tuple[int, ...],
    noise: NoiseHandler | None = None,
) -> None:
    """
    Arguments:

        ket (str): The ket given as a bitstring.
        bra (str): The bra given as a bitstring.
        qubit_support (int | tuple[int]): The qubit_support of the block.
    """
    if isinstance(qubit_support, int):
        qubit_support = (qubit_support,)
    if len(bra) != len(ket):
        raise ValueError(
            "Bra and ket must be bitstrings of same length in the 'Projector' definition."
        )
    elif len(bra) != len(qubit_support):
        raise ValueError("Bra or ket must be of same length as the 'qubit_support'")
    for wf in [bra, ket]:
        if not all(int(item) == 0 or int(item) == 1 for item in wf):
            raise ValueError(
                "All qubits must be either in the '0' or '1' state"
                " in the 'ProjectorBlock' definition."
            )

    self.ket = ket
    self.bra = bra
    super().__init__(qubit_support, noise=noise)

ScaleBlock(block, parameter)

Bases: ParametricBlock

Scale blocks are created when multiplying a block by a number or parameter.

Example:

from qadence import X

print(X(0) * 2)

[mul: 2] 
└── X(0)

Source code in qadence/blocks/primitive.py

def __init__(self, block: AbstractBlock, parameter: Any):
    self.block = block
    # TODO: more meaningful name like `scale`?
    self.parameters = (
        parameter if isinstance(parameter, ParamMap) else ParamMap(parameter=parameter)
    )
    super().__init__(block.qubit_support)

TimeEvolutionBlock(qubit_support, noise=None) dataclass

Bases: ParametricBlock

Simple time evolution block with time-independent Hamiltonian.

This class is just a convenience class which is used to label blocks which contains simple time evolution with time-independent Hamiltonian operators

Source code in qadence/blocks/primitive.py

def __init__(
    self,
    qubit_support: tuple[int, ...],
    noise: NoiseHandler | None = None,
):
    self._qubit_support = qubit_support
    self._noise = noise

Analog blocks

To learn how to use analog blocks and how to mix digital & analog blocks, check out the digital-analog section of the documentation.

Examples on how to use digital-analog blocks can be found in the *examples folder of the qadence repo:

• Fit a simple sinus: examples/digital-analog/fit-sin.py
• Solve a QUBO: examples/digital-analog/qubo.py

AnalogChain(blocks) dataclass

Bases: AnalogComposite

A chain of analog blocks.

Needed because analog blocks require stricter validation than the general ChainBlock.

AnalogChains can only be constructed from AnalogKron blocks or globally supported, primitive, analog blocks (like InteractionBlocks and ConstantAnalogRotations).

Automatically constructed by the chain function if only analog blocks are given.

Example:

from qadence import X, chain, AnalogInteraction

b = chain(AnalogInteraction(200), AnalogInteraction(200))
print(type(b))  # this is an `AnalogChain`

b = chain(X(0), AnalogInteraction(200))
print(type(b))  # this is a general `ChainBlock`

<class 'qadence.blocks.analog.AnalogChain'>
<class 'qadence.blocks.composite.ChainBlock'>

Source code in qadence/blocks/analog.py

def __init__(self, blocks: Tuple[AnalogBlock, ...]):
    """A chain of analog blocks.

    Needed because analog blocks require
    stricter validation than the general `ChainBlock`.

    `AnalogChain`s can only be constructed from `AnalogKron` blocks or
    _**globally supported**_, primitive, analog blocks (like `InteractionBlock`s and
    `ConstantAnalogRotation`s).

    Automatically constructed by the [`chain`][qadence.blocks.utils.chain]
    function if only analog blocks are given.

    Example:
    ```python exec="on" source="material-block" result="json"
    from qadence import X, chain, AnalogInteraction

    b = chain(AnalogInteraction(200), AnalogInteraction(200))
    print(type(b))  # this is an `AnalogChain`

    b = chain(X(0), AnalogInteraction(200))
    print(type(b))  # this is a general `ChainBlock`
    ```
    """
    for b in blocks:
        if not (isinstance(b, AnalogKron) or b.qubit_support.is_global):
            raise ValueError("Only KronBlocks or global blocks can be chain'ed.")
    self.blocks = blocks

AnalogKron(blocks, interaction=Interaction.NN) dataclass

Bases: AnalogComposite

Stack analog blocks vertically (i.e. in time).

Needed because analog require stricter validation than the general KronBlock.

AnalogKrons can only be constructed from non-global, analog blocks with the same duration.

Source code in qadence/blocks/analog.py

def __init__(self, blocks: Tuple[AnalogBlock, ...], interaction: Interaction = Interaction.NN):
    """Stack analog blocks vertically (i.e. in time).

    Needed because analog require
    stricter validation than the general `KronBlock`.

    `AnalogKron`s can only be constructed from _**non-global**_, analog blocks
    with the _**same duration**_.
    """
    if len(blocks) == 0:
        raise NotImplementedError("Empty KronBlocks not supported")

    self.blocks = blocks
    self.interaction = interaction

    qubit_support = QubitSupport()
    duration = blocks[0].duration
    for b in blocks:
        if not isinstance(b, AnalogBlock):
            raise ValueError("Can only kron `AnalgoBlock`s with other `AnalgoBlock`s.")

        if b.qubit_support == QubitSupport("global"):
            raise ValueError("Blocks with global support cannot be kron'ed.")

        if not qubit_support.is_disjoint(b.qubit_support):
            raise ValueError("Make sure blocks act on distinct qubits!")

        if not np.isclose(evaluate(duration), evaluate(b.duration)):
            raise ValueError("Kron'ed blocks have to have same duration.")

        qubit_support += b.qubit_support

    self.blocks = blocks

ConstantAnalogRotation(tag=None, __array_priority__=1000, _eigenvalues_generator=None, parameters=ParamMap(alpha=0.0, duration=1000.0, omega=0.0, delta=0.0, phase=0.0), qubit_support=QubitSupport('global'), add_pattern=True) dataclass

Bases: AnalogBlock

Implements a constant analog rotation with interaction dictated by the chosen Hamiltonian.

H/h = ∑ᵢ(Ω/2 cos(φ)*Xᵢ - sin(φ)*Yᵢ - δnᵢ) + Hᵢₙₜ.

To construct this block you can use of the following convenience wrappers: - The general rotation operation AnalogRot - Shorthands for rotatins around an axis: AnalogRX, AnalogRY, AnalogRZ

WARNING: do not use ConstantAnalogRotation with alpha as differentiable parameter - use the convenience wrappers mentioned above.

InteractionBlock(tag=None, __array_priority__=1000, _eigenvalues_generator=None, parameters=ParamMap(duration=1000.0), qubit_support=QubitSupport('global'), add_pattern=True) dataclass

Bases: AnalogBlock

Free-evolution for the Hamiltonian interaction term of a register of qubits.

In real interacting quantum devices, it means letting the system evolve freely according to the time-dependent Schrodinger equation. With emulators, this block is translated to an appropriate interaction Hamiltonian, for example, an Ising interaction

Hᵢₙₜ = ∑ᵢⱼ C₆/rᵢⱼ⁶ nᵢnⱼ

or an XY-interaction

Hᵢₙₜ = ∑ᵢⱼ C₃/rⱼⱼ³ (XᵢXⱼ + ZᵢZⱼ)

with nᵢ = (1-Zᵢ)/2.

To construct, use the AnalogInteraction function.

Composite blocks

chain(*args)

Chain blocks sequentially.

On digital backends this can be interpreted loosely as a matrix mutliplication of blocks. In the analog case it chains blocks in time.

PARAMETER	DESCRIPTION
*args	Blocks to chain. Can also be a generator. TYPE: Union[AbstractBlock, Generator, List[AbstractBlock]] DEFAULT: ()

RETURNS	DESCRIPTION
ChainBlock	ChainBlock

Example:

from qadence import X, Y, chain

b = chain(X(0), Y(0))

# or use a generator
b = chain(X(i) for i in range(3))
print(b)

ChainBlock(0,1,2)
├── X(0)
├── X(1)
└── X(2)

Source code in qadence/blocks/utils.py

def chain(*args: Union[AbstractBlock, Generator, List[AbstractBlock]]) -> ChainBlock:
    """Chain blocks sequentially.

    On digital backends this can be interpreted
    loosely as a matrix mutliplication of blocks. In the analog case it chains
    blocks in time.

    Arguments:
        *args: Blocks to chain. Can also be a generator.

    Returns:
        ChainBlock

    Example:
    ```python exec="on" source="material-block" result="json"
    from qadence import X, Y, chain

    b = chain(X(0), Y(0))

    # or use a generator
    b = chain(X(i) for i in range(3))
    print(b)
    ```
    """
    # ugly hack to use `AnalogChain` if we are dealing only with analog blocks
    if len(args) and all(
        isinstance(a, AnalogBlock) or isinstance(a, AnalogComposite) for a in args
    ):
        return analog_chain(*args)  # type: ignore[return-value,arg-type]
    return _construct(ChainBlock, args)

kron(*args)

Stack blocks vertically.

On digital backends this can be intepreted loosely as a kronecker product of blocks. In the analog case it executes blocks parallel in time.

PARAMETER	DESCRIPTION
*args	Blocks to kron. Can also be a generator. TYPE: Union[AbstractBlock, Generator] DEFAULT: ()

RETURNS	DESCRIPTION
KronBlock	KronBlock

Example:

from qadence import X, Y, kron

b = kron(X(0), Y(1))

# or use a generator
b = kron(X(i) for i in range(3))
print(b)

KronBlock(0,1,2)
├── X(0)
├── X(1)
└── X(2)

Source code in qadence/blocks/utils.py

def kron(*args: Union[AbstractBlock, Generator]) -> KronBlock:
    """Stack blocks vertically.

    On digital backends this can be intepreted
    loosely as a kronecker product of blocks. In the analog case it executes
    blocks parallel in time.

    Arguments:
        *args: Blocks to kron. Can also be a generator.

    Returns:
        KronBlock

    Example:
    ```python exec="on" source="material-block" result="json"
    from qadence import X, Y, kron

    b = kron(X(0), Y(1))

    # or use a generator
    b = kron(X(i) for i in range(3))
    print(b)
    ```
    """
    # ugly hack to use `AnalogKron` if we are dealing only with analog blocks
    if len(args) and all(
        isinstance(a, AnalogBlock) or isinstance(a, AnalogComposite) for a in args
    ):
        return analog_kron(*args)  # type: ignore[return-value,arg-type]
    return _construct(KronBlock, args)

add(*args)

Sums blocks.

PARAMETER	DESCRIPTION
*args	Blocks to add. Can also be a generator. TYPE: Union[AbstractBlock, Generator] DEFAULT: ()

RETURNS	DESCRIPTION
AddBlock	AddBlock

Example:

from qadence import X, Y, add

b = add(X(0), Y(0))

# or use a generator
b = add(X(i) for i in range(3))
print(b)

AddBlock(0,1,2)
├── X(0)
├── X(1)
└── X(2)

Source code in qadence/blocks/utils.py

def add(*args: Union[AbstractBlock, Generator]) -> AddBlock:
    """Sums blocks.

    Arguments:
        *args: Blocks to add. Can also be a generator.

    Returns:
        AddBlock

    Example:
    ```python exec="on" source="material-block" result="json"
    from qadence import X, Y, add

    b = add(X(0), Y(0))

    # or use a generator
    b = add(X(i) for i in range(3))
    print(b)
    ```
    """
    return _construct(AddBlock, args)

AddBlock(blocks)

Bases: CompositeBlock

Adds blocks.

Constructed via add.

Source code in qadence/blocks/composite.py

def __init__(self, blocks: Tuple[AbstractBlock, ...]):
    self.blocks = blocks

ChainBlock(blocks)

Bases: CompositeBlock

Chains blocks sequentially.

Constructed via chain

Source code in qadence/blocks/composite.py

def __init__(self, blocks: Tuple[AbstractBlock, ...]):
    self.blocks = blocks

CompositeBlock(tag=None, __array_priority__=1000) dataclass

Bases: AbstractBlock

Block which composes multiple blocks into one larger block (which can again be composed).

Composite blocks are constructed via chain, kron, and add.

KronBlock(blocks)

Bases: CompositeBlock

Stacks blocks horizontally.

Constructed via kron.

Source code in qadence/blocks/composite.py

def __init__(self, blocks: Tuple[AbstractBlock, ...]):
    if len(blocks) == 0:
        raise NotImplementedError("Empty KronBlocks not supported")

    qubit_support = QubitSupport()
    for b in blocks:
        assert (
            QubitSupportType.GLOBAL,
        ) != b.qubit_support, "Blocks with global support cannot be kron'ed."
        assert qubit_support.is_disjoint(
            b.qubit_support
        ), "Make sure blocks act on distinct qubits!"
        qubit_support += b.qubit_support

    self.blocks = blocks

Converting blocks to matrices

_controlled_block_with_params(block)

Redefines parameterized/non-parameterized controlled block.

PARAMETER	DESCRIPTION
block	original controlled rotation block TYPE: ParametricControlBlock

RETURNS	DESCRIPTION
AbstractBlock	redefined controlled rotation block TYPE: AbstractBlock
dict[str, Tensor]	dict with new parameters which are added

Source code in qadence/blocks/block_to_tensor.py

def _controlled_block_with_params(
    block: ParametricControlBlock | ControlBlock,
) -> tuple[AbstractBlock, dict[str, torch.Tensor]]:
    """Redefines parameterized/non-parameterized controlled block.

    Args:
        block (ParametricControlBlock): original controlled rotation block

    Returns:
        AbstractBlock: redefined controlled rotation block
        dict with new parameters which are added
    """
    from qadence.operations import I
    from qadence.utils import P1

    # redefine controlled rotation block in a way suitable for matrix evaluation
    control = block.qubit_support[:-1]
    target = block.qubit_support[-1]
    p1 = kron(P1(qubit) for qubit in control)
    p0 = I(control[0]) - p1
    c_block = kron(p0, I(target)) + kron(p1, block.blocks[0])

    uuid_expr = uuid_to_expression(c_block)
    newparams = {
        stringify(expr): evaluate(expr, {}, as_torch=True)
        for uuid, expr in uuid_expr.items()
        if expr.is_number
    }

    return c_block, newparams

_fill_identities(block_mat, qubit_support, full_qubit_support, diag_only=False, endianness=Endianness.BIG, device=None)

Returns a Kronecker product of a block matrix with identities.

The block matrix can defined on a subset of qubits and the full matrix is filled with identities acting on the unused qubits.

PARAMETER	DESCRIPTION
block_mat	matrix of an arbitrary gate TYPE: Tensor
qubit_support	qubit support of block_mat TYPE: tuple
full_qubit_support	full qubit support of the circuit TYPE: tuple
diag_only	Use diagonals only TYPE: bool DEFAULT: False

RETURNS	DESCRIPTION
Tensor	torch.Tensor: augmented matrix with dimensions (2nqubits, 2nqubits)
Tensor	or a tensor (2**n_qubits) if diag_only

Source code in qadence/blocks/block_to_tensor.py

def _fill_identities(
    block_mat: torch.Tensor,
    qubit_support: tuple,
    full_qubit_support: tuple | list,
    diag_only: bool = False,
    endianness: Endianness = Endianness.BIG,
    device: torch.device | None = None,
) -> torch.Tensor:
    """Returns a Kronecker product of a block matrix with identities.

    The block matrix can defined on a subset of qubits and the full matrix is
    filled with identities acting on the unused qubits.

    Args:
        block_mat (torch.Tensor): matrix of an arbitrary gate
        qubit_support (tuple): qubit support of `block_mat`
        full_qubit_support (tuple): full qubit support of the circuit
        diag_only (bool): Use diagonals only

    Returns:
        torch.Tensor: augmented matrix with dimensions (2**nqubits, 2**nqubits)
        or a tensor (2**n_qubits) if diag_only
    """
    full_qubit_support = tuple(sorted(full_qubit_support))
    qubit_support = tuple(sorted(qubit_support))
    block_mat = block_mat.to(device)
    mat = IMAT.to(device) if qubit_support[0] != full_qubit_support[0] else block_mat
    if diag_only:
        mat = torch.diag(mat.squeeze(0))
    for i in full_qubit_support[1:]:
        if i == qubit_support[0]:
            other = torch.diag(block_mat.squeeze(0)) if diag_only else block_mat
            if endianness == Endianness.LITTLE:
                mat = torch.kron(other, mat)
            else:
                mat = torch.kron(mat.contiguous(), other.contiguous())
        elif i not in qubit_support:
            other = torch.diag(IMAT.squeeze(0).to(device)) if diag_only else IMAT.to(device)
            if endianness == Endianness.LITTLE:
                mat = torch.kron(other.contiguous(), mat.contiguous())
            else:
                mat = torch.kron(mat.contiguous(), other.contiguous())

    return mat

_phase_matrix(theta)

Args:

theta(torch.Tensor): input parameter

Returns: torch.Tensor: a batch of gates after applying theta

Source code in qadence/blocks/block_to_tensor.py

def _phase_matrix(theta: torch.Tensor | TNumber) -> torch.Tensor:
    """
    Args:

        theta(torch.Tensor): input parameter
    Returns:
        torch.Tensor: a batch of gates after applying theta
    """
    exp_t = torch.exp(1j * theta).unsqueeze(1).unsqueeze(2)
    exp_t = exp_t.repeat((1, 2, 2))
    return 0.5 * (IMAT + ZMAT) + exp_t * 0.5 * (IMAT - ZMAT)

_rot_matrices(theta, generator)

Args:

theta(torch.Tensor): input parameter
generator(torch.Tensor): the tensor of the generator

Returns: torch.Tensor: a batch of gates after applying theta

Source code in qadence/blocks/block_to_tensor.py

def _rot_matrices(theta: torch.Tensor, generator: torch.Tensor) -> torch.Tensor:
    """
    Args:

        theta(torch.Tensor): input parameter
        generator(torch.Tensor): the tensor of the generator
    Returns:
        torch.Tensor: a batch of gates after applying theta
    """
    batch_size = theta.size(0)

    cos_t = torch.cos(theta / 2).unsqueeze(1).unsqueeze(2)
    cos_t = cos_t.repeat((1, 2, 2))
    sin_t = torch.sin(theta / 2).unsqueeze(1).unsqueeze(2)
    sin_t = sin_t.repeat((1, 2, 2))

    batch_imat = IMAT.repeat(batch_size, 1, 1)
    batch_generator = generator.repeat(batch_size, 1, 1)

    return cos_t * batch_imat - 1j * sin_t * batch_generator

_swap_block(block)

Redefines SWAP block.

PARAMETER	DESCRIPTION
block	original SWAP block TYPE: AbstractBlock

RETURNS	DESCRIPTION
AbstractBlock	redefined SWAP block TYPE: AbstractBlock

Source code in qadence/blocks/block_to_tensor.py

def _swap_block(block: AbstractBlock) -> AbstractBlock:
    """Redefines SWAP block.

    Args:
        block (AbstractBlock): original SWAP block

    Returns:
        AbstractBlock: redefined SWAP block
    """
    from qadence.operations import CNOT

    # redefine controlled rotation block in a way suitable for matrix evaluation
    control = block.qubit_support[0]
    target = block.qubit_support[1]
    swap_block = chain(CNOT(control, target), CNOT(target, control), CNOT(control, target))

    return swap_block

_u_matrix(theta)

Args:

theta(tuple[torch.Tensor]): tuple of torch Tensor with 3 elements
    per each parameter of the arbitrary rotation

Returns: torch.Tensor: matrix corresponding to the U gate after applying theta

Source code in qadence/blocks/block_to_tensor.py

def _u_matrix(theta: tuple[torch.Tensor, ...]) -> torch.Tensor:
    """
    Args:

        theta(tuple[torch.Tensor]): tuple of torch Tensor with 3 elements
            per each parameter of the arbitrary rotation
    Returns:
        torch.Tensor: matrix corresponding to the U gate after applying theta
    """
    z_phi = _rot_matrices(theta[0], OPERATIONS_DICT["Z"])
    y_theta = _rot_matrices(theta[1], OPERATIONS_DICT["Y"])
    z_omega = _rot_matrices(theta[2], OPERATIONS_DICT["Z"])

    res = torch.matmul(y_theta, z_phi)
    res = torch.matmul(z_omega, res)
    return res

block_to_tensor(block, values={}, qubit_support=None, use_full_support=True, tensor_type=TensorType.DENSE, endianness=Endianness.BIG, device=None)

Convert a block into a torch tensor.

PARAMETER	DESCRIPTION
block	The block to convert. TYPE: AbstractBlock
values	A optional dict with values for parameters. TYPE: dict DEFAULT: {}
qubit_support	The qubit_support of the block. TYPE: tuple DEFAULT: None
use_full_support	True infers the total number of qubits. TYPE: bool DEFAULT: True
tensor_type	the target tensor type. TYPE: TensorType DEFAULT: DENSE

RETURNS	DESCRIPTION
Tensor	A torch.Tensor.

Examples:

from qadence import hea, hamiltonian_factory, Z, block_to_tensor

block = hea(2,2)
print(block_to_tensor(block))

# In case you have a diagonal observable, you can use
obs = hamiltonian_factory(2, detuning = Z)
print(block_to_tensor(obs, tensor_type="SparseDiagonal"))

tensor([[[ 0.4351+4.2992e-02j, -0.6912-4.9491e-01j, -0.2856-6.6079e-02j,
          -0.0100-1.1552e-02j],
         [ 0.5522-3.8415e-01j,  0.4327+1.2980e-01j, -0.3996-3.3275e-01j,
          -0.2587-7.7870e-02j],
         [ 0.0706-5.1515e-01j, -0.0580-2.6393e-01j,  0.6698-9.0935e-02j,
          -0.1004-4.3543e-01j],
         [-0.0835-2.8112e-01j, -0.0134+3.5530e-04j, -0.0728-4.2592e-01j,
           0.8465+1.0240e-01j]]], grad_fn=<UnsafeViewBackward0>)
tensor(indices=tensor([[0, 3],
                       [0, 3]]),
       values=tensor([ 2.+0.j, -2.+0.j]),
       size=(4, 4), nnz=2, layout=torch.sparse_coo)

Source code in qadence/blocks/block_to_tensor.py

def block_to_tensor(
    block: AbstractBlock,
    values: dict[str, TNumber | torch.Tensor] = {},
    qubit_support: tuple | None = None,
    use_full_support: bool = True,
    tensor_type: TensorType = TensorType.DENSE,
    endianness: Endianness = Endianness.BIG,
    device: torch.device = None,
) -> torch.Tensor:
    """
    Convert a block into a torch tensor.

    Arguments:
        block (AbstractBlock): The block to convert.
        values (dict): A optional dict with values for parameters.
        qubit_support (tuple): The qubit_support of the block.
        use_full_support (bool): True infers the total number of qubits.
        tensor_type (TensorType): the target tensor type.

    Returns:
        A torch.Tensor.

    Examples:
    ```python exec="on" source="material-block" result="json"
    from qadence import hea, hamiltonian_factory, Z, block_to_tensor

    block = hea(2,2)
    print(block_to_tensor(block))

    # In case you have a diagonal observable, you can use
    obs = hamiltonian_factory(2, detuning = Z)
    print(block_to_tensor(obs, tensor_type="SparseDiagonal"))
    ```
    """

    # FIXME: default use_full_support to False. In general, it would
    # be more efficient to do that, and make sure that computations such
    # as observables only do the matmul of the size of the qubit support.

    if tensor_type == TensorType.DENSE:
        from qadence.blocks import embedding

        (ps, embed) = embedding(block)
        return _block_to_tensor_embedded(
            block,
            embed(ps, values),
            qubit_support,
            use_full_support,
            endianness=endianness,
            device=device,
        )

    elif tensor_type == TensorType.SPARSEDIAGONAL:
        t = block_to_diagonal(block, endianness=endianness)
        indices, values, size = torch.nonzero(t), t[t != 0], len(t)
        indices = torch.stack((indices.flatten(), indices.flatten()))
        return torch.sparse_coo_tensor(indices, values, (size, size))