This is HomotopyLieAlgebra.info, produced by Macaulay2, version 1.21

HomotopyLieAlgebra -- Homotopy Lie Algebra of a surjective ring homomorphism
****************************************************************************

Description
===========

If R = S/I, K is the Koszul complex on the generators of I, and A is the
DGAlgebra that is the acyclic closure of K, then the homotopy Lie algebra Pi of
the map S -->> R is defined as in Briggs ****, with underlying vector space the
graded dual of the space spanned by a given set of generators of A.

+--------------------------------------+
|i1 : S = ZZ/101[x,y]                  |
|                                      |
|o1 = S                                |
|                                      |
|o1 : PolynomialRing                   |
+--------------------------------------+
|i2 : R = S/ideal(x^2,y^2,x*y)         |
|                                      |
|o2 = R                                |
|                                      |
|o2 : QuotientRing                     |
+--------------------------------------+
|i3 : KR = koszulComplexDGA(ideal R)   |
|                                      |
|o3 = {Ring => S                      }|
|      Underlying algebra => S[T ..T ] |
|                               1   3  |
|                        2   2         |
|      Differential => {x , y , x*y}   |
|                                      |
|o3 : DGAlgebra                        |
+--------------------------------------+

Since the acyclic closure is infinitely generated, we must specify the maximum
homological degree in which cycles will be killed

+-----------------------------------------------------------------------------+
|i4 : lastCyclesDegree = 4                                                    |
|                                                                             |
|o4 = 4                                                                       |
+-----------------------------------------------------------------------------+
|i5 : A = acyclicClosure(KR, EndDegree => lastCyclesDegree)                   |
|                                                                             |
|o5 = {Ring => S                                                              |
|      Underlying algebra => S[T ..T  ]                                       |
|                               1   25                                        |
|                        2   2                                                |
|      Differential => {x , y , x*y, x*T  - y*T , - y*T  + x*T , T T  + y*T , |
|                                       2      3       1      3   2 3      4  |
|                                                                             |
|o5 : DGAlgebra                                                               |
|-----------------------------------------------------------------------------|
|                                                                             |
|                                                                             |
|                                                                             |
|                                                                             |
|- T T  + x*T  + y*T , - T T  + x*T , - T T  + y*T , - T T  + x*T , - T T  -  |
|   1 2      4      5     1 3      5     2 4      6     3 4      6     3 4    |
|-----------------------------------------------------------------------------|
|                                                                             |
|                                                                             |
|                                                                             |
|                                                                             |
|T T  + y*T , - T T  - T T  + x*T , - T T  + y*T , - T T  + x*T , - T T  +    |
| 2 5      7     1 4    3 5      7     3 5      8     1 5      8     2 6      |
|-----------------------------------------------------------------------------|
|                                                                             |
|                                                                             |
|                                                                             |
|           2                                   2                             |
|y*T , - 50T  - T T  + x*T , - T T  + y*T  , 50T  - T T  + y*T  , T T  + x*T  |
|   9       4    3 6      9     3 6      10     4    2 7      11   4 5      11|
|-----------------------------------------------------------------------------|
|                                                                             |
|                                                                             |
|                                                                             |
|                                             2                               |
|- y*T  , - T T  - T T  + x*T   + y*T  , - 50T  - T T  + x*T  , - T T  - T T  |
|     12     1 6    3 7      10      12       5    1 7      12     4 5    3 7 |
|-----------------------------------------------------------------------------|
|                                                                            }|
|                                                                             |
|                                                                             |
|                                           2                                 |
|- T T  + y*T   + y*T  , - T T  + x*T  , 50T  - T T  + y*T  , - T T  + x*T  } |
|   2 8      12      13     3 8      13     5    3 8      14     1 8      14  |
+-----------------------------------------------------------------------------+

The evaluation of bracketMatrix(A,d,e) gives the matrix of values of
[Pi^d,Pi^e]. Here we are identifying the vector space spanned by the generators
of A with its graded dual by taking the generators produced by the algorithm in
the DGAlgebras package to be self-dual.

