paddle_quantum.linalg

The library of functions in linear algebra.

paddle_quantum.linalg.abs_norm(mat)

tool for calculation of matrix norm

Parameters:: mat (ndarray | Tensor | State) – matrix
Returns:: norm of input matrix
Return type:: float

paddle_quantum.linalg.dagger(mat)

tool for calculation of matrix dagger

Parameters:: mat (ndarray | Tensor) – matrix
Returns:: The dagger of matrix
Return type:: ndarray | Tensor

paddle_quantum.linalg.is_hermitian(mat, eps=1e-06)

verify whether mat is Hermitian

Parameters:

mat (ndarray | Tensor) – hermitian candidate $P$
eps (float | None) – tolerance of error

Returns:

determine whether $P - P^{†} = 0$

Return type:

bool

paddle_quantum.linalg.is_positive(mat, eps=1e-06)

verify whether mat is a positive semi-definite matrix.

Parameters:

mat (ndarray | Tensor) – positive operator candidate $P$
eps (float | None) – tolerance of error

Returns:

determine whether $P$ is Hermitian and eigenvalues are non-negative

Return type:

bool

paddle_quantum.linalg.is_state_vector(vec, eps=None)

verify whether vec is a legal quantum state vector

Parameters:

vec (ndarray | Tensor) – state vector candidate $x$
eps (float | None) – tolerance of error, default to be None i.e. no testing for data correctness

Returns:

determine whether $x^{†} x = 1$ , and return the number of qubits or an error message

Return type:

Tuple[bool, int]

Note

error message is: * -1 if the above equation does not hold * -2 if the dimension of vec is not a power of 2 * -3 if vec is not a vector

paddle_quantum.linalg.is_density_matrix(rho, eps=None)

verify whether rho is a legal quantum density matrix

Parameters:

rho (ndarray | Tensor) – density matrix candidate
eps (float | None) – tolerance of error, default to be None i.e. no testing for data correctness

Returns:

determine whether rho is a PSD matrix with trace 1 and return the number of qubits or an error message.

Return type:

Tuple[bool, int]

Note

error message is: * -1 if rho is not PSD * -2 if the trace of rho is not 1 * -3 if the dimension of rho is not a power of 2 * -4 if rho is not a square matrix

paddle_quantum.linalg.is_projector(mat, eps=1e-06)

verify whether mat is a projector

Parameters:

mat (ndarray | Tensor) – projector candidate $P$
eps (float | None) – tolerance of error

Returns:

determine whether $P P - P = 0$

Return type:

bool

paddle_quantum.linalg.is_unitary(mat, eps=0.0001)

verify whether mat is a unitary

Parameters:

mat (ndarray | Tensor) – unitary candidate $P$
eps (float | None) – tolerance of error

Returns:

determine whether $P P^{†} - I = 0$

Return type:

bool

paddle_quantum.linalg.hermitian_random(num_qubits)

randomly generate a $2^{n} \times 2^{n}$ hermitian matrix

Parameters:: num_qubits (int) – number of qubits $n$
Returns:: a $2^{n} \times 2^{n}$ hermitian matrix
Return type:: Tensor

paddle_quantum.linalg.orthogonal_projection_random(num_qubits)

randomly generate a $2^{n} \times 2^{n}$ rank-1 orthogonal projector

Parameters:: num_qubits (int) – number of qubits $n$
Returns:: a $2^{n} \times 2^{n}$ orthogonal projector
Return type:: Tensor

paddle_quantum.linalg.density_matrix_random(num_qubits)

randomly generate an num_qubits-qubit state in density matrix form

Parameters:: num_qubits (int) – number of qubits $n$
Returns:: a $2^{n} \times 2^{n}$ density matrix
Return type:: Tensor

paddle_quantum.linalg.unitary_random(num_qubits)

randomly generate a $2^{n} \times 2^{n}$ unitary

Parameters:: num_qubits (int) – number of qubits $n$
Returns:: a $2^{n} \times 2^{n}$ unitary matrix
Return type:: Tensor

paddle_quantum.linalg.unitary_hermitian_random(num_qubits)

randomly generate a $2^{n} \times 2^{n}$ hermitian unitary

Parameters:: num_qubits (int) – number of qubits $n$
Returns:: a $2^{n} \times 2^{n}$ hermitian unitary matrix
Return type:: Tensor

paddle_quantum.linalg.unitary_random_with_hermitian_block(num_qubits, is_unitary=False)

randomly generate a unitary $2^{n} \times 2^{n}$ matrix that is a block encoding of a $2^{n / 2} \times 2^{n / 2}$ Hermitian matrix

Parameters:

num_qubits (int) – number of qubits $n$
is_unitary (bool) – whether the hermitian block is a unitary divided by 2 (for tutorial only)

Returns:

