This is Brackets.info, produced by Macaulay2, version 1.25.05

Brackets -- Brackets, Grassmann-Cayley Algebra, and Projective Geometry
***********************************************************************

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

Fix integers $n \ge d \ge 1,$ and let $X = (x_{i j})$ be an $n\times d$ matrix
of distinct variables in the polynomial ring $k [x_{i j}]$ over a fixed field
$k.$ Think of each row of $X$ is a point in the projective space
$\mathbb{P}^{d-1}$ of dimension $(d-1)$ over $k,$ so that $X$ as represents a
configuration of $n$ points in this projective space. Many interesting
geometric properties of this point configuration can be expressed in terms of
the maximal minors of $X.$

For notational convenience, it is common to write these minors in bracket
notation. A bracket is an expression $[\lambda_1 \lambda_2 \ldots \lambda_d]$
representing the minor of $X$ whose rows are given by indices $1\le \lambda_1 <
\lambda_2 < \ldots < \lambda_d \le n.$

Formally, we may consider the map of polynomial rings $$\psi_{n,d} : k \left[
[\lambda_{i_1} \cdots \lambda_{i_d}] \mid 1 \le i_1 < \ldots < i_d \le n
\right] \to k [X],$$ $$ [\lambda_{i_1} \cdots \lambda_{i_d}] \mapsto \det
\begin{pmatrix} x_{i_1, 1} & \cdots & x_{i_1, d} \\ \vdots & & \vdots & \\
x_{i_d 1} & \cdots & x_{i_d d}\end{pmatrix}. $$

The classical bracket ring $B_{n,d}$ is the image of this map. This is the
homogeneous coordinate ring of the Grassmannian of $(n-1)$-dimensional planes
in $\mathbb{P}^{d-1}$ under its Plücker embedding.

Acknowledgement
===============

We thank Thomas Yahl for helpful contributions, and the organizers of the 2023
Macaulay2 workshop in Minneapolis, IMA staff, and acknowledge support from the
National Science Foundation grant DMS 2302476.

References
==========

Sturmfels, Bernd. Algorithms in invariant theory. Springer Science & Business
Media, 2008.

