Quantum Operators (quanguru.QuantumToolbox.operators)#

Contains methods to functions to create and/or manipulate quantum operators

Functions#

identity()

Creates the identity operator \(\mathbb{I}\).

number()

Creates the (bosonic) number \(\hat{n} := a^{\dagger}a\) operator (in Fock basis).

destroy()

Creates the bosonic annihilation \(\hat{a}\) operator (in Fock basis).

create()

Creates the bosonic creation \(\hat{a}^{\dagger}\) operator (in Fock basis).

sigmaz()

Creates the Pauli (sigma z) \(\hat{\sigma}_{z} := \begin{bmatrix} 1, \ \ 0 \\ 0, -1 \end{bmatrix}\) operator.

sigmay()

Creates the Pauli (sigma y) \(\hat{\sigma}_{y} := \begin{bmatrix} 0, -i \\ i,\ \ 0 \end{bmatrix}\) operator.

sigmax()

Creates the Pauli (sigma x) \(\hat{\sigma}_{x} := \begin{bmatrix} 0, 1 \\ 1, 0 \end{bmatrix}\) operator.

sigmap()

Creates the Pauli (sigma +) \(\hat{\sigma}_{+} := \frac{1}{2}(\hat{\sigma}_{x} +i\hat{\sigma}_{y}) = \begin{bmatrix} 0, 1 \\ 0, 0 \end{bmatrix}\) operator.

sigmam()

Creates the Pauli (sigma -) \(\hat{\sigma}_{-} := \frac{1}{2}(\hat{\sigma}_{x} - i\hat{\sigma}_{y}) = \begin{bmatrix} 0, 0 \\ 1, 0 \end{bmatrix}\) operator.

Jp()

Creates the angular momentum (spin) raising operator \(\hat{J}_{+} := \frac{1}{2}(\hat{J}_{x}+i\hat{J}_{y})\) for a given spin quantum number j.

Jm()

Creates the angular momentum (spin) lowering operator \(\hat{J}_{-} := \frac{1}{2}(\hat{J}_{x}-i\hat{J}_{y})\) for a given spin quantum number j.

Jx()

Creates the angular momentum (spin) X operator \(\hat{J}_{x}\) for a given spin quantum number j.

Jy()

Creates the angular momentum (spin) Y operator \(\hat{J}_{y}\) for a given spin quantum number j.

Jz()

Creates the angular momentum (spin) Z operator \(\hat{J}_{z}\) for a given spin quantum number j.

Js()

Creates the total angular momentum (spin) operator \(\hat{J}_{s} := \hat{J}_{x}^{2} + \hat{J}_{y}^{2}+ \hat{J}_{z}^{2}\) for a given spin quantum number j.

displacement()

Creates the displacement operator \(\hat{D}(\alpha) := e^{\alpha a^{\dagger} - \alpha^{*}a}\) for a given displacement parameter \(\alpha\).

squeeze()

Creates the squeezing operator \(\hat{S}(\alpha) := e^{\frac{1}{2}(\alpha^{*}a^{2} - \alpha a^{\dagger 2})}\) for a given squeezing parameter \(\alpha\).

parityEXP(HamiltonianCavity)

Creates a parity operator \(\hat{P}(\hat{H}) := e^{i\pi\hat{H}}\) by exponenting a given Hamiltonian \(\hat{H}\).

paritySUM()

Creates a parity operator by explicitly placing alternating +/- into a matrix.

compositeOp(operator[, dimB, dimA])

Creates a composite operator \(\hat{O}_{comp} = \mathbb{I}_{dimB\times dimB}\otimes\hat{O}_{single}\otimes\mathbb{I}_{dimA\times dimA}\) ,ie tensor product with identities of dimensions before dimB and after dimA

operatorPow()

Creates a quantum operator for given function reference op and raises to a power.

Function Name

Docstrings

Examples

Unit Tests

Tutorials

identity

      ✅

    ✅

    ✅

    ❌

number

      ✅

    ✅

    ✅

    ❌

destroy

      ✅

    ✅

    ✅

    ❌

create

      ✅

    ✅

    ✅

    ❌

sigmaz

      ✅

    ✅

    ✅

    ❌

sigmay

      ✅

    ✅

    ✅

    ❌

sigmax

      ✅

    ✅

    ✅

    ❌