+--------------------------------------------+
|i6 : bracketMatrix(A,1,1)                   |
|                                            |
|o6 = | 2T_1 T_3  |                          |
|     | T_3  2T_2 |                          |
|                                            |
|                        2                  2|
|o6 : Matrix (S[T ..T  ])  <--- (S[T ..T  ]) |
|                1   25             1   25   |
+--------------------------------------------+
|i7 : bracketMatrix(A,2,1)                   |
|                                            |
|o7 = | 0   -T_5 |                           |
|     | T_4 0    |                           |
|     | T_5 -T_4 |                           |
|                                            |
|                        3                  2|
|o7 : Matrix (S[T ..T  ])  <--- (S[T ..T  ]) |
|                1   25             1   25   |
+--------------------------------------------+
|i8 : bracketMatrix(A,2,2)                   |
|                                            |
|o8 = | 0   -T_7 -T_8 |                      |
|     | T_7 0    T_6  |                      |
|     | T_8 -T_6 0    |                      |
|                                            |
|                        3                  3|
|o8 : Matrix (S[T ..T  ])  <--- (S[T ..T  ]) |
|                1   25             1   25   |
+--------------------------------------------+

Note that bracketMatrix(A,d,e) is antisymmetric in d,e if one of them is even,
and symmetric in d,e if both are odd

+-----------------------------------------------------------+
|i9 : bracketMatrix(A,1,1) - transpose bracketMatrix(A,1,1) |
|                                                           |
|o9 = 0                                                     |
|                                                           |
|                        2                  2               |
|o9 : Matrix (S[T ..T  ])  <--- (S[T ..T  ])                |
|                1   25             1   25                  |
+-----------------------------------------------------------+
|i10 : bracketMatrix(A,2,1) + transpose bracketMatrix(A,1,2)|
|                                                           |
|o10 = 0                                                    |
|                                                           |
|                         3                  2              |
|o10 : Matrix (S[T ..T  ])  <--- (S[T ..T  ])               |
|                 1   25             1   25                 |
+-----------------------------------------------------------+

References
==========

Briggs, Avramov