Authors
=======

  * Dalton Bidleman (see  ) <deb0036@auburn.edu>
  * Tim Duff (see https://timduff35.github.io/timduff35/ ) <tduff@missouri.edu>
  * Jack Kendrick (see  ) <jackgk@uw.edu>
  * Michael Zeng (see  ) <zengrf@uw.edu>

Version
=======

This documentation describes version 0.1 of Brackets.

Citation
========

If you have used this package in your research, please cite it as follows:

+-----------------------------------------------------------------------------+
|@misc{BracketsSource,                                                        |
|  title = {{Brackets: Brackets, Grassmann-Cayley Algebra, and Projective Geom|
|  author = {Dalton Bidleman and Tim Duff and Jack Kendrick and Michael Zeng},|
|  howpublished = {A \emph{Macaulay2} package available at                    |
|    \url{https://github.com/Macaulay2/M2/tree/master/M2/Macaulay2/packages}} |
|}                                                                            |
|-----------------------------------------------------------------------------|
|etry. Version~0.1}},                                                         |
+-----------------------------------------------------------------------------+

Exports
=======

  * Types
      * Bracket
      * BracketRing
      * GCAlgebra
      * GCExpression
  * Functions and commands
      * bracketRing -- Constructor for bracket rings
      * gc -- Constructor for Grassmann-Cayley algebras.
      * normalForm -- Represent a bracket polynomial in a
        normal form with respect to a Groebner basis
      * toBracketPolynomial -- Represent an
        invariant polynomial as a polynomial in brackets
  * Methods
      * AbstractGCRing Array (missing documentation)
      * Array _ AbstractGCRing (missing documentation)
      * "bracketRing(AbstractGCRing)" -- see bracketRing, --
        Constructor for bracket rings
      * "bracketRing(BracketRing)" -- see bracketRing, --
        Constructor for bracket rings
      * "bracketRing(GCAlgebra)" -- see bracketRing, --
        Constructor for bracket rings
      * "bracketRing(GCExpression)" -- see bracketRing, --
        Constructor for bracket rings
      * "bracketRing(VisibleList,ZZ)" -- see bracketRing, --
        Constructor for bracket rings
      * "bracketRing(ZZ,ZZ)" -- see bracketRing, --
        Constructor for bracket rings
      * coefficients(GCExpression) (missing documentation)
      * commonRing(GCExpression,GCExpression) (missing documentation)
      * degree(GCExpression) (missing documentation)
      * factor(GCExpression) (missing documentation)
      * "gc(VisibleList,ZZ)" -- see gc, -- Constructor for
        Grassmann-Cayley algebras.
      * GCExpression * GCExpression (missing documentation)
      * GCExpression * Number (missing documentation)
      * GCExpression * RingElement (missing documentation)
      * GCExpression + GCExpression (missing documentation)
      * GCExpression - GCExpression (missing documentation)
      * GCExpression ^ GCExpression, --
        Shuffle product in the Grassmann-Cayley Algebra
      * GCExpression ^ RingElement (missing documentation)
      * GCExpression ^ ZZ (missing documentation)
      * GCExpression _ BracketRing, --
        Substituting top-degree Grassmann-Cayley elements into the bracket ring
      * GCExpression _ GCAlgebra (missing documentation)
      * generators(AbstractGCRing) (missing documentation)
      * ideal(BracketRing) (missing documentation)
      * matrix(AbstractGCRing,List) (missing documentation)
      * matrix(BracketRing) (missing documentation)
      * net(AbstractGCRing) (missing documentation)
      * net(BracketRing) (missing documentation)
      * net(GCExpression) (missing documentation)
      * "normalForm(GCExpression)" -- see normalForm, --
        Represent a bracket polynomial in a normal form with respect to a
        Groebner basis
      * Number * GCExpression (missing documentation)
      * numColumns(BracketRing) (missing documentation)
      * numgens(AbstractGCRing) (missing documentation)
      * numRows(BracketRing) (missing documentation)
      * ring(AbstractGCRing) (missing documentation)
      * ring(GCExpression) (missing documentation)
      * RingElement * GCExpression (missing documentation)
      * RingElement ^ GCExpression (missing documentation)
      * RingElement _ AbstractGCRing, --
        Substituting ring elements into bracket rings and GC algebras
      * terms(GCExpression) (missing documentation)
      * "toBracketPolynomial(RingElement,BracketRing)" -- see
        toBracketPolynomial, -- Represent an invariant
        polynomial as a polynomial in brackets
      * use(AbstractGCRing) (missing documentation)
      * ZZ _ AbstractGCRing (missing documentation)

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

The object Brackets, is a package (Macaulay2Doc),
defined in Brackets.m2.

-------------------------------------------------------------------------------

The source of this document is in Brackets.m2:396:0.

Bracket
*******

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

In a BracketRing, a Bracket represents a maximal minor of the matrix of
coordinates of a configuration of points in a projective space. The example
below illustrates this for a configuration of 5 points in the projective space
$\mathbb{P}^2$.

+-----------------------------------------------------------------------------+
|i1 : B = bracketRing(5,3)                                                    |
|                                                                             |
|o1 = B                                                                       |
|      5,3                                                                    |
|                                                                             |
|o1 : BracketRing                                                             |
+-----------------------------------------------------------------------------+
|i2 : [1 2 3]_B                                                               |
|                                                                             |
|o2 = [123]                                                                   |
|                                                                             |
|o2 : Bracket                                                                 |
+-----------------------------------------------------------------------------+
|i3 : X = matrix B                                                            |
|                                                                             |
|o3 = {-1} | x_(1,1) x_(1,2) x_(1,3) |                                        |
|     {-1} | x_(2,1) x_(2,2) x_(2,3) |                                        |
|     {-1} | x_(3,1) x_(3,2) x_(3,3) |                                        |
|     {-1} | x_(4,1) x_(4,2) x_(4,3) |                                        |
|     {-1} | x_(5,1) x_(5,2) x_(5,3) |                                        |
|                                                                             |
|                                                                             |
|o3 : Matrix (QQ[x   ..x   , y     , y     , y     , y     , y     , y     ,  |
|                 1,1   5,3   [345]   [245]   [235]   [234]   [145]   [135]   |
|-----------------------------------------------------------------------------|
|                                5                                            |
|y     , y     , y     , y     ])  <-- (QQ[x   ..x   , y     , y     , y     ,|
| [134]   [125]   [124]   [123]             1,1   5,3   [345]   [245]   [235] |
|-----------------------------------------------------------------------------|
|                                                        3                    |
|y     , y     , y     , y     , y     , y     , y     ])                     |
| [234]   [145]   [135]   [134]   [125]   [124]   [123]                       |
+-----------------------------------------------------------------------------+
|i4 : toBracketPolynomial(det X^{0,1,2},B)                                    |
|                                                                             |
|o4 = [123]                                                                   |
|                                                                             |
|o4 : GCExpression                                                            |
+-----------------------------------------------------------------------------+

See also BracketRing, and toBracketPolynomial.

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

The object Bracket, is a type (Macaulay2Doc), with
ancestor classes GCExpression, < HashTable (Macaulay2Doc)
< Thing (Macaulay2Doc).

-------------------------------------------------------------------------------

The source of this document is in Brackets.m2:518:0.

BracketRing
***********

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

An object of class BracketRing represents the bracket ring $B_{n,d}$. For
example, let $n=4, d=2,$ so that $$X=\begin{pmatrix} x_{1,1}&x_{1,2}\\
x_{2,1}&x_{2,2}\\ x_{3,1}&x_{3,2}\\ x_{4,1}&x_{4,2}\\ \end{pmatrix}.$$ There
are $6=\binom{4}{2}$ brackets, and the matrix $X$ represents a configuration of
$6$ points on the projective line $\mathbb{P}^1.$ These brackets are not
algebraically independent, as they satisfy the quadratic Plücker relation, $$
[1 2] [3 4] - [1 3] [2 4] + [1 4] [2 3] = 0. $$ Some basic syntax for working
with objects of class BracketRing is illustrated in the documentation page
bracketRing.

Methods that use an object of class BracketRing:
================================================

  * "bracketRing(BracketRing)" -- see bracketRing, --
    Constructor for bracket rings
  * GCExpression _ BracketRing, --
    Substituting top-degree Grassmann-Cayley elements into the bracket ring
  * ideal(BracketRing) (missing documentation)
  * matrix(BracketRing) (missing documentation)
  * net(BracketRing) (missing documentation)
  * numColumns(BracketRing) (missing documentation)
  * numRows(BracketRing) (missing documentation)
  * "toBracketPolynomial(RingElement,BracketRing)" -- see
    toBracketPolynomial, -- Represent an invariant
    polynomial as a polynomial in brackets

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

The object BracketRing, is a type (Macaulay2Doc),
with ancestor classes AbstractGCRing (missing
documentation) < HashTable (Macaulay2Doc) < Thing (Macaulay2Doc).

-------------------------------------------------------------------------------

The source of this document is in Brackets.m2:417:0.

bracketRing -- Constructor for bracket rings
********************************************

  * Usage:
        B = bracketRing(n, d)
        B = bracketRing(vectorSymbols, d)
        B = bracketRing B'
        B = bracketRing G
  * Inputs:
      * B', an instance of the type BracketRing,
      * G, an instance of the type GCAlgebra,
      * vectorSymbols, a list (Macaulay2Doc),
      * n, an integer (Macaulay2Doc),
      * d, an integer (Macaulay2Doc),
  * Optional inputs (Macaulay2Doc),:
      * CoefficientRing (missing documentation) => ..., default value QQ,
      * Strategy (missing documentation) => ..., default value GroebnerBasis,
      * Variables (missing documentation) => ..., default value {},
  * Outputs:
      * B, an instance of the type BracketRing,

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

To construct the bracket ring $B_{n,d}$ it is enough to specify two integers.
In that case, each bracket will contain $n$ symbols which are integers between
$1$ and $d.$

+------------------------------------------+
|i1 : B = bracketRing(6, 3)                |
|                                          |
|o1 = B                                    |
|      6,3                                 |
|                                          |
|o1 : BracketRing                          |
+------------------------------------------+
|i2 : T = [1 4 5]_B * [1 5 6]_B * [2 3 4]_B|
|                                          |
|o2 = [234]*[156]*[145]                    |
|                                          |
|o2 : GCExpression                         |
+------------------------------------------+

One may also provide a visible list (Macaulay2Doc), of $n$
symbols.

+------------------------------+
|i3 : B2 = bracketRing(a..f, 3)|
|                              |
|o3 = B                        |
|      6,3                     |
|                              |
|o3 : BracketRing              |
+------------------------------+

Additionally, brackets can be interpreted as the top-degree elements of the
Grassmann-Cayley algebra.

+-----------------------------------------------------------+
|i4 : G = gc(a..f, 3)                                       |
|                                                           |
|o4 = Grassmann-Cayley Algebra generated by 1-extensors a..f|
|                                                           |
|o4 : GCAlgebra                                             |
+-----------------------------------------------------------+
|i5 : B3 = bracketRing G                                    |
|                                                           |
|o5 = B                                                     |
|      6,3                                                  |
|                                                           |
|o5 : BracketRing                                           |
+-----------------------------------------------------------+

See also BracketRing.

Ways to use bracketRing:
========================

  * "bracketRing(AbstractGCRing)"
  * "bracketRing(BracketRing)"
  * "bracketRing(GCAlgebra)"
  * "bracketRing(GCExpression)"
  * "bracketRing(VisibleList,ZZ)"
  * "bracketRing(ZZ,ZZ)"

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

The object bracketRing, is a method function with options (Macaulay2Doc).

-------------------------------------------------------------------------------

The source of this document is in Brackets.m2:461:0.

gc -- Constructor for Grassmann-Cayley algebras.
************************************************

  * Usage:
        G = gc(vectorSymbols, d)
  * Inputs:
      * vectorSymbols, a list (Macaulay2Doc),
      * d, an integer (Macaulay2Doc),
  * Optional inputs (Macaulay2Doc),:
      * CoefficientRing (missing documentation) => ..., default value QQ,
      * Strategy (missing documentation) => ..., default value GroebnerBasis,
  * Outputs:
      * G, an instance of the type GCAlgebra,

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

To construct a Grassmann-Cayley algebra specify a a visible list (Macaulay2Doc),
of $n$ symbols, representing $n$ points in a
projective space $\mathbb{P}^{d-1}$, and the integer $d.$

+-----------------------------------------------------------+
|i1 : G = gc(a .. f, 3)                                     |
|                                                           |
|o1 = Grassmann-Cayley Algebra generated by 1-extensors a..f|
|                                                           |
|o1 : GCAlgebra                                             |
+-----------------------------------------------------------+

See also GCAlgebra.

Ways to use gc:
===============

  * "gc(VisibleList,ZZ)"

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

The object gc, is a method function with options (Macaulay2Doc).

-------------------------------------------------------------------------------

The source of this document is in Brackets.m2:501:0.

GCAlgebra
*********

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

An object of class GCAlgebra represents a Grassmann-Cayley algebra. The
Grassmann-Cayley algebra may be viewed as an algebra of linear subspaces of
$\mathbb{P}^{d−1}.$ In this algebra, there are two operations which correspond
to the join and meet of subspaces. We denote these operators by * and ^,
respectively. The first operator is simply multiplication in a skew-commutative
polynomial ring $\mathbb{C}\langle a_1, . . . , a_n\rangle.$ An algebraic
formula for the meet operator is more complicated, but it can be defined using
the so-called shuffle product.

As a $k-$vector space, the Grassmann-Cayley algebra has a direct-sum
decomposition $$\oplus_{k=0}^d\Lambda^k(a_1, \ldots, a_n)$$ where
$\Lambda^k(a_1,\ldots, a_n)$ is the vector space of extensors of the form
$a_{i_1}\cdots a_{i_k}.$ We may identify $\Lambda^d(a_1, \ldots, a_n)\cong
B_{n,d}$ with the BracketRing.

Methods that use an object of class GCAlgebra:
==============================================

  * "bracketRing(GCAlgebra)" -- see bracketRing, --
    Constructor for bracket rings
  * GCExpression _ GCAlgebra (missing documentation)

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

The object GCAlgebra, is a type (Macaulay2Doc),
with ancestor classes AbstractGCRing (missing documentation) < HashTable (Macaulay2Doc)
< Thing (Macaulay2Doc).

-------------------------------------------------------------------------------

The source of this document is in Brackets.m2:479:0.

GCExpression
************

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

A general data type for representing elements of bracket rings and
Grassmann-Cayley algebras. GC expressions can be assembled into matrices, and
they support a number of the usual arithmetic operations: addition,
multiplication, and scalar multiplication.

Multiplication on the Grassmann-Cayley algebra is the usual exterior product.
This represents the span, or join, of linear subspaces in a given vector space.

The Grassmann-Cayley algebra is also endowed with a "shuffle product",
representing the intersection or meet of linear subspaces. This is implemented
in GCExpression ^ GCExpression.

Types of GCExpression:
======================

  * Bracket

Methods that use an object of class GCExpression:
=================================================

  * "bracketRing(GCExpression)" -- see bracketRing, --
    Constructor for bracket rings
  * coefficients(GCExpression) (missing documentation)
  * commonRing(GCExpression,GCExpression) (missing documentation)
  * degree(GCExpression) (missing documentation)
  * factor(GCExpression) (missing documentation)
  * GCExpression * GCExpression (missing documentation)
  * GCExpression * Number (missing documentation)
  * GCExpression * RingElement (missing documentation)
  * GCExpression + GCExpression (missing documentation)
  * GCExpression - GCExpression (missing documentation)
  * GCExpression ^ GCExpression -- Shuffle
    product in the Grassmann-Cayley Algebra
  * GCExpression ^ RingElement (missing documentation)
  * GCExpression ^ ZZ (missing documentation)
  * GCExpression _ BracketRing, --
    Substituting top-degree Grassmann-Cayley elements into the bracket ring
  * GCExpression _ GCAlgebra (missing documentation)
  * net(GCExpression) (missing documentation)
  * "normalForm(GCExpression)" -- see normalForm, --
    Represent a bracket polynomial in a normal form with respect to a Groebner
    basis
  * Number * GCExpression (missing documentation)
  * ring(GCExpression) (missing documentation)
  * RingElement * GCExpression (missing documentation)
  * RingElement ^ GCExpression (missing documentation)
  * terms(GCExpression) (missing documentation)

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

The object GCExpression, is a type (Macaulay2Doc),
with ancestor classes HashTable (Macaulay2Doc),
< Thing (Macaulay2Doc).

-------------------------------------------------------------------------------

The source of this document is in Brackets.m2:579:0.

GCExpression ^ GCExpression -- Shuffle product in the Grassmann-Cayley Algebra
******************************************************************************

  * Operator: ^ (Macaulay2Doc),
  * Usage:
        f = g ^ h;
  * Inputs:
      * g, an instance of the type GCExpression,
      * h, an instance of the type GCExpression,
  * Outputs:
      * f, an instance of the type GCExpression,

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

Let $V$ be a vector space of dimension $d$ over a field $\mathbb{F}.$ We recall
the exterior algebra, \[ \Lambda (V) = \displaystyle\bigoplus_{k=0}^d \Lambda^k
(V), \] a set which forms an algebra with the usual addition and exterior
product. The Grassmann-Cayley algebra is obtained by endowing this set with an
additional shuffle product, defined below.

The linear span of $k$ independent vectors $a_1, \ldots , a_k\in V$ is
represented by the extensor $a_1 \cdots a_k \in \Lambda^k (V)$, where the
product is the usual exterior product. If we fix a basis $\{ e_1, \ldots , e_d
\}$ for $V,$ then each exterior power $\Lambda^k (V)$ has a basis given by the
extensors of the form $e_{i_1} \vee \cdots \vee e_{i_k}.$ We identify the
extensor $a_1 \cdots a_d$ with the bracket $[a_1, \ldots , a_d]$ (see
BracketRing.)

Let $A = a_1 a_2 \cdots a_j$ and $B = b_1 b_2 \cdots b_k$ be extensors with
$j+k\ge d.$ The shuffle product of $A$ and $B$ represents the intersection of
the subspaces represented by $A$ and $B.$ is defined by the formula \[ A \vee B
= \displaystyle\sum_{\sigma \mid \text{is shuffle}} \operatorname{sgn}(\sigma )
[a_{\sigma (1)}, \ldots , a_{\sigma (d-k)}, b_1, \ldots , b_k], \] where the
sum is taken over shuffle permutations with respect to the split $(d-k, j + k
-d).$ These are the permutations $\sigma : [j] \to [j]$ satisfying $\sigma (1)
< \sigma (2) < \ldots  < \sigma (d-k)$ and $\sigma (d-k +1) < \sigma (d-k+2) <
\cdots < \sigma (j).$ Extending $\mathbb{F}$-linearly, the shuffle product
defines an associative, skew-commutative multiplication.

The exterior and shuffle products are implemented using the operators * (Macaulay2Doc),
and  ^ (Macaulay2Doc), respectively. When using
Grassmann-Cayley algebras to prove theorems involving point configurations in
$\mathbb{P} (V)$, it is beneficial to work with indeterminate points, rather
than fixed elements of $V.$ Internally, we represent these indeterminate points
with variables in a skew-commutative polynomial ring, $\mathbb{F}< a_1, \ldots
, a_n>$ (see SkewCommutative (Macaulay2Doc).)

In the example below, three lines spanned by six distinct points in
$\mathbb{P}^2$ in the Grassmann-Cayley algebra, as well as the intersection of
these three lines. In the latter case, we obtain an element of the bracket ring
$B_{3,6}$ (see BracketRing.)

+-----------------------------------------------------------+
|i1 : G = gc(a..f, 3)                                       |
|                                                           |
|o1 = Grassmann-Cayley Algebra generated by 1-extensors a..f|
|                                                           |
|o1 : GCAlgebra                                             |
+-----------------------------------------------------------+
|i2 : lab = (a*b)_G                                         |
|                                                           |
|o2 = a*b                                                   |
|                                                           |
|o2 : GCExpression                                          |
+-----------------------------------------------------------+
|i3 : lcd = (c*d)_G;                                        |
+-----------------------------------------------------------+
|i4 : lef = (e*f)_G;                                        |
+-----------------------------------------------------------+
|i5 : lab ^ lcd ^ lef                                       |
|                                                           |
|o5 = -2*[bcd]*[aef]+2*[bef]*[acd]                          |
|                                                           |
|o5 : GCExpression                                          |
+-----------------------------------------------------------+

See also GCAlgebra, GCExpression.

Ways to use this method:
========================

  * GCExpression ^ GCExpression -- Shuffle
    product in the Grassmann-Cayley Algebra
-------------------------------------------------------------------------------

The source of this document is in Brackets.m2:633:0.

GCExpression _ BracketRing -- Substituting top-degree Grassmann-Cayley elements into the bracket ring
*****************************************************************************************************

  * Operator: _ (Macaulay2Doc),
  * Usage:
        a = b_R;
  * Inputs:
      * b, an instance of the type GCExpression,
      * R, an instance of the type BracketRing,
  * Outputs:
      * a, an instance of the type GCExpression,

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

Interpreting bracket polynomials as functions on $\Lambda^d (V)$ (see
GCExpression ^ GCExpression, for notation), we may
convert an extensor $a_1 \wedge \cdots \wedge a_d$ to the bracket $[a_1, \ldots
, a_d].$

Ways to use this method:
========================

  * GCExpression _ BracketRing, --
    Substituting top-degree Grassmann-Cayley elements into the bracket ring
-------------------------------------------------------------------------------

The source of this document is in Brackets.m2:667:0.

normalForm -- Represent a bracket polynomial in a normal form with respect to a Groebner basis
**********************************************************************************************

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

The relations between brackets generate an ideal, which are the classic Plücker
relations. A Groebner basis for this ideal allows one to represent a polynomial
in brackets in a unique normal form.

+------------------------------------------------------------------+
|i1 : B = bracketRing(4,2)                                         |
|                                                                  |
|o1 = B                                                            |
|      4,2                                                         |
|                                                                  |
|o1 : BracketRing                                                  |
+------------------------------------------------------------------+
|i2 : f = [1 2]_B * [3 4]_B - [1 3]_B * [2 4]_B + [1 4]_B * [2 3]_B|
|                                                                  |
|o2 = [23]*[14]-[24]*[13]+[34]*[12]                                |
|                                                                  |
|o2 : GCExpression                                                 |
+------------------------------------------------------------------+
|i3 : normalForm(f)                                                |
|                                                                  |
|o3 = 0                                                            |
|                                                                  |
|o3 : GCExpression                                                 |
+------------------------------------------------------------------+

See also Bracket, toBracketPolynomial,
and bracketRing,

Ways to use normalForm:
=======================

  * "normalForm(GCExpression)"

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

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

-------------------------------------------------------------------------------

The source of this document is in Brackets.m2:564:0.

RingElement _ AbstractGCRing -- Substituting ring elements into bracket rings and GC algebras
*********************************************************************************************

  * Operator: _ (Macaulay2Doc),
  * Usage:
        a = b_R;
  * Inputs:
      * b, a ring element (Macaulay2Doc),
      * R, an instance of the type AbstractGCRing (missing documentation),
  * Outputs:
      * a, an instance of the type GCExpression,

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

This element is required in order to interpret various symbols as elements of
the Grassmann-Cayley algebra or its associated bracket ring.

Ways to use this method:
========================

  * RingElement _ AbstractGCRing, --
    Substituting ring elements into bracket rings and GC algebras
-------------------------------------------------------------------------------

The source of this document is in Brackets.m2:650:0.

toBracketPolynomial -- Represent an invariant polynomial as a polynomial in brackets
************************************************************************************

  * Usage:
        g = toBracketPolynomial(f,B)
  * Inputs:
      * f, a ring element (Macaulay2Doc),
      * B, an instance of the type BracketRing,
  * Outputs:
      * g, an instance of the type GCExpression,

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

A polynomial invariant under the action of the special linear group may be
represented by a polynomial in brackets. See Bracket, for more
details. Groebner basis methods allow one to compute such a representation.
Below is a simple example.

+-----------------------------------------------------------------------------+
|i1 : B = bracketRing(3, 2)                                                   |
|                                                                             |
|o1 = B                                                                       |
|      3,2                                                                    |
|                                                                             |
|o1 : BracketRing                                                             |
+-----------------------------------------------------------------------------+
|i2 : X = matrix B                                                            |
|                                                                             |
|o2 = {-1} | x_(1,1) x_(1,2) |                                                |
|     {-1} | x_(2,1) x_(2,2) |                                                |
|     {-1} | x_(3,1) x_(3,2) |                                                |
|                                                                             |
|                                                 3                           |
|o2 : Matrix (QQ[x   ..x   , y    , y    , y    ])  <-- (QQ[x   ..x   , y    ,|
|                 1,1   3,2   [23]   [13]   [12]             1,1   3,2   [23] |
|-----------------------------------------------------------------------------|
|              2                                                              |
|y    , y    ])                                                               |
| [13]   [12]                                                                 |
+-----------------------------------------------------------------------------+
|i3 : f = (det X^{1,2}) - (det X^{0,2}) + (det X^{0,1})                       |
|                                                                             |
|o3 = - x   x    + x   x    + x   x    - x   x    - x   x    + x   x          |
|        1,2 2,1    1,1 2,2    1,2 3,1    2,2 3,1    1,1 3,2    2,1 3,2       |
|                                                                             |
|o3 : QQ[x   ..x   , y    , y    , y    ]                                     |
|         1,1   3,2   [23]   [13]   [12]                                      |
+-----------------------------------------------------------------------------+
|i4 : toBracketPolynomial(f,B)                                                |
|                                                                             |
|o4 = [23]-[13]+[12]                                                          |
|                                                                             |
|o4 : GCExpression                                                            |
+-----------------------------------------------------------------------------+

Such a representation is not unique. It may be checked that two bracket
polynomials are equal through their normal form with respect to a Groebner
basis. See normalForm, for a further explanation.

See also BracketRing.

Ways to use toBracketPolynomial:
================================

  * "toBracketPolynomial(RingElement,BracketRing)"

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

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

-------------------------------------------------------------------------------

The source of this document is in Brackets.m2:547:0.