Basic Linear Algebra (`quanguru.QuantumToolbox.linearAlgebra`)#

Contains some basic linear algebra methods for scipy.sparse and np.ndarray types.

Functions#

`hc`(matrix)	Hermitian conjugate $M^{\dagger} := (M^{})^{T}$ of a matrix $M$ , where is complex conjugation, and T is transposition.
`innerProd`(ket1[, ket2])	Computes the inner product $\langle ket2 \| ket1 \rangle$ of a ket vector with itself or with another, where $\langle ket2\| := \|ket2 \rangle^{\dagger}$ .
`norm`(ket)	Norm $\sqrt{\langle ket \| ket \rangle}$ of a ket state $\|ket \rangle$ , where $\langle ket\| := \|ket \rangle^{\dagger}$ .
`outerProd`(ket1[, ket2])	Computes the outer product $\|ket2 \rangle\langle ket1\|$ of a ket vector with itself or with another, where $\langle ket2\| := \|ket2 \rangle^{\dagger}$ .
`tensorProd`(*args)	Function to calculate tensor product $\otimes_{i} M_{i}$ of given (any number i of) states ( $\{M_{i}\}$ in the given order).
`trace`(matrix)	Trace $Tr(M) := \sum_{i} M_{ii}$ of a matrix M.
`partialTrace`(keep, dims, state)	Calculates the partial trace of a density matrix of composite state.
`_matMulInputs`(*args)	Calculates the matrix multiplication of the given arbitrary number of inputs in the given order.
`_matPower`(matrix, power)	A recursive function to raise the given matrix to a power, ie for given matrix $M$ and power $n$ , this returns $\overbrace{M @ M @ \cdots @ M}^{n times}$ , where $@$ is the matrix multiplication.

Function Name	Docstrings	Examples	Unit Tests	Tutorials
hc	✅	✅	✅	❌
innerProd	✅	✅	✅	❌
norm	✅	✅	✅	❌
outerProd	✅	✅	✅	❌
tensorProd	✅	✅	✅	❌
trace	✅	✅	✅	❌
partialTrace	✅	✅	✅	❌
_matMulInputs	✅	✅	✅	❌
_matPower	✅	✅	✅	❌

hc(matrix: Union[scipy.sparse._base.spmatrix, numpy.ndarray]) → Union[scipy.sparse._base.spmatrix, numpy.ndarray][source]#

Hermitian conjugate $M^{\dagger} := (M^{*})^{T}$ of a matrix $M$ , where * is complex conjugation, and T is transposition.

Parameters: matrix (Matrix) – a matrix
Returns: Hermitian conjugate of the given matrix
Return type: Matrix

Examples

>>> operEx1 = np.array([[1+1j, 2+2j],
>>>                     [3+3j, 4+4j]])
>>> hc(operEx1)
array([[1.-1.j, 3.-3.j],
       [2.-2.j, 4.-4.j]])

>>> operEx2 = np.array([[0, 1],
>>>                    [1, 0]])
>>> hc(operEx2)
array([[0, 1],
       [1, 0]])

>>> operEx3 = np.array([[1, 0, 0],
>>>                     [0, 1, 0],
>>>                     [1j, 0, 1]])
>>> hc(operEx3)
array([[1, 0, -1j],
       [0, 1, 0],
       [0, 0, 1]])

innerProd(ket1: Union[scipy.sparse._base.spmatrix, numpy.ndarray], ket2: Optional[Union[scipy.sparse._base.spmatrix, numpy.ndarray]] = None) → float[source]#

Computes the inner product $\langle ket2 | ket1 \rangle$ of a ket vector with itself or with another, where $\langle ket2| := |ket2 \rangle^{\dagger}$ .

Parameters

ket1 (Matrix) – 1st ket state
ket2 (Matrix) – 2nd ket state

Returns

inner product

Return type

float

Examples

>>> cMatEx1 = np.array([[1],
>>>                     [0]])
>>> innerProd(cMatEx1)
1

>>> cMatEx2 = np.array([[0],
>>>                     [1]])
>>> innerProd(cMatEx2)
1

>>> cMatEx3 = (1/5)*np.array([[3],
>>>                           [4j]])
>>> innerProd(cMatEx3)
1

>>> cMatEx4 = np.array([[1],
>>>                     [1j]])
>>> innerProd(cMatEx4)
2

norm(ket: Union[scipy.sparse._base.spmatrix, numpy.ndarray]) → float[source]#