sigmap

      ✅

    ✅

    ✅

    ❌

sigmam

      ✅

    ✅

    ✅

    ❌

Jp

      ✅

    ✅

    ✅

    ❌

Jm

      ✅

    ✅

    ✅

    ❌

Jx

      ✅

    ✅

    ❌

    ❌

Jy

      ✅

    ✅

    ❌

    ❌

Jz

      ✅

    ✅

    ✅

    ❌

Js

      ✅

    ✅

    ✅

    ❌

displacement

      ✅

    ✅

    ✅

    ❌

squeeze

      ✅

    ✅

    ❌

    ❌

parityEXP

      ✅

    ✅

    ❌

    ❌

paritySUM

      ✅

    ✅

    ❌

    ❌

compositeOp

      ✅

    ✅

    ❌

    ❌

operatorPow

      ✅

    ✅

    ❌

    ❌
number(dimension: int, sparse: Literal[True] = True) → spmatrix[source]#
number(dimension: int, sparse: Literal[False]) → ndarray
number(dimension: int, sparse: bool) → spmatrix | ndarray

Creates the (bosonic) number \(\hat{n} := a^{\dagger}a\) operator (in Fock basis).

Parameters:

  • dimension (int) – dimension of the Hilbert space

  • sparse (bool) – if True(False), the returned Matrix type will be sparse(array)

Returns:

number operator

Return type:

Matrix

Examples

>>> number(dimension=3, sparse=False)
[[0 0 0]
 [0 1 0]
 [0 0 2]]

>>> print(number(3))
(0, 0)      0
(1, 1)      1
(2, 2)      2
destroy(dimension: int, sparse: Literal[True] = True) → spmatrix[source]#
destroy(dimension: int, sparse: Literal[False]) → ndarray
destroy(dimension: int, sparse: bool) → spmatrix | ndarray

Creates the bosonic annihilation \(\hat{a}\) operator (in Fock basis).

Parameters:

  • dimension (int) – dimension of the Hilbert space

  • sparse (bool) – if True(False), the returned Matrix type will be sparse(array)

Returns:

bosonic annihilation operator

Return type:

Matrix

Examples

>>> print(destroy(dimension=3))
(0, 1)      1.0
(1, 2)      1.4142135623730951

>>> destroy(3, sparse=False)
[[0.         1.         0.        ]
 [0.         0.         1.41421356]
 [0.         0.         0.        ]]
create(dimension: int, sparse: Literal[True] = True) → spmatrix[source]#
create(dimension: int, sparse: Literal[False]) → ndarray
create(dimension: int, sparse: bool) → spmatrix | ndarray

Creates the bosonic creation \(\hat{a}^{\dagger}\) operator (in Fock basis).

Parameters:

  • dimension (int) – dimension of the Hilbert space

  • sparse (bool) – if True(False), the returned Matrix type will be sparse(array)

Returns:

bosonic creation operator

Return type:

Matrix

Examples

>>> print(create(3))
(1, 0)      1.0
(2, 1)      1.4142135623730951

>>> create(3, sparse=False)
[[0.         0.         0.        ]
 [1.         0.         0.        ]
 [0.         1.41421356 0.        ]]
identity(dimension: int, sparse: Literal[True] = True) → spmatrix[source]#
identity(dimension: int, sparse: Literal[False]) → ndarray
identity(dimension: int, sparse: bool) → spmatrix | ndarray

Creates the identity operator \(\mathbb{I}\).

Parameters:

  • dimension (int) – dimension of the Hilbert space

  • sparse (bool) – if True(False), the returned Matrix type will be sparse(array)

Returns:

identity operator

Return type:

Matrix

Examples

>>> print(identity(3))
(0, 0)      1.0
(1, 1)      1.0
(2, 2)      1.0

>>> identity(3, sparse=False)
[[1. 0. 0.]
 [0. 1. 0.]
 [0. 0. 1.]]
sigmaz(sparse: Literal[True] = True) → spmatrix[source]#
sigmaz(sparse: Literal[False]) → ndarray
sigmaz(sparse: bool) → spmatrix | ndarray

Creates the Pauli (sigma z) \(\hat{\sigma}_{z} := \begin{bmatrix} 1, \ \ 0 \\ 0, -1 \end{bmatrix}\) operator.

Parameters:

sparse (bool) – if True(False), the returned Matrix type will be sparse(array)

Returns:

Pauli sigma z operator

Return type:

Matrix

Examples

>>> sigmaz(sparse=False)
[[ 1  0]
 [ 0 -1]]

>>> print(sigmaz())
(0, 0)      1
(1, 1)      -1
sigmay(sparse: Literal[True] = True) → spmatrix[source]#
sigmay(sparse: Literal[False]) → ndarray
sigmay(sparse: bool) → spmatrix | ndarray

Creates the Pauli (sigma y) \(\hat{\sigma}_{y} := \begin{bmatrix} 0, -i \\ i,\ \ 0 \end{bmatrix}\) operator.

Parameters:

sparse (bool) – if True(False), the returned Matrix type will be sparse(array)

Returns:

Pauli sigma y operator

Return type:

Matrix

Examples

>>> sigmay(sparse=False)
[[0.+0.j 0.-1.j]
 [0.+1.j 0.+0.j]]

>>> print(sigmay())
(1, 0)      1j
(0, 1)      (-0-1j)
sigmax(sparse: Literal[True] = True) → spmatrix[source]#
sigmax(sparse: Literal[False]) → ndarray
sigmax(sparse: bool) → spmatrix | ndarray

Creates the Pauli (sigma x) \(\hat{\sigma}_{x} := \begin{bmatrix} 0, 1 \\ 1, 0 \end{bmatrix}\) operator.

Parameters:

sparse (bool) – if True(False), the returned Matrix type will be sparse(array)

Returns:

Pauli sigma x operator

Return type:

Matrix

Examples

>>> sigmax(sparse=False)
[[0 1]
 [1 0]]

>>> print(sigmax())
(1, 0)      1
(0, 1)      1
sigmap(sparse: Literal[True] = True) → spmatrix[source]#
sigmap(sparse: Literal[False]) → ndarray
sigmap(sparse: bool) → spmatrix | ndarray

Creates the Pauli (sigma +) \(\hat{\sigma}_{+} := \frac{1}{2}(\hat{\sigma}_{x} +i\hat{\sigma}_{y}) = \begin{bmatrix} 0, 1 \\ 0, 0 \end{bmatrix}\) operator.

Parameters:

sparse (bool) – if True(False), the returned Matrix type will be sparse(array)

Returns:

Pauli sigma + operator

Return type:

Matrix

Examples

>>> sigmap(sparse=False)
[[0 1]
 [0 0]]

>>> print(sigmap())
(0, 1)      1
sigmam(sparse: Literal[True] = True) → spmatrix[source]#
sigmam(sparse: Literal[False]) → ndarray
sigmam(sparse: bool) → spmatrix | ndarray

Creates the Pauli (sigma -) \(\hat{\sigma}_{-} := \frac{1}{2}(\hat{\sigma}_{x} - i\hat{\sigma}_{y}) = \begin{bmatrix} 0, 0 \\ 1, 0 \end{bmatrix}\) operator.

Parameters:

sparse (bool) – if True(False), the returned Matrix type will be sparse(array)

Returns:

Pauli sigma - operator

Return type:

Matrix

Examples

>>> sigmam(sparse=False)
[[0 0]
 [1 0]]

>>> print(sigmam())
(1, 0)      1
Jp(j: float, sparse: Literal[True], isDim: bool = False) → spmatrix[source]#
Jp(j: float, sparse: Literal[False], isDim: bool = False) → ndarray
Jp(j: float, sparse: bool, isDim: bool = False) → spmatrix | ndarray

Creates the angular momentum (spin) raising operator \(\hat{J}_{+} := \frac{1}{2}(\hat{J}_{x}+i\hat{J}_{y})\) for a given spin quantum number j.

NOTE This is a direct matrix construction, i.e. it does not use the Jx and Jy functions, and this function is used in Jx and Jy implementations

Parameters:

  • j (int or float) – integer or half-integer spin quantum number, or the dimension (then spin quantum number = (d-1)/2)

  • sparse (bool) – if True(False), the returned Matrix type will be sparse(array)

  • isDim (bool) – boolean for whether j is spin quantum number of dimension

Returns:

Angular momentum (spin) raising operator

Return type:

Matrix

Examples

