Macaulay2 » Documentation
Packages » SLPexpressions :: working with gate matrices
next | previous | forward | backward | up | index | toc

# working with gate matrices

Many typical matrix operations can also be performed on gate matrices, such as obtaining entries, number of rows and columns, transpose, and vertical or horizontal concatenation.

    i1 : R = RR[x,y]

    o1 = R

    o1 : PolynomialRing

    i2 : M = gateMatrix basis(3, R)

            3   2      2   3
    o2 = {{x , x y, x*y , y }}

    o2 : GateMatrix

    i3 : numcols M, numrows M

    o3 = (4, 1)

    o3 : Sequence

Rows or entries can be accessed with &#95; or #:

    i4 : M_0

           3   2      2   3
    o4 = {x , x y, x*y , y }

    o4 : List

    i5 : M#0

           3   2      2   3
    o5 = {x , x y, x*y , y }

    o5 : List

    i6 : M#0#0

          3
    o6 = x

    o6 : InputGate

    i7 : entries M

            3   2      2   3
    o7 = {{x , x y, x*y , y }}

    o7 : List

Horizontal (resp. vertical) concatenation is done with | (resp. ||):

    i8 : N = gateMatrix {delete(x^2*y^2, flatten entries basis(4, R))}

            4   3      3   4
    o8 = {{x , x y, x*y , y }}

    o8 : GateMatrix

    i9 : M | N

            3   2      2   3   4   3      3   4
    o9 = {{x , x y, x*y , y , x , x y, x*y , y }}

    o9 : GateMatrix

    i10 : M || N

             3   2      2   3     4   3      3   4
    o10 = {{x , x y, x*y , y }, {x , x y, x*y , y }}

    o10 : GateMatrix

The determinant of a gate matrix is a DetGate:

    i11 : P = transpose M*M

               3    3       3    2        3      2       3    3         2
    o11 = {{((x  * x )), ((x  * x y)), ((x  * x*y )), ((x  * y ))}, {((x y *
          -----------------------------------------------------------------------
           3       2     2        2       2       2     3           2    3
          x )), ((x y * x y)), ((x y * x*y )), ((x y * y ))}, {((x*y  * x )),
          -----------------------------------------------------------------------
               2    2          2      2         2    3         3    3       3
          ((x*y  * x y)), ((x*y  * x*y )), ((x*y  * y ))}, {((y  * x )), ((y  *
          -----------------------------------------------------------------------
           2        3      2       3    3
          x y)), ((y  * x*y )), ((y  * y ))}}

    o11 : GateMatrix

    i12 : det P

    o12 = det|    3    3        3    2         3      2        3    3     |
             | ((x  * x ))   ((x  * x y))   ((x  * x*y ))   ((x  * y ))   |
             |    2     3       2     2        2       2       2     3    |
             | ((x y * x ))  ((x y * x y))  ((x y * x*y ))  ((x y * y ))  |
             |      2    3        2    2         2      2        2    3   |
             | ((x*y  * x )) ((x*y  * x y)) ((x*y  * x*y )) ((x*y  * y )) |
             |    3    3        3    2         3      2        3    3     |
             | ((y  * x ))   ((y  * x y))   ((y  * x*y ))   ((y  * y ))   |

    o12 : DetGate

The native method substitute has also been overloaded to work with gate matrices: the input should be a list of options of the form "A => B" where A is an InputGate and B is a Gate; and the output is another GateMatrix.

## See also

- GateMatrix -- a matrix of Gates

The source of this document is in /build/macaulay2-88fgJW/macaulay2-1.25.11+ds/M2/Macaulay2/packages/SLPexpressions/doc.m2:549:0.