a $2^{n} \times 2^{n}$ unitary matrix that its upper-left block is a Hermitian matrix

Return type:

Tensor

paddle_quantum.linalg.block_enc_herm(mat, num_block_qubits=1)

generate a (qubitized) block encoding of hermitian mat

Parameters:

mat (ndarray | Tensor) – matrix to be block encoded
num_block_qubits (int) – ancilla qubits used in block encoding

Returns:

a unitary that is a block encoding of mat

Return type:

ndarray | Tensor

paddle_quantum.linalg.haar_orthogonal(num_qubits)

randomly generate an orthogonal matrix following Haar random, referenced by arXiv:math-ph/0609050v2

Parameters:: num_qubits (int) – number of qubits $n$
Returns:: a $2^{n} \times 2^{n}$ orthogonal matrix
Return type:: Tensor

paddle_quantum.linalg.haar_unitary(num_qubits)

randomly generate a unitary following Haar random, referenced by arXiv:math-ph/0609050v2

Parameters:: num_qubits (int) – number of qubits $n$
Returns:: a $2^{n} \times 2^{n}$ unitary
Return type:: Tensor

paddle_quantum.linalg.haar_state_vector(num_qubits, is_real=False)

randomly generate a state vector following Haar random

Parameters:

num_qubits (int) – number of qubits $n$
is_real (bool | None) – whether the vector is real, default to be False

Returns:

a $2^{n} \times 1$ state vector

Return type:

Tensor

paddle_quantum.linalg.haar_density_operator(num_qubits, rank=None, is_real=False)

randomly generate a density matrix following Haar random

Parameters:

num_qubits (int) – number of qubits $n$
rank (int | None) – rank of density matrix, default to be None refering to full ranks
is_real (bool | None) – whether the density matrix is real, default to be False

Returns:

a $2^{n} \times 2^{n}$ density matrix

Return type:

Tensor

paddle_quantum.linalg.direct_sum(A, B)

calculate the direct sum of A and B

Parameters:

A (ndarray | Tensor) – $m \times n$ matrix
B (ndarray | Tensor) – $p \times q$ matrix

Returns:

a direct sum of A and B, with shape $(m + p) \times (n + q)$

Return type:

ndarray | Tensor

paddle_quantum.linalg.NKron(matrix_A, matrix_B, *args)

calculate Kronecker product of at least two matrices

Parameters:

matrix_A (Tensor | ndarray) – matrix, as paddle.Tensor or numpy.ndarray
matrix_B (Tensor | ndarray) – matrix, as paddle.Tensor or numpy.ndarray
*args (Tensor | ndarray) – other matrices, as paddle.Tensor or numpy.ndarray

Returns:

Kronecker product of matrices, determined by input type of matrix_A

Return type:

Tensor | ndarray

from paddle_quantum.state import density_op_random
from paddle_quantum.linalg import NKron
A = density_op_random(2)
B = density_op_random(2)
C = density_op_random(2)
result = NKron(A, B, C)

Note

result from above code block should be A otimes B otimes C

paddle_quantum.linalg.herm_transform(fcn, mat, ignore_zero=False)

function transformation for Hermitian matrix

Parameters:

fcn (Callable[[float], float]) – function $f$ that can be expanded by Taylor series
mat (Tensor | ndarray | State) – hermitian matrix $H$
ignore_zero (bool | None) – whether ignore eigenspaces with zero eigenvalue, defaults to be False

Returns: $f (H)$

paddle_quantum.linalg.pauli_basis_generation(num_qubits)

Generate a Pauli basis.

Parameters:: num_qubits (int) – the number of qubits $n$ .
Returns:: The Pauli basis of $C^{2^{n} \times 2^{n}}$ .
Return type:: List[Tensor]

paddle_quantum.linalg.pauli_decomposition(mat)

Decompose the matrix by the Pauli basis.

Parameters:: mat (ndarray | Tensor) – the matrix to be decomposed
Returns:: The list of coefficients corresponding to Pauli basis.
Return type:: ndarray | Tensor

paddle_quantum.linalg.subsystem_decomposition(mat, first_basis, second_basis, inner_prod)

Decompose the input matrix by two given bases in two subsystems.

Parameters:

mat (ndarray | Tensor) – the matrix $w$ to be decomposed
first_basis (List[ndarray] | List[Tensor]) – a basis ${e_{i}}_{i}$ from the first space
second_basis (List[ndarray] | List[Tensor]) – a basis ${f_{j}}_{j}$ from the second space
inner_prod (Callable[[ndarray, ndarray], ndarray] | Callable[[Tensor, Tensor], Tensor]) – the inner product of these subspaces

Returns:

a coefficient matrix $[β_{i j}]$ such that $w = \sum_{i, j} β_{i j} e_{i} \otimes f_{j}$ .

Return type:

ndarray | Tensor