This is FormalGroupLaws.info, produced by Macaulay2, version 1.24.11

FormalGroupLaws -- commutative formal group laws
************************************************

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

This package provides elementary functions to deal with commutative formal
group laws of dimension one.

Authors
=======

  * Baptiste Calmès (see http://bcalmes.perso.math.cnrs.fr/ )
  * Viktor Petrov

Version
=======

This documentation describes version 0.2 of FormalGroupLaws.

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

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

Exports
=======

  * Types
      * FormalGroupLaw -- the class of all formal group
        laws
      * FormalGroupPoint -- the class of all points of
        a formal group
      * FormalSeries -- the class of all formal series
  * Functions and commands
      * compositionInverse -- inverse for
        composition
      * FGL -- constructing a formal group law
      * formalGroupPoint -- constructing a formal
        group point
      * series -- constructing a formal series
      * universalFGL -- universal formal group law
      * universalFGLQ -- universal formal group law over
        rationals
      * valuation -- smallest degree of monomials
  * Methods
      * - FormalGroupPoint -- inverse to a point of
        a formal group
      * - FormalSeries -- minus a formal series
      * compositionInverse(FormalSeries)
        -- inverse for composition of
        formal series
      * FGL(FormalSeries) -- constructing a
        formal group law
      * FormalGroupPoint + FormalGroupPoint
        -- sum of points of a formal group
      * FormalGroupPoint - FormalGroupPoint
        -- difference of points of a formal group
      * formalGroupPoint(FormalGroupLaw,FormalSeries)
        -- constructing a
        formal group point
      * FormalSeries * FormalSeries, --
        multiplication of formal series
      * FormalSeries + FormalSeries, --
        addition of formal series
      * FormalSeries - FormalSeries, --
        difference of formal series
      * FormalSeries == FormalSeries, --
        equality of formal series
      * FormalSeries ^ ZZ -- powers of formal series
      * inverse(FormalSeries), --
        multiplicative inverse of formal series
      * RingElement * FormalSeries, --
        multiplication of a formal series by a constant
      * series(RingElement,ZZ), --
        constructing a formal series
      * substitute(FormalSeries,BasicList)
        -- compose formal series
      * truncate(FormalSeries,ZZ), --
        truncate formal series
      * universalFGL(ZZ,String,String,String)
        -- universal formal
        group law in the Lazard ring
      * universalFGLQ(ZZ,String,String,String)
        -- universal formal
        group law in the Lazard ring tensor Q
      * ZZ * FormalGroupPoint
      * ZZ * FormalSeries -- multiplication of a
        formal series by an integer

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

The object FormalGroupLaws, is a package (Macaulay2Doc).

- FormalGroupPoint -- inverse to a point of a formal group
**********************************************************

Synopsis
========

  * Operator: - (Macaulay2Doc),
  * Usage:
        -s
  * Inputs:
      * s, an instance of the type FormalGroupPoint,
  * Outputs:
      * an instance of the type FormalGroupPoint,

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

+-----------------------------------------------------------------------------+
|i1 : ZZ[x,y]                                                                 |
|                                                                             |
|o1 = ZZ[x..y]                                                                |
|                                                                             |
|o1 : PolynomialRing                                                          |
+-----------------------------------------------------------------------------+
|i2 : f = FGL(series(x+y+x*y,10))                                             |
|                                                                             |
|o2 = FormalGroupLaw{x*y + x + y, 10}                                         |
|                                                                             |
|o2 : FormalGroupLaw                                                          |
+-----------------------------------------------------------------------------+
|i3 : ZZ[u]                                                                   |
|                                                                             |
|o3 = ZZ[u]                                                                   |
|                                                                             |
|o3 : PolynomialRing                                                          |
+-----------------------------------------------------------------------------+
|i4 : s = formalGroupPoint(f,series(u^2+u,5))                                 |
|                                                                             |
|                                                                     2       |
|o4 = FormalGroupPoint{FormalGroupLaw{x*y + x + y, 10}, FormalSeries{u  + u,  |
|                                                                             |
|o4 : FormalGroupPoint                                                        |
|-----------------------------------------------------------------------------|
|5}}                                                                          |
+-----------------------------------------------------------------------------+
|i5 : t = -s                                                                  |
|                                                                             |
|                                                                       4    3|
|o5 = FormalGroupPoint{FormalGroupLaw{x*y + x + y, 10}, FormalSeries{- u  + u |
|                                                                             |
|o5 : FormalGroupPoint                                                        |
|-----------------------------------------------------------------------------|
|- u, 5}}                                                                     |
+-----------------------------------------------------------------------------+
|i6 : s+t                                                                     |
|                                                                             |
|o6 = FormalGroupPoint{FormalGroupLaw{x*y + x + y, 10}, FormalSeries{0, 5}}   |
|                                                                             |
|o6 : FormalGroupPoint                                                        |
+-----------------------------------------------------------------------------+

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

  * - FormalGroupPoint -- inverse to a point of a
    formal group

- FormalSeries -- minus a formal series
***************************************

Synopsis
========

  * Operator: - (Macaulay2Doc),
  * Usage:
        -s
  * Inputs:
      * s, an instance of the type FormalSeries,

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

This returns the additive opposite of the formal series s.

+----------------------------------+
|i1 : R=ZZ[x,y]                    |
|                                  |
|o1 = R                            |
|                                  |
|o1 : PolynomialRing               |
+----------------------------------+
|i2 : s = series(x^2+x+y,2)        |
|                                  |
|                   2              |
|o2 = FormalSeries{x  + x + y, 2}  |
|                                  |
|o2 : FormalSeries                 |
+----------------------------------+
|i3 : -s                           |
|                                  |
|                     2            |
|o3 = FormalSeries{- x  - x - y, 2}|
|                                  |
|o3 : FormalSeries                 |
+----------------------------------+

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

  * - FormalSeries -- minus a formal series

compositionInverse -- inverse for composition
*********************************************

Ways to use compositionInverse:
===============================

  * compositionInverse(FormalSeries)
    -- inverse for composition of formal
    series

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

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

compositionInverse(FormalSeries) -- inverse for composition of formal series
****************************************************************************

Synopsis
========

  * Function: compositionInverse,
  * Usage:
        compositionInverse(s)
  * Inputs:
      * s, an instance of the type FormalSeries,
  * Outputs:
      * an instance of the type FormalSeries,

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

The FormalSeries s must be in one variable and have a zero constant coefficient
and a coefficient +1 or -1 in degree 1. Then, compositionInverse computes the
inverse of s for the composition of formal series, up to the precision of s.

+------------------------------------------+
|i1 : ZZ[x]                                |
|                                          |
|o1 = ZZ[x]                                |
|                                          |
|o1 : PolynomialRing                       |
+------------------------------------------+
|i2 : s = series(x+x^2+2*x^3-5*x^4,4)      |
|                                          |
|                      4     3    2        |
|o2 = FormalSeries{- 5x  + 2x  + x  + x, 4}|
|                                          |
|o2 : FormalSeries                         |
+------------------------------------------+
|i3 : t = compositionInverse(s)            |
|                                          |
|                     4    2               |
|o3 = FormalSeries{10x  - x  + x, 4}       |
|                                          |
|o3 : FormalSeries                         |
+------------------------------------------+
|i4 : substitute(s,{t})                    |
|                                          |
|o4 = FormalSeries{x, 4}                   |
|                                          |
|o4 : FormalSeries                         |
+------------------------------------------+
|i5 : substitute(t,{s})                    |
|                                          |
|o5 = FormalSeries{x, 4}                   |
|                                          |
|o5 : FormalSeries                         |
+------------------------------------------+

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

  * compositionInverse(FormalSeries)
    -- inverse for composition of formal
    series

FGL -- constructing a formal group law
**************************************

Ways to use FGL:
================

  * FGL(FormalSeries) -- constructing a formal
    group law

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

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

FGL(FormalSeries) -- constructing a formal group law
****************************************************

Synopsis
========

  * Function: FGL,
  * Usage:
        FGL(s)
  * Inputs:
      * s, an instance of the type FormalSeries, in two
        variables
  * Outputs:
      * an instance of the type FormalGroupLaw,

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

This constructs an object of the class FormalGroupLaw out of a FormalSeries
living in a PolynomialRing with two generators. The axioms of the neutral
element, commutativity and associativity are checked up to the precision of s.

+-----------------------------------+
|i1 : R=ZZ[x,y]                     |
|                                   |
|o1 = R                             |
|                                   |
|o1 : PolynomialRing                |
+-----------------------------------+
|i2 : s = series(x+y+x*y,2)         |
|                                   |
|o2 = FormalSeries{x*y + x + y, 2}  |
|                                   |
|o2 : FormalSeries                  |
+-----------------------------------+
|i3 : f= FGL(s)                     |
|                                   |
|o3 = FormalGroupLaw{x*y + x + y, 2}|
|                                   |
|o3 : FormalGroupLaw                |
+-----------------------------------+

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

  * FGL(FormalSeries) -- constructing a formal
    group law

FormalGroupLaw -- the class of all formal group laws
****************************************************

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

An object of the class FormalGroupLaw is a FormalSeries in two variables.

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

  * formalGroupPoint(FormalGroupLaw,FormalSeries)
    -- constructing a
    formal group point

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

The object FormalGroupLaw, is a type (Macaulay2Doc),
with ancestor classes FormalSeries, <
BasicList (Macaulay2Doc) < Thing (Macaulay2Doc).

FormalGroupPoint -- the class of all points of a formal group
*************************************************************

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

An object of the class FormalGroupPoint is a list \{f,s\} where f is a formal
group law, s is a formal series without free term

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

  * - FormalGroupPoint -- inverse to a point of a
    formal group
  * FormalGroupPoint + FormalGroupPoint
    -- sum of points of a formal group
  * FormalGroupPoint - FormalGroupPoint
    -- difference of points of a formal group
  * ZZ * FormalGroupPoint

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

The object FormalGroupPoint, is a type (Macaulay2Doc),
with ancestor classes BasicList (Macaulay2Doc),
< Thing (Macaulay2Doc).

formalGroupPoint -- constructing a formal group point
*****************************************************

Ways to use formalGroupPoint:
=============================

  * formalGroupPoint(FormalGroupLaw,FormalSeries)
    -- constructing a
    formal group point

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

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

FormalGroupPoint + FormalGroupPoint -- sum of points of a formal group
**********************************************************************

Synopsis
========

  * Operator: + (Macaulay2Doc),
  * Usage:
        s+t
  * Inputs:
      * s, an instance of the type FormalGroupPoint,
      * t, an instance of the type FormalGroupPoint,
  * Outputs:
      * an instance of the type FormalGroupPoint,

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

+-----------------------------------------------------------------------------+
|i1 : ZZ[x,y]                                                                 |
|                                                                             |
|o1 = ZZ[x..y]                                                                |
|                                                                             |
|o1 : PolynomialRing                                                          |
+-----------------------------------------------------------------------------+
|i2 : f = FGL(series(x+y+x*y,10))                                             |
|                                                                             |
|o2 = FormalGroupLaw{x*y + x + y, 10}                                         |
|                                                                             |
|o2 : FormalGroupLaw                                                          |
+-----------------------------------------------------------------------------+
|i3 : ZZ[u]                                                                   |
|                                                                             |
|o3 = ZZ[u]                                                                   |
|                                                                             |
|o3 : PolynomialRing                                                          |
+-----------------------------------------------------------------------------+
|i4 : s = formalGroupPoint(f,series(u^2+u,5))                                 |
|                                                                             |
|                                                                     2       |
|o4 = FormalGroupPoint{FormalGroupLaw{x*y + x + y, 10}, FormalSeries{u  + u,  |
|                                                                             |
|o4 : FormalGroupPoint                                                        |
|-----------------------------------------------------------------------------|
|5}}                                                                          |
+-----------------------------------------------------------------------------+
|i5 : t = formalGroupPoint(f,series(u^3,5))                                   |
|                                                                             |
|                                                                     3       |
|o5 = FormalGroupPoint{FormalGroupLaw{x*y + x + y, 10}, FormalSeries{u , 5}}  |
|                                                                             |
|o5 : FormalGroupPoint                                                        |
+-----------------------------------------------------------------------------+
|i6 : s+t                                                                     |
|                                                                             |
|                                                                     5    4  |
|o6 = FormalGroupPoint{FormalGroupLaw{x*y + x + y, 10}, FormalSeries{u  + u  +|
|                                                                             |
|o6 : FormalGroupPoint                                                        |
|-----------------------------------------------------------------------------|
| 3    2                                                                      |
|u  + u  + u, 5}}                                                             |
+-----------------------------------------------------------------------------+

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

  * FormalGroupPoint + FormalGroupPoint
    -- sum of points of a formal group

FormalGroupPoint - FormalGroupPoint -- difference of points of a formal group
*****************************************************************************

Synopsis
========

  * Operator: - (Macaulay2Doc),
  * Usage:
        s-t
  * Inputs:
      * s, an instance of the type FormalGroupPoint,
      * t, an instance of the type FormalGroupPoint,
  * Outputs:
      * an instance of the type FormalGroupPoint,

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

+-----------------------------------------------------------------------------+
|i1 : ZZ[x,y]                                                                 |
|                                                                             |
|o1 = ZZ[x..y]                                                                |
|                                                                             |
|o1 : PolynomialRing                                                          |
+-----------------------------------------------------------------------------+
|i2 : f = FGL(series(x+y+x*y,10))                                             |
|                                                                             |
|o2 = FormalGroupLaw{x*y + x + y, 10}                                         |
|                                                                             |
|o2 : FormalGroupLaw                                                          |
+-----------------------------------------------------------------------------+
|i3 : ZZ[u]                                                                   |
|                                                                             |
|o3 = ZZ[u]                                                                   |
|                                                                             |
|o3 : PolynomialRing                                                          |
+-----------------------------------------------------------------------------+
|i4 : s = formalGroupPoint(f,series(u^2+u,5))                                 |
|                                                                             |
|                                                                     2       |
|o4 = FormalGroupPoint{FormalGroupLaw{x*y + x + y, 10}, FormalSeries{u  + u,  |
|                                                                             |
|o4 : FormalGroupPoint                                                        |
|-----------------------------------------------------------------------------|
|5}}                                                                          |
+-----------------------------------------------------------------------------+
|i5 : t = formalGroupPoint(f,series(u^3,5))                                   |
|                                                                             |
|                                                                     3       |
|o5 = FormalGroupPoint{FormalGroupLaw{x*y + x + y, 10}, FormalSeries{u , 5}}  |
|                                                                             |
|o5 : FormalGroupPoint                                                        |
+-----------------------------------------------------------------------------+
|i6 : s-t                                                                     |
|                                                                             |
|                                                                       5    4|
|o6 = FormalGroupPoint{FormalGroupLaw{x*y + x + y, 10}, FormalSeries{- u  - u |
|                                                                             |
|o6 : FormalGroupPoint                                                        |
|-----------------------------------------------------------------------------|
|   3    2                                                                    |
|- u  + u  + u, 5}}                                                           |
+-----------------------------------------------------------------------------+

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

  * FormalGroupPoint - FormalGroupPoint
    -- difference of points of a formal group

formalGroupPoint(FormalGroupLaw,FormalSeries) -- constructing a formal group point
**********************************************************************************

Synopsis
========

  * Function: formalGroupPoint,
  * Usage:
        formalGroupPoint(f,s)
  * Inputs:
      * f, an instance of the type FormalGroupLaw,
      * s, an instance of the type FormalSeries, with the
        same coefficient ring as f
  * Outputs:
      * p, an instance of the type FormalGroupPoint,

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

This constructs an object of the class FormalGroupPoint out of a FormalGroupLaw
and a FormalSeries with the same coefficient ring and such that s has precision
at most that of f.

+-----------------------------------------------------------------------------+
|i1 : ZZ[x,y]                                                                 |
|                                                                             |
|o1 = ZZ[x..y]                                                                |
|                                                                             |
|o1 : PolynomialRing                                                          |
+-----------------------------------------------------------------------------+
|i2 : f=FGL(series(x+y+x*y,2))                                                |
|                                                                             |
|o2 = FormalGroupLaw{x*y + x + y, 2}                                          |
|                                                                             |
|o2 : FormalGroupLaw                                                          |
+-----------------------------------------------------------------------------+
|i3 : ZZ[u,v]                                                                 |
|                                                                             |
|o3 = ZZ[u..v]                                                                |
|                                                                             |
|o3 : PolynomialRing                                                          |
+-----------------------------------------------------------------------------+
|i4 : s = series(u+v+u^2,2)                                                   |
|                                                                             |
|                   2                                                         |
|o4 = FormalSeries{u  + u + v, 2}                                             |
|                                                                             |
|o4 : FormalSeries                                                            |
+-----------------------------------------------------------------------------+
|i5 : p= formalGroupPoint(f,s)                                                |
|                                                                             |
|                                                                    2        |
|o5 = FormalGroupPoint{FormalGroupLaw{x*y + x + y, 2}, FormalSeries{u  + u +  |
|                                                                             |
|o5 : FormalGroupPoint                                                        |
|-----------------------------------------------------------------------------|
|v, 2}}                                                                       |
+-----------------------------------------------------------------------------+

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

  * formalGroupPoint(FormalGroupLaw,FormalSeries)
    -- constructing a
    formal group point

FormalSeries -- the class of all formal series
**********************************************

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

An object of the class FormalSeries is a list \{P,n\} where P is an element of
a polynomial ring and n is an integer representing the precision (the terms in
degree strictly greater than n are considered zero).

Types of FormalSeries:
======================

  * FormalGroupLaw -- the class of all formal group laws

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

  * - FormalSeries -- minus a formal series
  * compositionInverse(FormalSeries)
    -- inverse for composition of formal
    series
  * FGL(FormalSeries) -- constructing a formal
    group law
  * formalGroupPoint(FormalGroupLaw,FormalSeries)
    -- constructing a
    formal group point
  * FormalSeries * FormalSeries, --
    multiplication of formal series
  * FormalSeries + FormalSeries -- addition
    of formal series
  * FormalSeries - FormalSeries, --
    difference of formal series
  * FormalSeries == FormalSeries, --
    equality of formal series
  * FormalSeries ^ ZZ -- powers of formal series
  * inverse(FormalSeries) -- multiplicative
    inverse of formal series
  * RingElement * FormalSeries, --
    multiplication of a formal series by a constant
  * substitute(FormalSeries,BasicList)
    -- compose formal series
  * truncate(FormalSeries,ZZ), --
    truncate formal series
  * ZZ * FormalSeries -- multiplication of a formal
    series by an integer

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

The object FormalSeries, is a type (Macaulay2Doc),
with ancestor classes BasicList (Macaulay2Doc),
< Thing (Macaulay2Doc).

FormalSeries * FormalSeries -- multiplication of formal series
**************************************************************

Synopsis
========

  * Operator: * (Macaulay2Doc),
  * Usage:
        s * t
  * Inputs:
      * s, an instance of the type FormalSeries,
      * t, an instance of the type FormalSeries,
  * Outputs:
      * an instance of the type FormalSeries, the product
        of the formal series s and t

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

+---------------------------------------------+
|i1 : R=ZZ[x,y]                               |
|                                             |
|o1 = R                                       |
|                                             |
|o1 : PolynomialRing                          |
+---------------------------------------------+
|i2 : s = series(x^2+x+y,2)                   |
|                                             |
|                   2                         |
|o2 = FormalSeries{x  + x + y, 2}             |
|                                             |
|o2 : FormalSeries                            |
+---------------------------------------------+
|i3 : t = series(x+y+1,2)                     |
|                                             |
|o3 = FormalSeries{x + y + 1, 2}              |
|                                             |
|o3 : FormalSeries                            |
+---------------------------------------------+
|i4 : s * t                                   |
|                                             |
|                    2           2            |
|o4 = FormalSeries{2x  + 2x*y + y  + x + y, 2}|
|                                             |
|o4 : FormalSeries                            |
+---------------------------------------------+

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

  * FormalSeries * FormalSeries, --
    multiplication of formal series

FormalSeries + FormalSeries -- addition of formal series
********************************************************

Synopsis
========

  * Operator: + (Macaulay2Doc),
  * Usage:
        s + t
  * Inputs:
      * s, an instance of the type FormalSeries,
      * t, an instance of the type FormalSeries,
  * Outputs:
      * an instance of the type FormalSeries,

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

The sum of the formal series is returned.

+--------------------------------------+
|i1 : R=ZZ[x,y]                        |
|                                      |
|o1 = R                                |
|                                      |
|o1 : PolynomialRing                   |
+--------------------------------------+
|i2 : s = series(x^2+x+y,2)            |
|                                      |
|                   2                  |
|o2 = FormalSeries{x  + x + y, 2}      |
|                                      |
|o2 : FormalSeries                     |
+--------------------------------------+
|i3 : t = series(x+y+1,2)              |
|                                      |
|o3 = FormalSeries{x + y + 1, 2}       |
|                                      |
|o3 : FormalSeries                     |
+--------------------------------------+
|i4 : s + t                            |
|                                      |
|                   2                  |
|o4 = FormalSeries{x  + 2x + 2y + 1, 2}|
|                                      |
|o4 : FormalSeries                     |
+--------------------------------------+

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

  * FormalSeries + FormalSeries -- addition
    of formal series

FormalSeries - FormalSeries -- difference of formal series
**********************************************************

Synopsis
========

  * Operator: - (Macaulay2Doc),
  * Usage:
        s - t
  * Inputs:
      * s, an instance of the type FormalSeries,
      * t, an instance of the type FormalSeries,
  * Outputs:
      * an instance of the type FormalSeries,

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

The difference of the formal series is returned.

+--------------------------------+
|i1 : R=ZZ[x,y]                  |
|                                |
|o1 = R                          |
|                                |
|o1 : PolynomialRing             |
+--------------------------------+
|i2 : s = series(x^2+x+y,2)      |
|                                |
|                   2            |
|o2 = FormalSeries{x  + x + y, 2}|
|                                |
|o2 : FormalSeries               |
+--------------------------------+
|i3 : t = series(x+y+1,2)        |
|                                |
|o3 = FormalSeries{x + y + 1, 2} |
|                                |
|o3 : FormalSeries               |
+--------------------------------+
|i4 : s - t                      |
|                                |
|                   2            |
|o4 = FormalSeries{x  - 1, 2}    |
|                                |
|o4 : FormalSeries               |
+--------------------------------+

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

  * FormalSeries - FormalSeries, --
    difference of formal series

FormalSeries == FormalSeries -- equality of formal series
*********************************************************

Synopsis
========

  * Operator: == (Macaulay2Doc),
  * Usage:
        s == t
  * Inputs:
      * s, an instance of the type FormalSeries,
      * t, an instance of the type FormalSeries,
  * Outputs:
      * an integer (Macaulay2Doc),

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

True is returned if the formal series are equal (they should have the same
precision) and false is returned if not.

+--------------------------------+
|i1 : R=ZZ[x,y]                  |
|                                |
|o1 = R                          |
|                                |
|o1 : PolynomialRing             |
+--------------------------------+
|i2 : s = series(x^2+x+y,2)      |
|                                |
|                   2            |
|o2 = FormalSeries{x  + x + y, 2}|
|                                |
|o2 : FormalSeries               |
+--------------------------------+
|i3 : t = series(x+y+1,2)        |
|                                |
|o3 = FormalSeries{x + y + 1, 2} |
|                                |
|o3 : FormalSeries               |
+--------------------------------+
|i4 : s == s                     |
|                                |
|o4 = true                       |
+--------------------------------+
|i5 : s == t                     |
|                                |
|o5 = false                      |
+--------------------------------+
|i6 : r = truncate(t,1)          |
|                                |
|o6 = FormalSeries{x + y + 1, 1} |
|                                |
|o6 : FormalSeries               |
+--------------------------------+
|i7 : t == r                     |
|                                |
|o7 = false                      |
+--------------------------------+

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

  * FormalSeries == FormalSeries, --
    equality of formal series

FormalSeries ^ ZZ -- powers of formal series
********************************************

Synopsis
========

  * Operator: ^ (Macaulay2Doc),
  * Usage:
        s^n
  * Inputs:
      * s, an instance of the type FormalSeries,
      * n, an integer (Macaulay2Doc),
  * Outputs:
      * an instance of the type FormalSeries, the n-th
        power of the formal series s

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

+--------------------------------+
|i1 : R=ZZ[x,y]                  |
|                                |
|o1 = R                          |
|                                |
|o1 : PolynomialRing             |
+--------------------------------+
|i2 : s = series(x^2+x+y,2)      |
|                                |
|                   2            |
|o2 = FormalSeries{x  + x + y, 2}|
|                                |
|o2 : FormalSeries               |
+--------------------------------+
|i3 : s^4                        |
|                                |
|o3 = FormalSeries{0, 2}         |
|                                |
|o3 : FormalSeries               |
+--------------------------------+

Caveat
======

If n is 0, the formal series returned is 1 with the same precision as s. If n
is negative, then s needs to have its constant part equal to either +1 or -1,
otherwise an error occurs.

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

  * FormalSeries ^ ZZ -- powers of formal series

inverse(FormalSeries) -- multiplicative inverse of formal series
****************************************************************

Synopsis
========

  * Function: inverse (Macaulay2Doc),
  * Usage:
        inverse(s)
  * Inputs:
      * s, an instance of the type FormalSeries,
  * Outputs:
      * an instance of the type FormalSeries, the
        multiplicative inverse of the formal series s

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

+-----------------------------------------------------------------+
|i1 : R=ZZ[x,y]                                                   |
|                                                                 |
|o1 = R                                                           |
|                                                                 |
|o1 : PolynomialRing                                              |
+-----------------------------------------------------------------+
|i2 : s = series(2*x^2*y+x*y+x^2+x+y+1,3)                         |
|                                                                 |
|                    2     2                                      |
|o2 = FormalSeries{2x y + x  + x*y + x + y + 1, 3}                |
|                                                                 |
|o2 : FormalSeries                                                |
+-----------------------------------------------------------------+
|i3 : inverse(s)                                                  |
|                                                                 |
|                   3    2       2    3          2                |
|o3 = FormalSeries{x  - x y - x*y  - y  + x*y + y  - x - y + 1, 3}|
|                                                                 |
|o3 : FormalSeries                                                |
+-----------------------------------------------------------------+

Caveat
======

If the constant coefficient of s is not +1 or -1, inverse returns an error.

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

  * inverse(FormalSeries) -- multiplicative
    inverse of formal series

RingElement * FormalSeries -- multiplication of a formal series by a constant
*****************************************************************************

Synopsis
========

  * Operator: * (Macaulay2Doc),
  * Usage:
        r * t
  * Inputs:
      * r, a ring element (Macaulay2Doc),
      * t, an instance of the type FormalSeries,
  * Outputs:
      * an instance of the type FormalSeries, the
        multiplication of the formal series s by the constant r

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

+--------------------------------------------------------+
|i1 : R=ZZ[a]                                            |
|                                                        |
|o1 = R                                                  |
|                                                        |
|o1 : PolynomialRing                                     |
+--------------------------------------------------------+
|i2 : S=R[x,y]                                           |
|                                                        |
|o2 = S                                                  |
|                                                        |
|o2 : PolynomialRing                                     |
+--------------------------------------------------------+
|i3 : s = series(x^2+x+y,2)                              |
|                                                        |
|                   2                                    |
|o3 = FormalSeries{x  + x + y, 2}                        |
|                                                        |
|o3 : FormalSeries                                       |
+--------------------------------------------------------+
|i4 : (a^2+a) * s                                        |
|                                                        |
|                    2      2     2           2          |
|o4 = FormalSeries{(a  + a)x  + (a  + a)x + (a  + a)y, 2}|
|                                                        |
|o4 : FormalSeries                                       |
+--------------------------------------------------------+

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

  * RingElement * FormalSeries, --
    multiplication of a formal series by a constant

series -- constructing a formal series
**************************************

Ways to use series:
===================

  * series(RingElement,ZZ) -- constructing
    a formal series

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

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

series(RingElement,ZZ) -- constructing a formal series
******************************************************

Synopsis
========

  * Function: series,
  * Usage:
        series(s,n)
  * Inputs:
      * s, a ring element (Macaulay2Doc), an element of a
        polynomial ring
      * n, an integer (Macaulay2Doc),
  * Outputs:
      * an instance of the type FormalSeries,

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

This constructs an object of the class FormalSeries out of an element of a
PolynomialRing and an integer representing the precision.

+--------------------------------+
|i1 : R=ZZ[x,y]                  |
|                                |
|o1 = R                          |
|                                |
|o1 : PolynomialRing             |
+--------------------------------+
|i2 : s = series(x^2+x+y,2)      |
|                                |
|                   2            |
|o2 = FormalSeries{x  + x + y, 2}|
|                                |
|o2 : FormalSeries               |
+--------------------------------+

Note that the polynomial is automatically truncated at the precision.

+--------------------------------+
|i3 : t = series(x^3+x^2+x+y,2)  |
|                                |
|                   2            |
|o3 = FormalSeries{x  + x + y, 2}|
|                                |
|o3 : FormalSeries               |
+--------------------------------+

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

  * series(RingElement,ZZ) -- constructing
    a formal series

substitute(FormalSeries,BasicList) -- compose formal series
***********************************************************

Synopsis
========

  * Function: substitute (Macaulay2Doc),
  * Usage:
        substitute(s,l)
  * Inputs:
      * s, an instance of the type FormalSeries,
      * l, a basic list (Macaulay2Doc),
  * Outputs:
      * an instance of the type FormalSeries,

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

All the FormalSeries involved should have the same coefficient ring. The
function substitutes the variables in s with the series in the BasicList l.
Also note that this also works when s is a FormalGroupLaw which is a subclass
of FormalSeries.

+-----------------------------------------------+
|i1 : R=ZZ[x,y]                                 |
|                                               |
|o1 = R                                         |
|                                               |
|o1 : PolynomialRing                            |
+-----------------------------------------------+
|i2 : s = series(x^2+x+y,2)                     |
|                                               |
|                   2                           |
|o2 = FormalSeries{x  + x + y, 2}               |
|                                               |
|o2 : FormalSeries                              |
+-----------------------------------------------+
|i3 : substitute(s,{s,s})                       |
|                                               |
|                    2           2              |
|o3 = FormalSeries{3x  + 2x*y + y  + 2x + 2y, 2}|
|                                               |
|o3 : FormalSeries                              |
+-----------------------------------------------+

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

  * substitute(FormalSeries,BasicList)
    -- compose formal series

truncate(FormalSeries,ZZ) -- truncate formal series
***************************************************

Synopsis
========

  * Function: truncate (Macaulay2Doc),
  * Usage:
        truncate(s,n)
  * Inputs:
      * s, an instance of the type FormalSeries,
      * n, an integer (Macaulay2Doc),
  * Outputs:
      * an instance of the type FormalSeries,

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

This function truncates the formal series s at the precision n.

+-------------------------------------+
|i1 : R=ZZ[x,y]                       |
|                                     |
|o1 = R                               |
|                                     |
|o1 : PolynomialRing                  |
+-------------------------------------+
|i2 : s = series(x^7+x^2+x+y,7)       |
|                                     |
|                   7    2            |
|o2 = FormalSeries{x  + x  + x + y, 7}|
|                                     |
|o2 : FormalSeries                    |
+-------------------------------------+
|i3 : truncate(s,4)                   |
|                                     |
|                   2                 |
|o3 = FormalSeries{x  + x + y, 4}     |
|                                     |
|o3 : FormalSeries                    |
+-------------------------------------+

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

  * truncate(FormalSeries,ZZ), --
    truncate formal series

universalFGL -- universal formal group law
******************************************

Ways to use universalFGL:
=========================

  * universalFGL(ZZ,String,String,String)
    -- universal formal group
    law in the Lazard ring

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

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

universalFGL(ZZ,String,String,String) -- universal formal group law in the Lazard ring
**************************************************************************************

Synopsis
========

  * Function: universalFGL,
  * Usage:
        universalFGL(n,s,t,u)
  * Inputs:
      * n, an integer (Macaulay2Doc), the degree of precision
      * s, a string (Macaulay2Doc), the name (such as "a") to be
        used for the variables of the Lazard ring
      * t, a string (Macaulay2Doc), the name (such as "x") of the
        first variable of the formal group law
      * u, a string (Macaulay2Doc), the name (such as "y") of the
        second variable of the formal group law
  * Outputs:
      * an instance of the type FormalGroupLaw,

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

The following returns the formal group law over the Lazard ring (seen as a
polynomial ring in the {a_i}'s up to degree n.

+-----------------------------------------------------------------------------+
|i1 : universalFGL(3,"a","x","y")                                             |
|                                                                             |
|                       2         2                                           |
|o1 = FormalGroupLaw{a x y + a x*y  + a x*y + x + y, 3}                       |
|                     2       2        1                                      |
|                                                                             |
|o1 : FormalGroupLaw                                                          |
+-----------------------------------------------------------------------------+
|i2 : universalFGL(4,"a","x","y")                                             |
|                                                                             |
|                                    3                    2 2                 |
|o2 = FormalGroupLaw{(- 2a a  + 2a )x y + (- 2a a  + 3a )x y  + (- 2a a  +    |
|                         1 2     3            1 2     3             1 2      |
|                                                                             |
|o2 : FormalGroupLaw                                                          |
|-----------------------------------------------------------------------------|
|       3      2         2                                                    |
|2a )x*y  + a x y + a x*y  + a x*y + x + y, 4}                                |
|  3         2       2        1                                               |
+-----------------------------------------------------------------------------+

Caveat
======

The decomposition of the Lazard as a polynomial ring in an infinite number of
variables is not canonical, we have made a choice, here, which amounts to
choosing, for every d at most n, of Bezout coefficients for the set of binomial
coefficients (d,i), 1<i<d. Variables with names equal to the strings (like x, y
or a, here) should not have been assigned values (like 3) beforehand otherwise
an error will occur.

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

  * universalFGL(ZZ,String,String,String)
    -- universal formal group
    law in the Lazard ring

universalFGLQ -- universal formal group law over rationals
**********************************************************

Ways to use universalFGLQ:
==========================

  * universalFGLQ(ZZ,String,String,String)
    -- universal formal group
    law in the Lazard ring tensor Q

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

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

universalFGLQ(ZZ,String,String,String) -- universal formal group law in the Lazard ring tensor Q
************************************************************************************************

Synopsis
========

  * Function: universalFGLQ,
  * Usage:
        universalFGLQ(n,s,t,u)
  * Inputs:
      * n, an integer (Macaulay2Doc), the degree of precision
      * s, a string (Macaulay2Doc), the name (such as "b") to be
        used for the variables of the Lazard ring
      * t, a string (Macaulay2Doc), the name (such as "x") of the
        first variable of the formal group law
      * u, a string (Macaulay2Doc), the name (such as "y") of the
        second variable of the formal group law
  * Outputs:
      * an instance of the type FormalGroupLaw,

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

The following returns a formal group law over the Lazard ring tensor Q (seen as
a polynomial ring in the classes of the projective spaces {b_i}'s, up to degree
n.

+-----------------------------------------------------------------------------+
|i1 : universalFGLQ(3,"b","x","y")                                            |
|                                                                             |
|                       2        2       2          2                         |
|o1 = FormalGroupLaw{(4b  - 3b )x y + (4b  - 3b )x*y  - 2b x*y + x + y, 3}    |
|                       1     2          1     2          1                   |
|                                                                             |
|o1 : FormalGroupLaw                                                          |
+-----------------------------------------------------------------------------+
|i2 : universalFGLQ(4,"b","x","y")                                            |
|                                                                             |
|                         3                 3          3                 2 2  |
|o2 = FormalGroupLaw{(- 8b  + 12b b  - 4b )x y + (- 20b  + 24b b  - 6b )x y  +|
|                         1      1 2     3             1      1 2     3       |
|                                                                             |
|o2 : FormalGroupLaw                                                          |
|-----------------------------------------------------------------------------|
|     3                   3      2        2       2          2                |
|(- 8b  + 12b b  - 4b )x*y  + (4b  - 3b )x y + (4b  - 3b )x*y  - 2b x*y + x + |
|     1      1 2     3           1     2          1     2          1          |
|-----------------------------------------------------------------------------|
|y, 4}                                                                        |
+-----------------------------------------------------------------------------+

Caveat
======

Variables with names equal to the strings (like x, y or b, here) should not
have been assigned values (like 3) beforehand otherwise an error will occur.

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

  * universalFGLQ(ZZ,String,String,String)
    -- universal formal group
    law in the Lazard ring tensor Q

valuation -- smallest degree of monomials
*****************************************

Synopsis
========

  * Usage:
        valuation(p)
  * Inputs:
      * p, an element of a PolynomialRing
  * Outputs:
      * an integer, or infinity

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

This function computes the minimum of the degrees of monomials appearing in p.
It gives infinity if p is zero.

+---------------------+
|i1 : R= ZZ[x,y]      |
|                     |
|o1 = R               |
|                     |
|o1 : PolynomialRing  |
+---------------------+
|i2 : valuation(x^2+y)|
|                     |
|o2 = 1               |
+---------------------+
|i3 : valuation(0_R)  |
|                     |
|o3 = infinity        |
|                     |
|o3 : InfiniteNumber  |
+---------------------+

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

The object valuation, is a function closure (Macaulay2Doc).

ZZ * FormalGroupPoint
*********************

Synopsis
========

  * Operator: * (Macaulay2Doc),
  * Usage:
        n*s
  * Inputs:
      * n, an integer (Macaulay2Doc),
      * s, an instance of the type FormalGroupPoint,
  * Outputs:
      * an instance of the type FormalGroupPoint,

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

+-----------------------------------------------------------------------------+
|i1 : ZZ[x,y]                                                                 |
|                                                                             |
|o1 = ZZ[x..y]                                                                |
|                                                                             |
|o1 : PolynomialRing                                                          |
+-----------------------------------------------------------------------------+
|i2 : f = FGL(series(x+y+x*y,10))                                             |
|                                                                             |
|o2 = FormalGroupLaw{x*y + x + y, 10}                                         |
|                                                                             |
|o2 : FormalGroupLaw                                                          |
+-----------------------------------------------------------------------------+
|i3 : ZZ[u]                                                                   |
|                                                                             |
|o3 = ZZ[u]                                                                   |
|                                                                             |
|o3 : PolynomialRing                                                          |
+-----------------------------------------------------------------------------+
|i4 : s = formalGroupPoint(f,series(u^2+u,5))                                 |
|                                                                             |
|                                                                     2       |
|o4 = FormalGroupPoint{FormalGroupLaw{x*y + x + y, 10}, FormalSeries{u  + u,  |
|                                                                             |
|o4 : FormalGroupPoint                                                        |
|-----------------------------------------------------------------------------|
|5}}                                                                          |
+-----------------------------------------------------------------------------+
|i5 : 3*s                                                                     |
|                                                                             |
|                                                                      5     4|
|o5 = FormalGroupPoint{FormalGroupLaw{x*y + x + y, 10}, FormalSeries{3u  + 6u |
|                                                                             |
|o5 : FormalGroupPoint                                                        |
|-----------------------------------------------------------------------------|
|    3     2                                                                  |
|+ 7u  + 6u  + 3u, 5}}                                                        |
+-----------------------------------------------------------------------------+

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

  * ZZ * FormalGroupPoint

ZZ * FormalSeries -- multiplication of a formal series by an integer
********************************************************************

Synopsis
========

  * Operator: * (Macaulay2Doc),
  * Usage:
        n * t
  * Inputs:
      * n, an integer (Macaulay2Doc),
      * t, an instance of the type FormalSeries,
  * Outputs:
      * an instance of the type FormalSeries, The
        multiplication of the formal series s by the integer n

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

+-----------------------------------+
|i1 : R=ZZ[x,y]                     |
|                                   |
|o1 = R                             |
|                                   |
|o1 : PolynomialRing                |
+-----------------------------------+
|i2 : s = series(x^2+x+y,2)         |
|                                   |
|                   2               |
|o2 = FormalSeries{x  + x + y, 2}   |
|                                   |
|o2 : FormalSeries                  |
+-----------------------------------+
|i3 : 4 * s                         |
|                                   |
|                    2              |
|o3 = FormalSeries{4x  + 4x + 4y, 2}|
|                                   |
|o3 : FormalSeries                  |
+-----------------------------------+

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

  * ZZ * FormalSeries -- multiplication of a formal
    series by an integer