Norm $\sqrt{\langle ket | ket \rangle}$ of a ket state $|ket \rangle$ , where $\langle ket| := |ket \rangle^{\dagger}$ . This function simply returns the square root of innerProd

Parameters: ket (Matrix) – a ket state
Returns: norm of the state
Return type: float

Examples

>>> cMatEx1 = np.array([[1],
>>>                     [0]])
>>> norm(cMatEx1)
1

>>> cMatEx2 = np.array([[3],
>>>                     [4j]])
>>> norm(cMatEx2)
5+0j

>>> cMatEx3 = np.array([[1],
>>>                     [1j]])
>>> norm(cMatEx3)
1.4142135623730951+0j

outerProd(ket1: Union[scipy.sparse._base.spmatrix, numpy.ndarray], ket2: Optional[Union[scipy.sparse._base.spmatrix, numpy.ndarray]] = None) → Union[scipy.sparse._base.spmatrix, numpy.ndarray][source]#

Computes the outer product $|ket2 \rangle\langle ket1|$ of a ket vector with itself or with another, where $\langle ket2| := |ket2 \rangle^{\dagger}$ .

Parameters

ket1 (Matrix) – 1st ket state
ket2 (Matrix) – 2nd ket state

Returns

operator in square matrix form resulting from the computed outer product

Return type

Matrix

Examples

>>> cMatEx1 = np.array([[1],
>>>                     [0]])
>>> outerProd(cMatEx1)
array([[1, 0],
       [0, 0]])

>>> cMatEx2 = np.array([[0],
>>>                     [1]])
>>> outerProd(cMatEx2)
array([[0, 0],
       [0, 1]])

>>> cMatEx3 = (1/5)*np.array([[3],
>>>                           [4j]])
>>> outerProd(cMatEx3)
array([[0.36+0.j  , 0.  -0.48j],
       [0.  +0.48j, 0.64+0.j  ]])

>>> cMatEx4 = np.array([[1],
>>>                     [1j]])
>>> outerProd(cMatEx4)
array([[1+0.j , 0. -1j],
       [0. +1j, 1+0.j ]])

tensorProd(*args: Union[scipy.sparse._base.spmatrix, numpy.ndarray]) → Union[scipy.sparse._base.spmatrix, numpy.ndarray][source]#

Function to calculate tensor product $\otimes_{i} M_{i}$ of given (any number i of) states ( $\{M_{i}\}$ in the given order).

Parameters: *args (Matrix) – state matrices (arbitrary number of them)
Returns: tensor product of given states (in the given order)
Return type: Matrix

Examples

>>> cMatEx1 = np.array([[1],
>>>                     [0]])
>>> cMatEx2 = np.array([[0],
>>>                     [1]])
>>> tensorProd(cMatEx1, cMatEx2)
array([[0],
       [1],
       [0],
       [0]], dtype=int64)
>>> tensorProd(cMatEx2, cMatEx1)
array([[0],
       [0],
       [1],
       [0]], dtype=int64)

>>> operEx1 = np.array([[0, 1],
>>>                    [1, 0]])
>>> operEx2 = np.array([[1, 0, 0],
>>>                     [0, 1, 0],
>>>                     [1j, 0, 1]])
>>> tensorProd(operEx1, operEx2)
array([[0, 0, 0, 1, 0, 0],
       [0, 0, 0, 0, 1, 0],
       [0, 0, 0, 0, 0, 1],
       [1, 0, 0, 0, 0, 0],
       [0, 1, 0, 0, 0, 0],
       [0, 0, 1, 0, 0, 0]], dtype=int64)
>>> tensorProd(operEx2, operEx1)
array([[0, 1, 0, 0, 0, 0],
       [1, 0, 0, 0, 0, 0],
       [0, 0, 0, 1, 0, 0],
       [0, 0, 1, 0, 0, 0],
       [0, 0, 0, 0, 0, 1],
       [0, 0, 0, 0, 1, 0]], dtype=int64)

trace(matrix: Union[scipy.sparse._base.spmatrix, numpy.ndarray]) → float[source]#

Trace $Tr(M) := \sum_{i} M_{ii}$ of a matrix M.

Parameters: matrix (Matrix) – a matrix
Returns: trace of the given matrix
Return type: float

Examples

>>> cMatEx1 = np.array([[1],
>>>                     [0]])
>>> trace(outerProd(cMatEx1))
1