>>> Jp(j=2, sparse=False)
[[0.         2.         0.         0.         0.        ]
 [0.         0.         2.44948974 0.         0.        ]
 [0.         0.         0.         2.44948974 0.        ]
 [0.         0.         0.         0.         2.        ]
 [0.         0.         0.         0.         0.        ]]

>>> print(Jp(j=2))
(0, 1)      2.0
(1, 2)      2.449489742783178
(2, 3)      2.449489742783178
(3, 4)      2.0

>>> Jp(j=5, sparse=False, isDim=True)
[[0.         2.         0.         0.         0.        ]
 [0.         0.         2.44948974 0.         0.        ]
 [0.         0.         0.         2.44948974 0.        ]
 [0.         0.         0.         0.         2.        ]
 [0.         0.         0.         0.         0.        ]]

>>> print(Jp(j=5, isDim=True))
(0, 1)      2.0
(1, 2)      2.449489742783178
(2, 3)      2.449489742783178
(3, 4)      2.0
Jm(j: float, sparse: Literal[True] = True, isDim: bool = False) → spmatrix[source]#
Jm(j: float, sparse: Literal[False], isDim: bool = False) → ndarray
Jm(j: float, sparse: bool, isDim: bool = False) → spmatrix | ndarray

Creates the angular momentum (spin) lowering operator \(\hat{J}_{-} := \frac{1}{2}(\hat{J}_{x}-i\hat{J}_{y})\) for a given spin quantum number j.

NOTE This is a direct matrix construction, i.e. it does not use the Jx and Jy functions, and this function is used in Jx and Jy implementations

Parameters:

  • j (int or float) – integer or half-integer spin quantum number, or the dimension (then spin quantum number = (d-1)/2)

  • sparse (bool) – if True(False), the returned Matrix type will be sparse(array)

  • isDim (bool) – boolean for whether j is spin quantum number of dimension

Returns:

Angular momentum (spin) lowering operator

Return type:

Matrix

Examples

>>> Jm(j=2, isDim=False, sparse=False)
[[0.         0.         0.         0.         0.        ]
 [2.         0.         0.         0.         0.        ]
 [0.         2.44948974 0.         0.         0.        ]
 [0.         0.         2.44948974 0.         0.        ]
 [0.         0.         0.         2.         0.        ]]

>>> print(Jm(j=2, isDim=False))
(1, 0)      2.0
(2, 1)      2.449489742783178
(3, 2)      2.449489742783178
(4, 3)      2.0

>>> Jm(j=5, sparse=False, isDim=True)
[[0.         0.         0.         0.         0.        ]
 [2.         0.         0.         0.         0.        ]
 [0.         2.44948974 0.         0.         0.        ]
 [0.         0.         2.44948974 0.         0.        ]
 [0.         0.         0.         2.         0.        ]]

>>> print(Jm(j=5, isDim=True))
(1, 0)      2.0
(2, 1)      2.449489742783178
(3, 2)      2.449489742783178
(4, 3)      2.0
Jx(j: float, sparse: Literal[True] = True, isDim: bool = False) → spmatrix[source]#
Jx(j: float, sparse: Literal[False], isDim: bool = False) → ndarray
Jx(j: float, sparse: bool, isDim: bool = False) → spmatrix | ndarray

Creates the angular momentum (spin) X operator \(\hat{J}_{x}\) for a given spin quantum number j.

NOTE This function uses the definition \(\hat{J}_{x} =\frac{1}{2}(\hat{J}_{p}+\hat{J}_{m})\) and calls Jp and Jm There are no test for this method, it rely on Jp and Jm

Parameters:

  • j (int or float) – integer or half-integer spin quantum number, or the dimension (then spin quantum number = (d-1)/2)

  • sparse (bool) – if True(False), the returned Matrix type will be sparse(array)

  • isDim (bool) – boolean for whether j is spin quantum number of dimension

Returns:

Angular momentum (spin) X operator

Return type:

Matrix

Examples

>>> Jx(j=2, isDim=False, sparse=False)
[[0.         1.         0.         0.         0.        ]
 [1.         0.         1.22474487 0.         0.        ]
 [0.         1.22474487 0.         1.22474487 0.        ]
 [0.         0.         1.22474487 0.         1.        ]
 [0.         0.         0.         1.         0.        ]]