Author
======

  * David Eisenbud (see https://www.msri.org/~de ) <de@msri.org>

Version
=======

This documentation describes version 0.9 of HomotopyLieAlgebra.

Source code
===========

The source code from which this documentation is derived is in the file
HomotopyLieAlgebra.m2 (see common/share/Macaulay2/HomotopyLieAlgebra.m2 ).

Exports
=======

  * Functions and commands
      * ad -- matrix of the adjoint action
      * allgens -- List the generators of a given degree
      * bracket -- Computes the Lie product
      * bracketMatrix -- Multiplication matrix of the
        homotopy Lie algebra
  * Methods
      * "ad(DGAlgebra,RingElement,ZZ)" -- see ad, -- matrix of the
        adjoint action
      * "allgens(DGAlgebra)" -- see allgens, -- List the
        generators of a given degree
      * "allgens(DGAlgebra,ZZ)" -- see allgens, -- List the
        generators of a given degree
      * "bracket(DGAlgebra,List)" -- see bracket, -- Computes
        the Lie product
      * "bracket(DGAlgebra,List,RingElement)" -- see bracket, --
        Computes the Lie product
      * "bracket(DGAlgebra,ZZ,ZZ)" -- see bracket, -- Computes
        the Lie product
      * "bracketMatrix(DGAlgebra,ZZ,ZZ)" -- see bracketMatrix,
        -- Multiplication matrix of the homotopy Lie algebra

For the programmer
==================

The object HomotopyLieAlgebra, is a package (Macaulay2Doc).

ad -- matrix of the adjoint action
**********************************

Synopsis
========

  * Usage:
        M = ad(A,U,e)
  * Inputs:
      * A, an instance of the type DGAlgebra (DGAlgebras),
      * U, a ring element (Macaulay2Doc), linear form in the
        generators of A
      * e, an integer (Macaulay2Doc),
  * Outputs:
      * M, a matrix (Macaulay2Doc), with entries in the ground
        field

Description
===========

The adjoint action of a scalar linear combination of the entries of
allgens(A,d-1) U, regarded as an element of Pi^d, acts by bracket
multiplication with source Pi^e and target Pi^{d+e}. The output is a matrix
whose columns correspond to a generalized row of the output of bracketMatrix.
bracketmatrix

+-----------------------------------------------------------+
|i1 : kk = ZZ/101                                           |
|                                                           |
|o1 = kk                                                    |
|                                                           |
|o1 : QuotientRing                                          |
+-----------------------------------------------------------+
|i2 : S = kk[x,y,z]                                         |
|                                                           |
|o2 = S                                                     |
|                                                           |
|o2 : PolynomialRing                                        |
+-----------------------------------------------------------+
|i3 : R = S/ideal(x^2,y^2,z^2-x*y,x*z, y*z)                 |
|                                                           |
|o3 = R                                                     |
|                                                           |
|o3 : QuotientRing                                          |
+-----------------------------------------------------------+
|i4 : lastCyclesDegree = 4                                  |
|                                                           |
|o4 = 4                                                     |
+-----------------------------------------------------------+
|i5 : KR = koszulComplexDGA(ideal R)                        |
|                                                           |
|o5 = {Ring => S                                     }      |
|      Underlying algebra => S[T ..T ]                      |
|                               1   5                       |
|                        2   2           2                  |
|      Differential => {x , y , - x*y + z , x*z, y*z}       |
|                                                           |
|o5 : DGAlgebra                                             |
+-----------------------------------------------------------+
|i6 : A = acyclicClosure(KR, EndDegree => lastCyclesDegree);|
+-----------------------------------------------------------+
|i7 : d = 1                                                 |
|                                                           |
|o7 = 1                                                     |
+-----------------------------------------------------------+
|i8 : e = 1                                                 |
|                                                           |
|o8 = 1                                                     |
+-----------------------------------------------------------+
|i9 : U = sum (Gd = allgens(A,d-1))                         |
|                                                           |
|o9 = x + y + z                                             |
|                                                           |
|o9 : S[T ..T  ]                                            |
|        1   99                                             |
+-----------------------------------------------------------+
|i10 : ad(A,U,1)                                            |
|                                                           |
|o10 = {1, 2} | 2  0  0 |                                   |
|      {1, 2} | 0  2  0 |                                   |
|      {1, 2} | -1 -1 2 |                                   |
|      {1, 2} | 1  0  1 |                                   |
|      {1, 2} | 0  1  1 |                                   |
|                                                           |
|                         5                  3              |
|o10 : Matrix (S[T ..T  ])  <--- (S[T ..T  ])               |
|                 1   99             1   99                 |
+-----------------------------------------------------------+

The columns of this matrix are the functionals that are the sum of the three
rows of the bracket multiplication table:

+------------------------------------------------+
|i11 : matrix{{1,1,1}}*bracketMatrix(A,d,e)      |
|                                                |
|o11 = | 2T_1-T_3+T_4 2T_2-T_3+T_5 2T_3+T_4+T_5 ||
|                                                |
|                         1                  3   |
|o11 : Matrix (S[T ..T  ])  <--- (S[T ..T  ])    |
|                 1   99             1   99      |
+------------------------------------------------+

See also
========

  * bracketMatrix -- Multiplication matrix of the
    homotopy Lie algebra

Ways to use ad :
================

  * "ad(DGAlgebra,RingElement,ZZ)"

For the programmer
==================

The object ad, is a method function (Macaulay2Doc).

allgens -- List the generators of a given degree
************************************************

Synopsis
========

  * Usage:
        G = allgens A
        Gd = allgens(A,d)
  * Inputs:
      * A, an instance of the type DGAlgebra (DGAlgebras),
      * d, an integer (Macaulay2Doc),
  * Outputs:
      * G, a list (Macaulay2Doc), of all generators of A
      * Gd, a list (Macaulay2Doc), of all generators of homological
        degree d.

Description
===========

The DGAlgebra is constructed as a polynomial ring over a ground ring that is
already a polynomial ring, and allgens includes the generators of the subring.

In invocations of bracket, and bracketMatrix,
it is useful to refer to the generators by reference to the
lists formed by allGens, rather than by trying to name them directly, since
there is a confusion between generators of A.natural and generators of
(flattenRing A.natural)_0.

+-----------------------------------------------------------+
|i1 : kk = ZZ/101                                           |
|                                                           |
|o1 = kk                                                    |
|                                                           |
|o1 : QuotientRing                                          |
+-----------------------------------------------------------+
|i2 : S = kk[x,y,z]                                         |
|                                                           |
|o2 = S                                                     |
|                                                           |
|o2 : PolynomialRing                                        |
+-----------------------------------------------------------+
|i3 : R = S/ideal(x^2,y^2,z^2-x*y,x*z, y*z)                 |
|                                                           |
|o3 = R                                                     |
|                                                           |
|o3 : QuotientRing                                          |
+-----------------------------------------------------------+
|i4 : lastCyclesDegree = 1                                  |
|                                                           |
|o4 = 1                                                     |
+-----------------------------------------------------------+
|i5 : KR = koszulComplexDGA(ideal R)                        |
|                                                           |
|o5 = {Ring => S                                     }      |
|      Underlying algebra => S[T ..T ]                      |
|                               1   5                       |
|                        2   2           2                  |
|      Differential => {x , y , - x*y + z , x*z, y*z}       |
|                                                           |
|o5 : DGAlgebra                                             |
+-----------------------------------------------------------+
|i6 : A = acyclicClosure(KR, EndDegree => lastCyclesDegree);|
+-----------------------------------------------------------+

This causes the generators of the acyclic closure to be computed up to
homological degree lastCycleDegree+1, to kill the cycles in lastCycleDegree. If
S is graded, then the generators of A.natural have degreeLength 2, with the
first component the homological degree.

Since A.natural is a polynomial ring over S, gens A.natural only lists the
generators of homological degree >=1, whereas allgens (made with fl

+-----------------------------------------------------------------------------+
|i7 : g = gens(A.natural)                                                     |
|                                                                             |
|o7 = {T , T , T , T , T , T , T , T , T , T  }                               |
|       1   2   3   4   5   6   7   8   9   10                                |
|                                                                             |
|o7 : List                                                                    |
+-----------------------------------------------------------------------------+
|i8 : g/degree                                                                |
|                                                                             |
|o8 = {{1, 2}, {1, 2}, {1, 2}, {1, 2}, {1, 2}, {2, 3}, {2, 3}, {2, 3}, {2, 3},|
|     ------------------------------------------------------------------------|
|     {2, 3}}                                                                 |
|                                                                             |
|o8 : List                                                                    |
+-----------------------------------------------------------------------------+
|i9 : allgens A                                                               |
|                                                                             |
|o9 = {x, y, z, T , T , T , T , T , T , T , T , T , T  }                      |
|                1   2   3   4   5   6   7   8   9   10                       |
|                                                                             |
|o9 : List                                                                    |
+-----------------------------------------------------------------------------+
|i10 : G3 = allgens(A,2)                                                      |
|                                                                             |
|o10 = {T , T , T , T , T  }                                                  |
|        6   7   8   9   10                                                   |
|                                                                             |
|o10 : List                                                                   |
+-----------------------------------------------------------------------------+
|i11 : G3/degree                                                              |
|                                                                             |
|o11 = {{2, 3}, {2, 3}, {2, 3}, {2, 3}, {2, 3}}                               |
|                                                                             |
|o11 : List                                                                   |
+-----------------------------------------------------------------------------+

Ways to use allgens :
=====================

  * "allgens(DGAlgebra)"
  * "allgens(DGAlgebra,ZZ)"

For the programmer
==================

The object allgens, is a method function (Macaulay2Doc).

bracket -- Computes the Lie product
***********************************

Synopsis
========

  * Usage:
        F = bracket(A,L,T)
        F = bracket(A,L)
        H = bracket(A,d,e)
  * Inputs:
      * A, an instance of the type DGAlgebra (DGAlgebras),
      * L, a list (Macaulay2Doc), list of two generators of A
      * T, a ring element (Macaulay2Doc), generator of A
      * d, an integer (Macaulay2Doc),
      * e, an integer (Macaulay2Doc),
  * Outputs:
      * F, a ring element (Macaulay2Doc), linear form in A
      * H, a hash table (Macaulay2Doc), gives all the products
        between (dual) elements of degrees d,e

Description
===========

Given a factor ring R = S/I, we take A to be the acyclic closure, up to some
degree n, of the Koszul complex on the generators of I. The underlying algebra
An := A.natural is thus a free algebra over S on generators T_i of various
homological and internal degrees.

The Homotopy Lie algebra of the map S ->> R is the graded dual of the space of
linear forms Lin(A) of A. Since we obtain A together with a set of generators
T_i, we identify the Lie algebra with space of linear forms, using the T_i as a
self-dual basis. Thus we express the bracket product of two linear forms as
another linear form. This inner product on the linear forms of degree d extends
naturally to an inner product between Lin(A)**Lin(A) and the quadratic forms of
A. This inner product has signs coming from the homological grading, and is the
only delicate part of the implementation.

The bracket function is the workhorse of this collection of routines. Suppose
that f,g are three linear forms in the generators of A homogeneous in the
homological grading, of homological degrees d-1, e-1 respectively, which we
regard as dual basis elements of Pi^d and Pi^e, graded components of the
homotopy Lie algebra Pi. We can compute the bracket product [f,g] as an element
of Pi^{d+e}, or its action on a linear form F that is homogeneous of
homological degree d+e-1 via the inner product<f**g, d(F)_2>, where d is the
differential of A. The calls bracket(A,{f,g}) and bracket(A, {f,g}, F) compute
these products

In the following example, we use the function allgens(A,d) to list the
generators of A of homological degree d:

+-----------------------------------------------------------------------------+
|i1 : kk = ZZ/101                                                             |
|                                                                             |
|o1 = kk                                                                      |
|                                                                             |
|o1 : QuotientRing                                                            |
+-----------------------------------------------------------------------------+
|i2 : S = kk[x,y,z]                                                           |
|                                                                             |
|o2 = S                                                                       |
|                                                                             |
|o2 : PolynomialRing                                                          |
+-----------------------------------------------------------------------------+
|i3 : R = S/ideal(x^2,y^2,z^2-x*y,x*z, y*z)                                   |
|                                                                             |
|o3 = R                                                                       |
|                                                                             |
|o3 : QuotientRing                                                            |
+-----------------------------------------------------------------------------+
|i4 : lastCyclesDegree = 4                                                    |
|                                                                             |
|o4 = 4                                                                       |
+-----------------------------------------------------------------------------+
|i5 : KR = koszulComplexDGA(ideal R)                                          |
|                                                                             |
|o5 = {Ring => S                                     }                        |
|      Underlying algebra => S[T ..T ]                                        |
|                               1   5                                         |
|                        2   2           2                                    |
|      Differential => {x , y , - x*y + z , x*z, y*z}                         |
|                                                                             |
|o5 : DGAlgebra                                                               |
+-----------------------------------------------------------------------------+
|i6 : A = acyclicClosure(KR, EndDegree => lastCyclesDegree);                  |
+-----------------------------------------------------------------------------+
|i7 : p2 = allgens(A,1) -- dual generators of Pi^2                            |
|                                                                             |
|o7 = {T , T , T , T , T }                                                    |
|       1   2   3   4   5                                                     |
|                                                                             |
|o7 : List                                                                    |
+-----------------------------------------------------------------------------+
|i8 : p3 = allgens(A,2) -- dual generators of Pi^3                            |
|                                                                             |
|o8 = {T , T , T , T , T  }                                                   |
|       6   7   8   9   10                                                    |
|                                                                             |
|o8 : List                                                                    |
+-----------------------------------------------------------------------------+
|i9 : a5 = allgens(A,4) -- generators of A of homological degree 5            |
|                                                                             |
|o9 = {T  , T  , T  , T  , T  , T  , T  , T  , T  , T  , T  , T  , T  , T  ,  |
|       21   22   23   24   25   26   27   28   29   30   31   32   33   34   |
|     ------------------------------------------------------------------------|
|     T  , T  , T  , T  , T  , T  , T  , T  , T  , T  }                       |
|      35   36   37   38   39   40   41   42   43   44                        |
|                                                                             |
|o9 : List                                                                    |
+-----------------------------------------------------------------------------+
|i10 : bracket(A, {sum p2, sum p3})                                           |
|                                                                             |
|o10 = - 2T   + T   + T   - T   + 2T   - T   - 2T   - 3T   - 2T   - T   - T   |
|          21    22    23    24     25    26     27     28     29    30    31 |
|      -----------------------------------------------------------------------|
|      + 2T   + 3T   + T   + T   - 2T   - T   - T   - 2T   - 2T   + 2T        |
|          32     33    34    35     36    37    38     40     42     43      |
|                                                                             |
|o10 : S[T ..T  ]                                                             |
|         1   99                                                              |
+-----------------------------------------------------------------------------+
|i11 : bracket(A,{sum p2, sum p3}, sum a5)                                    |
|                                                                             |
|o11 = -8                                                                     |
|                                                                             |
|o11 : S[T ..T  ]                                                             |
|         1   99                                                              |
+-----------------------------------------------------------------------------+

The other invocation of bracket produces a HashTable displaying all the bracket
products of elements of Pi^d and Pi^e as functions on the generators of
homological degree d+e-1 of A:

+-----------------------------------------------------------------------------+
|i12 : H = bracket(A,2,3);                                                    |
|(5, 5, 24)                                                                   |
|{T  , T  , T  , T  , T  , T  , T  , T  , T  , T  , T  , T  , T  , T  , T  ,  |
|  21   22   23   24   25   26   27   28   29   30   31   32   33   34   35   |
|-----------------------------------------------------------------------------|
|T  , T  , T  , T  , T  , T  , T  , T  , T  }                                 |
| 36   37   38   39   40   41   42   43   44                                  |
+-----------------------------------------------------------------------------+
|i13 : #keys H                                                                |
|                                                                             |
|o13 = 600                                                                    |
+-----------------------------------------------------------------------------+
|i14 : H' = select(keys H, k->H#k != 0);                                      |
+-----------------------------------------------------------------------------+
|i15 : H'                                                                     |
|                                                                             |
|o15 = {({T , T }, T T  - z*T   + y*T  ), ({T , T }, - T T  - T T  - T T  +   |
|          3   9    3 9      15      17      3   6      3 6    5 7    1 8     |
|      -----------------------------------------------------------------------|
|      z*T   + x*T  ), ({T , T }, - T T  + x*T  ), ({T , T }, - T T  - T T  + |
|         12      14      1   7      1 7      13      5   9      2 8    5 9   |
|      -----------------------------------------------------------------------|
|      y*T  ), ({T , T  }, - T T  + T T   - z*T   + x*T  ), ({T , T }, - T T  |
|         15      3   10      4 8    3 10      18      19      2   7      2 7 |
|      -----------------------------------------------------------------------|
|      - T T  + y*T   + z*T  ), ({T , T }, - T T  + T T   - z*T   + x*T  ),   |
|         4 8      12      14      4   8      4 8    3 10      18      19     |
|      -----------------------------------------------------------------------|
|      ({T , T  }, - T T  - T T   + y*T  ), ({T , T  }, - T T   + x*T  ),     |
|         2   10      5 8    2 10      19      4   10      4 10      18       |
|      -----------------------------------------------------------------------|
|      ({T , T }, - T T  - T T   + y*T  ), ({T , T }, T T  + x*T   - z*T  ),  |
|         5   8      5 8    2 10      19      3   8    3 8      15      17    |
|      -----------------------------------------------------------------------|
|      ({T , T }, - T T  - T T  - T T  + z*T   + x*T  ), ({T , T }, T T  -    |
|         1   8      3 6    5 7    1 8      12      14      4   9    4 9      |
|      -----------------------------------------------------------------------|
|      T T   - z*T   + z*T  ), ({T , T }, - T T  - T T  + y*T  ), ({T , T }, -|
|       5 10      17      19      2   8      2 8    5 9      15      5   7    |
|      -----------------------------------------------------------------------|
|      T T  - T T  - T T  + z*T   + x*T  ), ({T , T }, T T  + T T  + T T  +   |
|       3 6    5 7    1 8      12      14      4   9    2 6    3 8    4 9     |
|      -----------------------------------------------------------------------|
|      y*T   - z*T  ), ({T , T  }, T T  + T T   - z*T   + y*T  ), ({T , T },  |
|         14      17      3   10    5 6    3 10      18      20      5   6    |
|      -----------------------------------------------------------------------|
|      T T  + T T   - z*T   + y*T  ), ({T , T  }, - T T  - T T   + z*T   +    |
|       5 6    3 10      18      20      4   10      5 7    4 10      12      |
|      -----------------------------------------------------------------------|
|      z*T  ), ({T , T }, - T T  - T T  + x*T  ), ({T , T }, T T  + T T  -    |
|         20      1   6      1 6    4 7      11      3   9    5 8    3 9      |
|      -----------------------------------------------------------------------|
|      z*T   + x*T  ), ({T , T }, T T  + T T  - z*T   + y*T  ), ({T , T  }, - |
|         15      16      4   6    4 6    3 7      11      13      5   10     |
|      -----------------------------------------------------------------------|
|      T T   + y*T  ), ({T , T }, T T  - T T   + x*T  ), ({T , T }, - T T  -  |
|       5 10      18      4   6    4 6    1 10      20      4   7      1 6    |
|      -----------------------------------------------------------------------|
|      T T  + x*T  ), ({T , T }, T T  + T T  + T T  + y*T   - z*T  ), ({T ,   |
|       4 7      11      2   6    2 6    3 8    4 9      14      17      5    |
|      -----------------------------------------------------------------------|
|      T  }, T T  - T T   - z*T   + z*T  ), ({T , T }, T T  + T T  + T T  +   |
|       10    4 9    5 10      17      19      3   8    2 6    3 8    4 9     |
|      -----------------------------------------------------------------------|
|      y*T   - z*T  ), ({T , T }, T T  + y*T   - z*T  ), ({T , T }, - T T  -  |
|         14      17      3   6    3 6      11      12      5   7      5 7    |
|      -----------------------------------------------------------------------|
|      T T   + z*T   + z*T  ), ({T , T }, T T  + T T  - z*T   + y*T  ), ({T , |
|       4 10      12      20      3   7    4 6    3 7      11      13      2  |
|      -----------------------------------------------------------------------|
|      T }, - T T  + y*T  ), ({T , T }, - T T  - T T  - z*T   + x*T  ), ({T , |
|       9      2 9      16      1   9      5 6    1 9      14      17      4  |
|      -----------------------------------------------------------------------|
|      T }, - T T  + z*T  ), ({T , T  }, T T  - T T   + x*T  ), ({T , T }, -  |
|       7      4 7      13      1   10    4 6    1 10      20      5   9      |
|      -----------------------------------------------------------------------|
|      T T  + z*T  ), ({T , T }, T T  - z*T   + x*T  ), ({T , T }, - T T  -   |
|       5 9      16      3   7    3 7      11      12      5   6      5 6     |
|      -----------------------------------------------------------------------|
|      T T  - z*T   + x*T  ), ({T , T }, T T  + T T  - z*T   + x*T  ), ({T ,  |
|       1 9      14      17      5   8    5 8    3 9      15      16      4   |
|      -----------------------------------------------------------------------|
|      T }, - T T  - T T  + y*T   + z*T  )}                                   |
|       8      2 7    4 8      12      14                                     |
|                                                                             |
|o15 : List                                                                   |
+-----------------------------------------------------------------------------+
|i16 : H#(H'_0)                                                               |
|                                                                             |
|o16 = 1                                                                      |
|                                                                             |
|o16 : S[T ..T  ]                                                             |
|         1   99                                                              |
+-----------------------------------------------------------------------------+

From this we see that [T_5, T_6] sends T_37 to -1 in kk.

Another, often simpler view of the pairing is given by bracketMatrix,
where the rows and columns correspond to the generators of Pi^d
and Pi^e, and the entries are the bracket products, interpreted as elements of
Pi^{d+e}. Note the anti-symmetry, which holds when d or e are even and the
symmetry in the case both are odd.

+---------------------------------------------+
|i17 : bracketMatrix(A,1,2)                   |
|                                             |
|o17 = | 0    -T_8 -T_6 -T_7 -T_10 |          |
|      | -T_6 0    -T_8 T_10 -T_9  |          |
|      | T_7  T_9  0    T_6  T_8   |          |
|                                             |
|                         3                  5|
|o17 : Matrix (S[T ..T  ])  <--- (S[T ..T  ]) |
|                 1   99             1   99   |
+---------------------------------------------+
|i18 : bracketMatrix(A,2,1)                   |
|                                             |
|o18 = | 0    T_6   -T_7 |                    |
|      | T_8  0     -T_9 |                    |
|      | T_6  T_8   0    |                    |
|      | T_7  -T_10 -T_6 |                    |
|      | T_10 T_9   -T_8 |                    |
|                                             |
|                         5                  3|
|o18 : Matrix (S[T ..T  ])  <--- (S[T ..T  ]) |
|                 1   99             1   99   |
+---------------------------------------------+
|i19 : bracketMatrix(A,1,1)                   |
|                                             |
|o19 = | 2T_1 -T_3 T_4  |                     |
|      | -T_3 2T_2 T_5  |                     |
|      | T_4  T_5  2T_3 |                     |
|                                             |
|                         3                  3|
|o19 : Matrix (S[T ..T  ])  <--- (S[T ..T  ]) |
|                 1   99             1   99   |
+---------------------------------------------+

See also
========

  * allgens -- List the generators of a given degree
  * bracketMatrix -- Multiplication matrix of the
    homotopy Lie algebra

Ways to use bracket :
=====================

  * "bracket(DGAlgebra,List)"
  * "bracket(DGAlgebra,List,RingElement)"
  * "bracket(DGAlgebra,ZZ,ZZ)"

For the programmer
==================

The object bracket, is a method function (Macaulay2Doc).

bracketMatrix -- Multiplication matrix of the homotopy Lie algebra
******************************************************************

Synopsis
========

  * Usage:
        M = bracketMatrix(A,d,e)
  * Inputs:
      * A, an instance of the type DGAlgebra (DGAlgebras),
        first part of the acyclic closure of a Koszul complex
      * d, an integer (Macaulay2Doc),
      * e, an integer (Macaulay2Doc),
  * Outputs:
      * M, a matrix (Macaulay2Doc), of linear forms in the
        generators of A

Description
===========

This function implements the multiplication table of the degree d and degree e
components of the homotopy Lie algebra Pi. The entries of the matrix are linear
forms of homological degree d+e+1, interpreted as generators of Pi^{d+e}. See
bracket, for more details.

+-----------------------------------------------------------+
|i1 : kk = ZZ/101                                           |
|                                                           |
|o1 = kk                                                    |
|                                                           |
|o1 : QuotientRing                                          |
+-----------------------------------------------------------+
|i2 : S = kk[x,y,z]                                         |
|                                                           |
|o2 = S                                                     |
|                                                           |
|o2 : PolynomialRing                                        |
+-----------------------------------------------------------+
|i3 : R = S/ideal(x^2,y^2,z^2-x*y,x*z, y*z)                 |
|                                                           |
|o3 = R                                                     |
|                                                           |
|o3 : QuotientRing                                          |
+-----------------------------------------------------------+
|i4 : lastCyclesDegree = 4                                  |
|                                                           |
|o4 = 4                                                     |
+-----------------------------------------------------------+
|i5 : KR = koszulComplexDGA(ideal R)                        |
|                                                           |
|o5 = {Ring => S                                     }      |
|      Underlying algebra => S[T ..T ]                      |
|                               1   5                       |
|                        2   2           2                  |
|      Differential => {x , y , - x*y + z , x*z, y*z}       |
|                                                           |
|o5 : DGAlgebra                                             |
+-----------------------------------------------------------+
|i6 : A = acyclicClosure(KR, EndDegree => lastCyclesDegree);|
+-----------------------------------------------------------+
|i7 : p1 = allgens(A,0) -- dual generators of Pi^1          |
|                                                           |
|o7 = {x, y, z}                                             |
|                                                           |
|o7 : List                                                  |
+-----------------------------------------------------------+
|i8 : p2 = allgens(A,1) -- dual generators of Pi^3          |
|                                                           |
|o8 = {T , T , T , T , T }                                  |
|       1   2   3   4   5                                   |
|                                                           |
|o8 : List                                                  |
+-----------------------------------------------------------+
|i9 : p3 = allgens(A,2) -- dual generators of Pi^4          |
|                                                           |
|o9 = {T , T , T , T , T  }                                 |
|       6   7   8   9   10                                  |
|                                                           |
|o9 : List                                                  |
+-----------------------------------------------------------+
|i10 : bracketMatrix(A,2,1)                                 |
|                                                           |
|o10 = | 0    T_6   -T_7 |                                  |
|      | T_8  0     -T_9 |                                  |
|      | T_6  T_8   0    |                                  |
|      | T_7  -T_10 -T_6 |                                  |
|      | T_10 T_9   -T_8 |                                  |
|                                                           |
|                         5                  3              |
|o10 : Matrix (S[T ..T  ])  <--- (S[T ..T  ])               |
|                 1   99             1   99                 |
+-----------------------------------------------------------+

See also
========

  * bracket -- Computes the Lie product
  * allgens -- List the generators of a given degree

Ways to use bracketMatrix :
===========================

  * "bracketMatrix(DGAlgebra,ZZ,ZZ)"

For the programmer
==================

The object bracketMatrix, is a method function (Macaulay2Doc).