This is FunctionFieldDesingularization.info, produced by Macaulay2, version 1.25.11

FunctionFieldDesingularization -- Strong desingularization of a function field in arbitrary characteristic and dimension
************************************************************************************************************************

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

Strong desingularization of a function field in arbitrary characteristic and
dimension, using the algorithm in the paper Desingularization of Function
Fields, Leonard, arXiv1912.08663, December, 2019.

Author
======

  * Douglas A. Leonard <leonada@auburn.edu>

Version
=======

This documentation describes version 1.0 of FunctionFieldDesingularization,
released September 13, 2021.

Citation
========

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

+-----------------------------------------------------------------------------+
|@misc{FunctionFieldDesingularizationSource,                                  |
|  title = {{FunctionFieldDesingularization: desingularization of function    |
|  author = {Douglas A. Leonard},                                             |
|  howpublished = {A \emph{Macaulay2} package available at                    |
|    \url{https://github.com/Macaulay2/M2/tree/stable/M2/Macaulay2/packages   |
|}                                                                            |
|-----------------------------------------------------------------------------|
|fields. Version~1.0}},                                                       |
|                                                                             |
|                                                                             |
|}}                                                                           |
+-----------------------------------------------------------------------------+

Exports
=======

  * Functions and commands
      * arcs -- prints node labels for the desingularization tree
      * negLexMatrix -- a local (series) monomial ordering
        matrix for the input of arcs
  * Methods
      * arcs(RingElement,Ideal,List,File) (missing documentation)
      * negLexMatrix(ZZ) (missing documentation)

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

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

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

The source of this document is in FunctionFieldDesingularization.m2:583:0.

arcs -- prints node labels for the desingularization tree
*********************************************************

  * Usage:
        (prevlist,levellist,clist,blist,nlist,elist,philist,leaflist,Philist) = arcs(b0,n0e0,fout)
  * Inputs:
      * polyb, irreducible polynomial for the domain A_k
      * ineq, list of inequality constraints for the part
      * eq, ideal of equality constraints for the part
      * fout, output file to which results are written
  * Outputs:
      * prevlist, a list (Macaulay2Doc), previous node in tree list
      * levellist, a list (Macaulay2Doc), level determines the
        rings being used
      * clist, a list (Macaulay2Doc), irreducible mod x_d
      * blist, a list (Macaulay2Doc), irreducible
      * nlist, a list (Macaulay2Doc), inequality constraints
      * elist, a list (Macaulay2Doc), ideal of equality constraints
      * philist, a list (Macaulay2Doc), birational change of
        variables maps between node and previous node
      * leaflist, a list (Macaulay2Doc), leaf of tree or not
      * Philist, a list (Macaulay2Doc), birational change of
        variables maps between node and root node

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

+------------------------------------------------------+
|i1 : fout = openOut "curve_example0";                 |
+------------------------------------------------------+
|i2 : F = QQ;                                          |
+------------------------------------------------------+
|i3 : d = 1;                                           |
+------------------------------------------------------+
|i4 : P0 = F[a_{0,0}..a_{0,d}];                        |
+------------------------------------------------------+
|i5 : R0 = P0[x_{0,0}..x_{0,d},                        |
|     Weights=> entries negLexMatrix(d),Global=>false];|
+------------------------------------------------------+
|i6 : b0 = x_{0,0}^3+x_{0,0}*x_{0,1}+x_{0,1}^5;        |
+------------------------------------------------------+
|i7 : n0 = {};                                         |
+------------------------------------------------------+
|i8 : e0 = ideal(a_{0,0}^3+a_{0,0}*a_{0,1}+a_{0,1}^5); |
|                                                      |
|o8 : Ideal of P0                                      |
+------------------------------------------------------+
|i9 : tree = arcs(b0,e0,n0,fout);                      |
+------------------------------------------------------+
|i10 : b1 = x_{0,0}^3+x_{0,0}^2*x_{0,1}^4+x_{0,1}^5;   |
+------------------------------------------------------+
|i11 : n1 = {};                                        |
+------------------------------------------------------+
|i12 : e1 = ideal(a_{0,0},a_{0,1});                    |
|                                                      |
|o12 : Ideal of P0                                     |
+------------------------------------------------------+
|i13 : tree = arcs(b1,e1,n1,fout);                     |
+------------------------------------------------------+
|i14 : fout << close;                                  |
+------------------------------------------------------+
|i15 :                                                 |
+------------------------------------------------------+

Each node is described by an irreducible polynomial bnew, cnew its reduction
mod x_d, a list of inequality constraints, an ideal of equality constraints, a
birational change-of-variables from its previous node, and one from the root as
well. See the test examples for syntax.

Ways to use arcs:
=================

  * arcs(RingElement,Ideal,List,File) (missing documentation)

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

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

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

The source of this document is in FunctionFieldDesingularization.m2:652:0.

negLexMatrix -- a local (series) monomial ordering matrix for the input of arcs
*******************************************************************************

  * Usage:
        negLexMatrix(d)
  * Inputs:
      * d, the dimension, a positive integer
  * Outputs:
      * negLexMatrix, a matrix (Macaulay2Doc), negative lex d
        imes d matrix

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

+-------------------------+
|i1 : M = negLexMatrix 10;|
|                         |
|              11       11|
|o1 : Matrix ZZ   <-- ZZ  |
+-------------------------+

The rings should be poly rings over poly rings with local monomial orderings to
emphasize series

Ways to use negLexMatrix:
=========================

  * negLexMatrix(ZZ) (missing documentation)

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

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

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

The source of this document is in FunctionFieldDesingularization.m2:603:0.