>>> print(Jx(j=2, isDim=False))
(1, 0)      1.0
(0, 1)      1.0
(2, 1)      1.224744871391589
(1, 2)      1.224744871391589
(3, 2)      1.224744871391589
(2, 3)      1.224744871391589
(4, 3)      1.0
(3, 4)      1.0

>>> Jx(j=5, sparse=False, isDim=True)
[[0.         1.         0.         0.         0.        ]
 [1.         0.         1.22474487 0.         0.        ]
 [0.         1.22474487 0.         1.22474487 0.        ]
 [0.         0.         1.22474487 0.         1.        ]
 [0.         0.         0.         1.         0.        ]]

>>> print(Jx(j=5, isDim=True))
(1, 0)      1.0
(0, 1)      1.0
(2, 1)      1.224744871391589
(1, 2)      1.224744871391589
(3, 2)      1.224744871391589
(2, 3)      1.224744871391589
(4, 3)      1.0
(3, 4)      1.0
Jy(j: float, sparse: Literal[True] = True, isDim: bool = False) → spmatrix[source]#
Jy(j: float, sparse: Literal[False], isDim: bool = False) → ndarray
Jy(j: float, sparse: bool, isDim: bool = False) → spmatrix | ndarray

Creates the angular momentum (spin) Y operator \(\hat{J}_{y}\) for a given spin quantum number j.

NOTE This function uses the definition \(\hat{J}_{y}=\frac{1}{2j}(\hat{J}_{p}-\hat{J}_{m})\) and calls Jp and Jm There are no test for this method, it rely on Jp and Jm

Parameters:

  • j (int or float) – integer or half-integer spin quantum number, or the dimension (then spin quantum number = (d-1)/2)

  • sparse (bool) – if True(False), the returned Matrix type will be sparse(array)

  • isDim (bool) – boolean for whether j is spin quantum number of dimension

Returns:

Angular momentum (spin) Y operator

Return type:

Matrix

Examples

>>> Jy(j=2, isDim=False, sparse=False)
[[0.+0.j         0.-1.j         0.+0.j         0.+0.j                0.+0.j        ]
 [0.+1.j         0.+0.j         0.-1.22474487j 0.+0.j                0.+0.j        ]
 [0.+0.j         0.+1.22474487j 0.+0.j         0.-1.22474487j        0.+0.j        ]
 [0.+0.j         0.+0.j         0.+1.22474487j 0.+0.j                0.-1.j        ]
 [0.+0.j         0.+0.j         0.+0.j         0.+1.j                0.+0.j        ]]

>>> print(Jy(j=2, isDim=False))
(1, 0)      1j
(0, 1)      -1j
(2, 1)      1.224744871391589j
(1, 2)      -1.224744871391589j
(3, 2)      1.224744871391589j
(2, 3)      -1.224744871391589j
(4, 3)      1j
(3, 4)      -1j

>>> Jy(j=5, sparse=False, isDim=True)
[[0.+0.j         0.-1.j         0.+0.j         0.+0.j                0.+0.j        ]
 [0.+1.j         0.+0.j         0.-1.22474487j 0.+0.j                0.+0.j        ]
 [0.+0.j         0.+1.22474487j 0.+0.j         0.-1.22474487j        0.+0.j        ]
 [0.+0.j         0.+0.j         0.+1.22474487j 0.+0.j                0.-1.j        ]
 [0.+0.j         0.+0.j         0.+0.j         0.+1.j                0.+0.j        ]]

>>> print(Jy(j=5, isDim=True))
(1, 0)      1j
(0, 1)      -1j
(2, 1)      1.224744871391589j
(1, 2)      -1.224744871391589j
(3, 2)      1.224744871391589j
(2, 3)      -1.224744871391589j
(4, 3)      1j
(3, 4)      -1j
Jz(j: float, sparse: Literal[True] = True, isDim: bool = False) → spmatrix[source]#
Jz(j: float, sparse: Literal[False], isDim: bool = False) → ndarray
Jz(j: float, sparse: bool, isDim: bool = False) → spmatrix | ndarray

Creates the angular momentum (spin) Z operator \(\hat{J}_{z}\) for a given spin quantum number j.

Parameters:

  • j (int or float) – integer or half-integer spin quantum number, or the dimension (then spin quantum number = (d-1)/2)

  • sparse (bool) – if True(False), the returned Matrix type will be sparse(array)

  • isDim (bool) – boolean for whether j is spin quantum number of dimension