>>> cMatEx2 = np.array([[0],
>>>                     [1]])
>>> trace(outerProd(cMatEx2))
1

partialTrace(keep: Union[numpy.ndarray, List[int]], dims: Union[numpy.ndarray, List[int]], state: Union[scipy.sparse._base.spmatrix, numpy.ndarray]) → numpy.ndarray[source]#

Calculates the partial trace of a density matrix of composite state.

Parameters

keep (ndOrListInt) – An array of indices of the spaces to keep after being traced. For instance, if the space is A x B x C x D and we want to trace out B and D, keep = [0,2]
dims (ndOrListInt) – An array of the dimensions of each space. For instance, if the space is A x B x C x D, dims = [dim_A, dim_B, dim_C, dim_D]
state (Matrix) – Matrix to trace

Returns

Traced matrix

Return type

Matrix

Examples

>>> cMatEx1 = np.array([[1],
>>>                     [0]])
>>> cMatEx2 = np.array([[0],
>>>                     [1]])
>>> partialTrace([0], [2, 2], outerProd(tensorProd(cMatEx1, cMatEx2)))
array([[1, 0],
       [0, 0]], dtype=int64)
>>> partialTrace([1], [2, 2], outerProd(tensorProd(cMatEx1, cMatEx2)))
array([[0, 0],
       [0, 1]], dtype=int64)
>>> partialTrace([0], [2, 2], outerProd(tensorProd(cMatEx2, cMatEx1)))
array([[0, 0],
       [0, 1]], dtype=int64)
>>> partialTrace([1], [2, 2], outerProd(tensorProd(cMatEx2, cMatEx1)))
array([[1, 0],
       [0, 0]], dtype=int64)

_matMulInputs(*args: Union[scipy.sparse._base.spmatrix, numpy.ndarray, List[Union[scipy.sparse._base.spmatrix, numpy.ndarray]]]) → Union[scipy.sparse._base.spmatrix, numpy.ndarray][source]#

Calculates the matrix multiplication of the given arbitrary number of inputs in the given order. It does not check the correctness of the shapes until the matrix multiplication operator (@) itself gives an error.

Parameters: *args (matrixOrMatrixList) –
Returns: Given Matrices multiplied
Return type: Matrix

Examples

>>> cMatEx1 = np.array([[1, 1],
>>>                     [1, 1]])
>>> cMatEx2 = np.array([[1, 0],
>>>                     [0, 0]])
>>> qg.linearAlgebra._matMulInputs(cMatEx1,cMatEx2)
array([[1, 0],
       [1, 0]])

>>> cMatEx1 = np.array([[1, 1],
>>>                     [1, 1]])
>>> cMatEx2 = np.array([[1, 0],
>>>                     [0, 0]])
>>> cMatEx3 = np.array([[1, 1],
>>>                     [0, 0]])
>>> qg.linearAlgebra._matMulInputs(cMatEx1,cMatEx2,cMatEx3)
array([[1, 1],
       [1, 1]])

_matPower(matrix: Union[scipy.sparse._base.spmatrix, numpy.ndarray], power: int) → Union[scipy.sparse._base.spmatrix, numpy.ndarray][source]#

A recursive function to raise the given matrix to a power, ie for given matrix $M$ and power $n$ , this returns $\overbrace{M @ M @ \cdots @ M}^{n times}$ , where $@$ is the matrix multiplication.

Parameters

matrix (Matrix) – The matrix to raise to a power
power (int) – Power to raise

Returns

Given matrix raised to given power

Return type

Matrix

Examples

>>> cMatEx1 = np.array([[1, 1],
>>>                     [1, 1]])
>>> qg.linearAlgebra._matMulInputs(cMatEx1, 2)
array([[2, 2],
       [2, 2]])

>>> cMatEx1 = np.array([[1, 1],
>>>                     [1, 1]])
>>> qg.linearAlgebra._matMulInputs(cMatEx1, 5)
array([[16, 16],
       [16, 16]])

>>> cMatEx2 = np.array([[1, 1],
>>>                     [0, 0]])
>>> qg.linearAlgebra._matMulInputs(cMatEx1, 3)
array([[1, 1],
       [0, 0]])

Quantum Toolbox (quanguru.QuantumToolbox)

Quantum States (quanguru.QuantumToolbox.states)

Basic Linear Algebra (quanguru.QuantumToolbox.linearAlgebra)#

Functions#

Basic Linear Algebra (`quanguru.QuantumToolbox.linearAlgebra`)#