toqito.matrix_props.is_commuting
================================

.. py:module:: toqito.matrix_props.is_commuting

.. autoapi-nested-parse::

   Checks if the matrix is commuting.





Module Contents
---------------

.. py:function:: is_commuting(mat_1, mat_2)

   Determine if two linear operators commute with each other [@WikiComm].

   For any pair of operators \(X, Y \in \text{L}(\mathcal{X})\), the
   Lie bracket \(\left[X, Y\right] \in \text{L}(\mathcal{X})\) is defined
   as

   \[
       \left[X, Y\right] = XY - YX.
   \]

   It holds that \(\left[X,Y\right]=0\) if and only if \(X\) and
   \(Y\) commute (Section: Lie Brackets And Commutants from [@Watrous_2018_TQI]).

   .. rubric:: Examples

   Consider the following matrices:

   \[
       A = \begin{pmatrix} 0 & 1 \\ 0 & 0 \end{pmatrix},
       \quad \text{and} \quad
       B = \begin{pmatrix} 1 & 0 \\ 0 & 0 \end{pmatrix}.
   \]

   It holds that \(AB=0\), however

   \[
       BA = \begin{pmatrix} 0 & 1 \\ 0 & 0 \end{pmatrix} = A,
   \]

   and hence, do not commute.

   ```python exec="1" source="above"
   import numpy as np
   from toqito.matrix_props import is_commuting

   mat_1 = np.array([[0, 1], [0, 0]])
   mat_2 = np.array([[1, 0], [0, 0]])

   print(is_commuting(mat_1, mat_2))
   ```

   Consider the following pair of matrices:

   \[
       A = \begin{pmatrix}
           1 & 0 & 0 \\
           0 & 1 & 0 \\
           1 & 0 & 2
           \end{pmatrix} \quad \text{and} \quad
       B = \begin{pmatrix}
           2 & 4 & 0 \\
           3 & 1 & 0 \\
           -1 & -4 & 1
           \end{pmatrix}.
   \]

   It may be verified that \(AB = BA = 0\), and therefore \(A\) and
   \(B\) commute.

   ```python exec="1" source="above"
   import numpy as np
   from toqito.matrix_props import is_commuting

   mat_1 = np.array([[1, 0, 0], [0, 1, 0], [1, 0, 2]])
   mat_2 = np.array([[2, 4, 0], [3, 1, 0], [-1, -4, 1]])

   print(is_commuting(mat_1, mat_2))
   ```

   :param mat_1: First matrix to check.
   :param mat_2: Second matrix to check.

   :returns: Return `True` if `mat_1` commutes with `mat_2` and False otherwise.