Returns:

Angular momentum (spin) Z operator

Return type:

Matrix

Examples

>>> Jz(j=2, isDim=False, sparse=False)
[[ 2  0  0  0  0]
 [ 0  1  0  0  0]
 [ 0  0  0  0  0]
 [ 0  0  0 -1  0]
 [ 0  0  0  0 -2]]

>>> print(Jz(j=2, isDim=False))
(0, 0)      2
(1, 1)      1
(2, 2)      0
(3, 3)      -1
(4, 4)      -2

>>> Jz(j=5, sparse=False, isDim=True)
[[ 2.  0.  0.  0.  0.]
 [ 0.  1.  0.  0.  0.]
 [ 0.  0.  0.  0.  0.]
 [ 0.  0.  0. -1.  0.]
 [ 0.  0.  0.  0. -2.]]

>>> print(Jz(j=5, isDim=True))
(0, 0)      2.0
(1, 1)      1.0
(2, 2)      0.0
(3, 3)      -1.0
(4, 4)      -2.0
Js(j: float, sparse: Literal[True] = True, isDim: bool = False) → spmatrix[source]#
Js(j: float, sparse: Literal[False], isDim: bool = False) → ndarray
Js(j: float, sparse: bool, isDim: bool = False) → spmatrix | ndarray

Creates the total angular momentum (spin) operator \(\hat{J}_{s} := \hat{J}_{x}^{2} + \hat{J}_{y}^{2}+ \hat{J}_{z}^{2}\) for a given spin quantum number j.

NOTE This function is direct implementation of the defition, meaning it uses Jx, Jy, and Jz functions

Parameters:

  • j (int or float) – integer or half-integer spin quantum number, or the dimension (then spin quantum number = (d-1)/2)

  • sparse (bool) – if True(False), the returned Matrix type will be sparse(array)

  • isDim (bool) – boolean for whether j is spin quantum number of dimension

Return type:

Total angular momentum (spin) operator

Examples

>>> Js(j=2, isDim=False, sparse=False)
[[6.+0.j 0.+0.j 0.+0.j 0.+0.j 0.+0.j]
 [0.+0.j 6.+0.j 0.+0.j 0.+0.j 0.+0.j]
 [0.+0.j 0.+0.j 6.+0.j 0.+0.j 0.+0.j]
 [0.+0.j 0.+0.j 0.+0.j 6.+0.j 0.+0.j]
 [0.+0.j 0.+0.j 0.+0.j 0.+0.j 6.+0.j]]

>>> print(Js(j=2, isDim=False))
(0, 0)      (6+0j)
(1, 1)      (6+0j)
(2, 2)      (5.999999999999999+0j)
(3, 3)      (6+0j)
(4, 4)      (6+0j)

>>> Js(j=5, sparse=False, isDim=True)
[[6.+0.j 0.+0.j 0.+0.j 0.+0.j 0.+0.j]
 [0.+0.j 6.+0.j 0.+0.j 0.+0.j 0.+0.j]
 [0.+0.j 0.+0.j 6.+0.j 0.+0.j 0.+0.j]
 [0.+0.j 0.+0.j 0.+0.j 6.+0.j 0.+0.j]
 [0.+0.j 0.+0.j 0.+0.j 0.+0.j 6.+0.j]]

>>> print(Js(j=5, isDim=True))
(0, 0)      (6+0j)
(1, 1)      (6+0j)
(2, 2)      (5.999999999999999+0j)
(3, 3)      (6+0j)
(4, 4)      (6+0j)
displacement(alpha: complex, dim: int, sparse: Literal[True] = True) → spmatrix[source]#
displacement(alpha: complex, dim: int, sparse: Literal[False]) → ndarray
displacement(alpha: complex, dim: int, sparse: bool) → spmatrix | ndarray

Creates the displacement operator \(\hat{D}(\alpha) := e^{\alpha a^{\dagger} - \alpha^{*}a}\) for a given displacement parameter \(\alpha\).

NOTE can be implemented without matrix exponentiation

Parameters:

  • alpha (complex) – complex number, the displacement parameter

  • dim (int) – dimension of the Hilbert space

  • sparse (bool) – if True(False), the returned Matrix type will be sparse(array)

Returns:

Displacement operator

Return type:

Matrix

Examples

>>> displacement(alpha=1j, dim=4, sparse=False)
[[ 0.60605894+0.j          0.        +0.6100857j  -0.41242505+0.j       0.        -0.30065525j]
 [ 0.        +0.6100857j   0.02280184+0.j          0.        +0.34204129j        -0.71434114+0.j]
 [-0.41242505+0.j          0.        +0.34204129j -0.56045527+0.j        0.        +0.63150869j]
 [ 0.        -0.30065525j -0.71434114+0.j          0.        +0.63150869j        0.02280184+0.j]]

>>> print(displacement(alpha=1j, dim=4))
(0, 0)      (0.6060589372864117+0j)
(1, 0)      0.610085698426889j
(2, 0)      (-0.41242505189886125+0j)
(3, 0)      (-0-0.3006552538647247j)
(0, 1)      0.610085698426889j
(1, 1)      (0.02280183542861441+0j)
(2, 1)      0.3420412936689465j
(3, 1)      (-0.7143411442030587+0j)
(0, 2)      (-0.4124250518988613+0j)
(1, 2)      0.34204129366894637j
(2, 2)      (-0.5604552664291825+0j)
(3, 2)      0.6315086890322961j
(0, 3)      -0.3006552538647247j
(1, 3)      (-0.7143411442030586+0j)
(2, 3)      0.6315086890322962j
(3, 3)      (0.02280183542861464+0j)
squeeze(alpha: complex, dim: int, sparse: Literal[True] = True) → spmatrix[source]#
squeeze(alpha: complex, dim: int, sparse: Literal[False]) → ndarray
squeeze(alpha: complex, dim: int, sparse: bool) → spmatrix | ndarray

Creates the squeezing operator \(\hat{S}(\alpha) := e^{\frac{1}{2}(\alpha^{*}a^{2} - \alpha a^{\dagger 2})}\) for a given squeezing parameter \(\alpha\).

NOTE can be implemented without matrix exponentiation

Parameters:

  • alpha (complex) – complex number, the squeezing parameter

  • dim (int) – dimension of the Hilbert space

  • sparse (bool) – if True(False), the returned Matrix type will be sparse(array)

Returns:

Squeezing operator

Return type:

Matrix

Examples

>>> squeeze(alpha=1j, dim=4, sparse=False)
[[0.7602446 +0.j         0.        +0.j         0.        -0.64963694j      0.        +0.j        ]
 [0.        +0.j         0.33918599+0.j         0.        +0.j               0.        -0.94071933j]
 [0.        -0.64963694j 0.        +0.j         0.7602446 +0.j               0.        +0.j        ]
 [0.        +0.j         0.        -0.94071933j 0.        +0.j               0.33918599+0.j        ]]

>>> print(squeeze(alpha=1j, dim=4))
(0, 0)      (0.7602445970756301+0j)
(2, 0)      -0.6496369390800625j
(1, 1)      (0.3391859889869473+0j)
(3, 1)      -0.940719333741444j
(0, 2)      -0.6496369390800625j
(2, 2)      (0.7602445970756302+0j)
(1, 3)      -0.9407193337414442j
(3, 3)      (0.33918598898694713+0j)
parityEXP(HamiltonianCavity: spmatrix | ndarray) → spmatrix | ndarray[source]#

Creates a parity operator \(\hat{P}(\hat{H}) := e^{i\pi\hat{H}}\) by exponenting a given Hamiltonian \(\hat{H}\).

Keeps sparse/array as sparse/array.

Parameters:

HamiltonianCavity (Matrix) – dimension of the Hilbert space

Returns:

Parity operator

Return type:

Matrix

Examples

>>> ham = number(dimension=5, sparse=False)
>>> parityEXP(HamiltonianCavity=ham) # returns an array since ham is an array
[[ 1.+0.0000000e+00j  0.+0.0000000e+00j  0.+0.0000000e+00j  0.+0.0000000e+00j  0.+0.0000000e+00j]
 [ 0.+0.0000000e+00j -1.+1.2246468e-16j  0.+0.0000000e+00j  0.+0.0000000e+00j  0.+0.0000000e+00j]
 [ 0.+0.0000000e+00j  0.+0.0000000e+00j  1.-2.4492936e-16j  0.+0.0000000e+00j  0.+0.0000000e+00j]
 [ 0.+0.0000000e+00j  0.+0.0000000e+00j  0.+0.0000000e+00j  -1.+3.6739404e-16j  0.+0.0000000e+00j]
 [ 0.+0.0000000e+00j  0.+0.0000000e+00j  0.+0.0000000e+00j  0.+0.0000000e+00j  1.-4.8985872e-16j]]

>>> ham = number(dimension=5)
>>> print(parityEXP(HamiltonianCavity=ham)) # returns a sparse since ham is a sparse
(0, 0)      (1+0j)
(0, 1)      0j
(1, 1)      (-1+1.2246467991473532e-16j)
(1, 2)      -0j
(2, 2)      (1-2.4492935982947064e-16j)
(2, 3)      0j
(3, 3)      (-1+3.6739403974420594e-16j)
(3, 4)      -0j
(4, 4)      (1-4.898587196589413e-16j)
paritySUM(dimension: int, sparse: Literal[True] = True) → spmatrix[source]#
paritySUM(dimension: int, sparse: Literal[False]) → ndarray
paritySUM(dimension: int, sparse: bool) → spmatrix | ndarray

Creates a parity operator by explicitly placing alternating +/- into a matrix.

Parameters:

  • dimension (int) – dimension of the Hilbert space

  • sparse (bool) – if True(False), the returned Matrix type will be sparse(array)

Returns:

Parity operator

Return type:

Matrix

Examples

>>> paritySUM(dimension=5, sparse=False)
[[ 1.  0.  0.  0.  0.]
 [ 0. -1.  0.  0.  0.]
 [ 0.  0.  1.  0.  0.]
 [ 0.  0.  0. -1.  0.]
 [ 0.  0.  0.  0.  1.]]

>>> print(paritySUM(dimension=5))
(0, 0)      1.0
(1, 1)      -1.0
(2, 2)      1.0
(3, 3)      -1.0
(4, 4)      1.0
compositeOp(operator: spmatrix | ndarray, dimB: int = 1, dimA: int = 1) → spmatrix | ndarray[source]#

Creates a composite operator \(\hat{O}_{comp} = \mathbb{I}_{dimB\times dimB}\otimes\hat{O}_{single}\otimes\mathbb{I}_{dimA\times dimA}\) ,ie tensor product with identities of dimensions before dimB and after dimA

NOTE simply calls and returns tensorProd

Parameters:

  • operator (Matrix) – operator of a sub-system

  • dimB (int) – (total) dimension of the systems that appear before in the tensor product order

  • dimA (int) – (total) dimension of the systems that appear after in the tensor product order

Returns:

sub-system operator in the extended Hilbert space

Return type:

Matrix

Examples

>>> compositeOp(operator=sigmaz(), dimB=0, dimA=2).toarray()
[[ 1.  0.  0.  0.]
 [ 0.  1.  0.  0.]
 [ 0.  0. -1.  0.]
 [ 0.  0.  0. -1.]]

>>> compositeOp(operator=sigmaz(), dimB=2, dimA=0).toarray()
[[ 1.  0.  0.  0.]
 [ 0. -1.  0.  0.]
 [ 0.  0.  1.  0.]
 [ 0.  0.  0. -1.]]
operatorPow(op: Callable, dim: int, power: int, sparse: Literal[True] = True) → spmatrix[source]#
operatorPow(op: Callable, dim: int, power: int, sparse: Literal[False]) → ndarray
operatorPow(op: Callable, dim: int, power: int, sparse: bool) → spmatrix | ndarray

Creates a quantum operator for given function reference op and raises to a power.

Parameters:

  • op (Callable) – reference to the function (in here) for the operator

  • dim (int) – dimension of the Hilbert space

  • power (int) – power that the operator to be raised

  • sparse (bool) – if True(False), the returned Matrix type will be sparse(array)

Returns:

an operator raised to a power

Return type:

Matrix

Examples

>>> operatorPow(op=sigmax, dim=2, power=2, sparse=False)
[[1 0]
 [0 1]]

>>> print(operatorPow(op=sigmax, dim=2, power=2))
(0, 0)      1
(1, 1)      1

>>> operatorPow(op=sigmax, dim=2, power=3, sparse=False)
[[0 1]
 [1 0]]

>>> print(operatorPow(op=sigmax, dim=2, power=3))
(1, 0)      1
(0, 1)      1