This is TropicalToric.info, produced by Macaulay2, version 1.26.06

TropicalToric -- Macaulay2 package for toric intersection theory using tropical geometry.
*****************************************************************************************

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

This package implements the computations of classes in the Chow ring of a toric
variety using tropical geometry. Part of this code is based on a package
previously written by Diane Maclagan, Sameera Vemulapalli, Corey Harris, Erika
Pirnes and Ritvik Ramkumar.

Author
======

  * Alessio Borzì (see https://alessioborzi.github.io )
    <Alessio.Borzi@warwick.ac.uk>

Certification a gold star
=========================

Version 1.0 of this package was accepted for publication in volume 14 (see
https://msp.org/jsag/2024/14-1/ ) of Journal of Software for Algebra and
Geometry (see https://msp.org/jsag/ ) on 2023-09-14, in the article Tropical
computations for toric intersection theory in Macaulay2 (see
https://msp.org/jsag/2024/14-1/p04.xhtml ) (DOI: 10.2140/jsag.2024.14.19 (see
https://doi.org/10.2140/jsag.2024.14.19 )). That version can be obtained from
the journal (see https://msp.org/jsag/2024/14-1/jsag-v14-n1-x04-TropicalToric.
zip ).

Version
=======

This documentation describes version 1.0 of TropicalToric, released May 2022.

Citation
========

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

+-----------------------------------------------------------------------------+
|@misc{TropicalToricSource,                                                   |
|  title = {{TropicalToric: tropical methods for toric intersection           |
|  author = {Alessio Borzì},                                                  |
|  howpublished = {A \emph{Macaulay2} package available at                    |
|    \url{https://github.com/Macaulay2/M2/tree/stable/M2/Macaulay2/           |
|}                                                                            |
|                                                                             |
|@article{TropicalToricArticle,                                               |
|  title = {{Tropical computations for toric intersection theory in           |
|  author = {Alessio Borzì},                                                  |
|  journal = {Journal of Software for Algebra and Geometry},                  |
|  volume = {14},                                                             |
|  year = {2023},                                                             |
|}                                                                            |
|-----------------------------------------------------------------------------|
| theory. Version~1.0}},                                                      |
|                                                                             |
|                                                                             |
|packages}}                                                                   |
|                                                                             |
|                                                                             |
|                                                                             |
| \emph{Macaulay2}}},                                                         |
+-----------------------------------------------------------------------------+

Exports
=======

  * Types
      * ToricCycle -- the class of a toric cycle on a
        NormalToricVariety
  * Functions and commands
      * classFromTropical -- compute a toric cycle of
        X which class is the same as a given subvariety of X
      * classFromTropicalCox -- compute a toric
        cycle of X which class is the same as a given subvariety of X
      * classWonderfulCompactification,
        -- compute a toric cycle of X which class is the same as a given
        subvariety of X
      * degCycle -- Compute the degree of a cycle of maximal
        codimension
      * isTransverse -- checks transversality of toric
        divisors and cones
      * makeTransverse -- Find a divisor linearly
        equivalent to a toric divisor D that is transverse to a given cone C
      * poincareDuality -- Apply the isomorphism
        Hom(A^k(X),ZZ) = A_k(X)
      * "poincareMatrix" -- see poincareDuality, --
        Apply the isomorphism Hom(A^k(X),ZZ) = A_k(X)
      * polymakeConeContains -- Check if a vector
        is contained in a cone using polymake
      * pushforwardMultiplicity -- pushforward
        of Minkowski weights
      * refineMultiplicity -- Compute the
        multiplicities of a refinement of a tropical variety
      * toricCycle -- Creates a ToricCycle
      * toricDivisorFromCycle -- Convert a
        codimension one toric cycle into a toric divisor
      * torusIntersection -- compute the ideal of the
        intersection of a subvariety of a toric variety with the torus
  * Methods
      * "classFromTropical(NormalToricVariety,Ideal)" -- see
        classFromTropical, -- compute a toric cycle of X
        which class is the same as a given subvariety of X
      * "classFromTropicalCox(NormalToricVariety,Ideal)" -- see
        classFromTropicalCox, -- compute a toric cycle of
        X which class is the same as a given subvariety of X
      * "classWonderfulCompactification(Ideal,Ideal)" -- see
        classWonderfulCompactification, --
        compute a toric cycle of X which class is the same as a given
        subvariety of X
      * "classWonderfulCompactification(Ideal,RingElement)" -- see
        classWonderfulCompactification, --
        compute a toric cycle of X which class is the same as a given
        subvariety of X
      * "classWonderfulCompactification(NormalToricVariety,Ideal,Ideal)" -- see
        classWonderfulCompactification,
        -- compute a toric cycle of X which class is the same as a given
        subvariety of X
      * "classWonderfulCompactification(NormalToricVariety,Ideal,RingElement)"
        -- see classWonderfulCompactification,
        -- compute a toric cycle of X which
        class is the same as a given subvariety of X
      * "degCycle(ToricCycle)" -- see degCycle, -- Compute the
        degree of a cycle of maximal codimension
      * "isTransverse(ToricDivisor,List)" -- see isTransverse,
        -- checks transversality of toric divisors and cones
      * "makeTransverse(ToricDivisor,List)" -- see makeTransverse,
        -- Find a divisor linearly equivalent to a toric
        divisor D that is transverse to a given cone C
      * NormalToricVariety _ List -- Create
        toric cycles
      * "poincareDuality(List,NormalToricVariety,ZZ)" -- see
        poincareDuality, -- Apply the isomorphism
        Hom(A^k(X),ZZ) = A_k(X)
      * "poincareMatrix(NormalToricVariety,ZZ)" -- see poincareDuality,
        -- Apply the isomorphism Hom(A^k(X),ZZ) = A_k(X)
      * "polymakeConeContains(List,List)" -- see polymakeConeContains,
        -- Check if a vector is contained in a cone using
        polymake
      * "pushforwardMultiplicity(NormalToricVariety,NormalToricVariety,List,ZZ
        )" -- see pushforwardMultiplicity, --
        pushforward of Minkowski weights
      * "refineMultiplicity(List,Fan,NormalToricVariety)" -- see
        refineMultiplicity, -- Compute the multiplicities
        of a refinement of a tropical variety
      * "refineMultiplicity(TropicalCycle,NormalToricVariety)" -- see
        refineMultiplicity, -- Compute the multiplicities
        of a refinement of a tropical variety
      * support(ToricCycle) -- Get the list of
        cones with non-zero coefficients in the cycle
      * "expression(ToricCycle)" -- see ToricCycle, -- the
        class of a toric cycle on a NormalToricVariety
      * "net(ToricCycle)" -- see ToricCycle, -- the class of
        a toric cycle on a NormalToricVariety
      * "toricCycle(List,List,NormalToricVariety)" -- see toricCycle,
        -- Creates a ToricCycle
      * "toricCycle(List,NormalToricVariety)" -- see toricCycle,
        -- Creates a ToricCycle
      * ToricCycle * ToricCycle, --
        intersection product of two toric cycles
      * "- ToricCycle" -- see ToricCycle + ToricCycle,
        -- perform arithmetic on toric cycles
      * "QQ * ToricCycle" -- see ToricCycle + ToricCycle,
        -- perform arithmetic on toric cycles
      * "QQ * ToricDivisor" -- see ToricCycle + ToricCycle,
        -- perform arithmetic on toric cycles
      * ToricCycle + ToricCycle -- perform
        arithmetic on toric cycles
      * "ToricCycle + ToricDivisor" -- see ToricCycle + ToricCycle,
        -- perform arithmetic on toric cycles
      * "ToricCycle - ToricCycle" -- see ToricCycle + ToricCycle,
        -- perform arithmetic on toric cycles
      * "ToricCycle - ToricDivisor" -- see ToricCycle + ToricCycle,
        -- perform arithmetic on toric cycles
      * "ToricDivisor + ToricCycle" -- see ToricCycle + ToricCycle,
        -- perform arithmetic on toric cycles
      * "ToricDivisor - ToricCycle" -- see ToricCycle + ToricCycle,
        -- perform arithmetic on toric cycles
      * "ZZ * ToricCycle" -- see ToricCycle + ToricCycle,
        -- perform arithmetic on toric cycles
      * ToricCycle == ToricCycle -- equality
        of toric cycles
      * ToricCycle _ List -- Coefficients of toric
        cycle
      * "ToricCycle _ ZZ" -- see ToricCycle _ List,
        -- Coefficients of toric cycle
      * "toricCycle(ToricCycle)" -- see toricCycle(ToricDivisor),
        -- Creates a ToricCycle from a
        ToricDivisor
      * toricCycle(ToricDivisor), --
        Creates a ToricCycle from a ToricDivisor
      * ToricDivisor * List -- restriction of a
        Cartier toric divisor to the orbit closure of a cone
      * "ToricCycle * ToricDivisor" -- see ToricDivisor * ToricCycle,
        -- intersection product of a ToricDivisor
        and ToricCycle
      * ToricDivisor * ToricCycle, --
        intersection product of a ToricDivisor and ToricCycle
      * "toricDivisorFromCycle(ToricCycle)" -- see toricDivisorFromCycle,
        -- Convert a codimension one toric cycle into a
        toric divisor
      * "torusIntersection(NormalToricVariety,Ideal)" -- see
        torusIntersection, -- compute the ideal of the
        intersection of a subvariety of a toric variety with the torus
      * "torusIntersection(NormalToricVariety,Ideal,Ring)" -- see
        torusIntersection, -- compute the ideal of the
        intersection of a subvariety of a toric variety with the torus
      * "torusIntersection(NormalToricVariety,RingElement)" -- see
        torusIntersection, -- compute the ideal of the
        intersection of a subvariety of a toric variety with the torus
      * "torusIntersection(NormalToricVariety,RingElement,Ring)" -- see
        torusIntersection, -- compute the ideal of the
        intersection of a subvariety of a toric variety with the torus
      * variety(ToricCycle) -- Get the ambient
        variety of the cycle
  * Symbols
      * "PoincareMatrix" -- see poincareDuality, --
        Apply the isomorphism Hom(A^k(X),ZZ) = A_k(X)

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

The object TropicalToric, is a package (Macaulay2Doc),
defined in TropicalToric.m2, with auxiliary files in
TropicalToric/.

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

The source of this document is in TropicalToric/TropicalToricDoc.m2:13:0.

classFromTropical -- compute a toric cycle of X which class is the same as a given subvariety of X
**************************************************************************************************

  * Usage:
        classFromTropical(X,I)
  * Inputs:
      * X, a normal toric variety (NormalToricVarieties),
      * I, an ideal (Macaulay2Doc),
  * Outputs:
      * D, a toric cycle,

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

This function calculates a toric cycle which class is the same of a subvariety
of a normal toric variety X, under the hypothesis that X is simplicial. The
subvariety is given by the ideal of its intersection with the torus inside X.

+----------------------------------------------+
|i1 : X = toricProjectiveSpace 3;              |
+----------------------------------------------+
|i2 : R = QQ[x_1 .. x_3];                      |
+----------------------------------------------+
|i3 : I = ideal(x_1+x_2+x_3+1,x_1+2*x_2-x_3+4);|
|                                              |
|o3 : Ideal of R                               |
+----------------------------------------------+
|i4 : classFromTropical(X,I)                   |
|                                              |
|o4 = X                                        |
|      {0, 1}                                  |
|                                              |
|o4 : ToricCycle on X                          |
+----------------------------------------------+

Ways to use classFromTropical:
==============================

  * "classFromTropical(NormalToricVariety,Ideal)"

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

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

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

The source of this document is in TropicalToric/TropicalToricDoc.m2:135:0.

classFromTropicalCox -- compute a toric cycle of X which class is the same as a given subvariety of X
*****************************************************************************************************

  * Usage:
        classFromTropicalCox(X,I)
  * Inputs:
      * X, a normal toric variety (NormalToricVarieties),
      * I, an ideal (Macaulay2Doc),
  * Outputs:
      * D, a toric cycle,

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

This function calculates a toric cycle which class is the same of a subvariety
of a normal toric variety X, under the hypothesis that X is smooth. The
subvariety is given by its homogeneous ideal in the Cox ring of X.

+----------------------------------------------+
|i1 : X = toricProjectiveSpace 3;              |
+----------------------------------------------+
|i2 : S = ring X;                              |
+----------------------------------------------+
|i3 : I = ideal(S_0+S_1+S_2+1,S_0+2*S_1-S_2+4);|
|                                              |
|o3 : Ideal of S                               |
+----------------------------------------------+
|i4 : classFromTropicalCox(X,I)                |
|                                              |
|o4 = X                                        |
|      {0, 1}                                  |
|                                              |
|o4 : ToricCycle on X                          |
+----------------------------------------------+

Ways to use classFromTropicalCox:
=================================

  * "classFromTropicalCox(NormalToricVariety,Ideal)"

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

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

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

The source of this document is in TropicalToric/TropicalToricDoc.m2:239:0.

classWonderfulCompactification -- compute a toric cycle of X which class is the same as a given subvariety of X
***************************************************************************************************************

  * Usage:
        classWonderfulCompactification(X,I,J)
  * Inputs:
      * X, a normal toric variety (NormalToricVarieties),
      * I, an ideal (Macaulay2Doc),
      * J, an ideal (Macaulay2Doc),
  * Outputs:
      * D, a toric cycle,

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

Given a hyperplane inside the torus, given by a linear ideal I, let X be a
normal toric variety which fan is supported on the tropicalization of V(I).
This function calculates a toric cycle which class is the same of a subvariety
of V(I). The subvariety Y of V(I) is given by an ideal J such that Y = V(I+J),
that is Y is the intersection of V(J) and V(I) inside the torus of X. The
purpose of this function is essentially the same as classFromTropical, but it
is optimized to this particular setting. Note that the closure of V(I) inside X
is a wonderful compactification of V(I).

It is possible to explicitly input the toric variety, and this allows to
implicitly specify the building set of the wonderful compactification.

A remarkable example among these is the moduli space of n-marked genus 0 curves
M_0,n. Below, we use this function on M_0,6 to compute one of the 15
Keel-Vermeire divisors.

+-----------------------------------------------------------------------------+
|i1 : R = QQ[x_0..x_8];                                                       |
+-----------------------------------------------------------------------------+
|i2 : I = ideal {-x_0+x_3+x_4, -x_1+x_3+x_5,-x_2+x_3+x_6, -x_0+x_2+x_7,       |
|                                                                             |
|o2 : Ideal of R                                                              |
|-----------------------------------------------------------------------------|
|-x_1+x_2+x_8, -x_0+x_1+1};                                                   |
+-----------------------------------------------------------------------------+
|i3 : X = normalToricVariety fan tropicalVariety I;                           |
+-----------------------------------------------------------------------------+
|i4 : f = x_0*x_1-x_2*x_3;                                                    |
+-----------------------------------------------------------------------------+
|i5 : D = classWonderfulCompactification(X,I,f)                               |
|                                                                             |
|o5 = 2*X    + 2*X     - X     + 2*X     + 2*X     - X     + X    - X    -    |
|        {9}      {10}    {11}      {13}      {14}    {17}    {2}    {5}      |
|                                                                             |
|o5 : ToricCycle on X                                                         |
|-----------------------------------------------------------------------------|
|2*X    + X                                                                   |
|   {6}    {7}                                                                |
+-----------------------------------------------------------------------------+

Ways to use classWonderfulCompactification:
===========================================

  * "classWonderfulCompactification(Ideal,Ideal)"
  * "classWonderfulCompactification(Ideal,RingElement)"
  * "classWonderfulCompactification(NormalToricVariety,Ideal,Ideal)"
  * "classWonderfulCompactification(NormalToricVariety,Ideal,RingElement)"

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

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

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

The source of this document is in TropicalToric/TropicalToricDoc.m2:174:0.

degCycle -- Compute the degree of a cycle of maximal codimension
****************************************************************

  * Usage:
        degCycle(C)
  * Inputs:
      * C, a toric cycle,
  * Outputs:
      * d, an integer (Macaulay2Doc),

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

This function computes the sum of the coefficients of a cycle of maximal
codimension

+----------------------------------------------+
|i1 : rayList={{1,0},{1,1},{0,1},{-1,-1}};     |
+----------------------------------------------+
|i2 : coneList={{0,1},{1,2},{2,3},{3,0}};      |
+----------------------------------------------+
|i3 : X = normalToricVariety(rayList,coneList);|
+----------------------------------------------+
|i4 : C = X_{0,1} + X_{1,2} - 3*X_{2,3}        |
|                                              |
|o4 = - 3*X       + X       + X                |
|          {2, 3}    {0, 1}    {1, 2}          |
|                                              |
|o4 : ToricCycle on X                          |
+----------------------------------------------+
|i5 : degCycle(C)                              |
|                                              |
|o5 = -1                                       |
|                                              |
|o5 : QQ                                       |
+----------------------------------------------+

Ways to use degCycle:
=====================

  * "degCycle(ToricCycle)"

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

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

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

The source of this document is in TropicalToric/ToricCycleDoc.m2:418:0.

isTransverse -- checks transversality of toric divisors and cones
*****************************************************************

  * Usage:
        isTransverse(D,C)
  * Inputs:
      * D, a toric divisor (NormalToricVarieties),
      * C, a list (Macaulay2Doc),
  * Outputs:
      * a Boolean value (Macaulay2Doc),

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

This function tests transversality of toric divisors and cones. Toric divisors
are represented using the ToricDivisor class and cones are represented using
lists.

+---------------------------------------------+
|i1 : rayList={{1,0},{0,1},{-1,-1},{0,-1}}    |
|                                             |
|o1 = {{1, 0}, {0, 1}, {-1, -1}, {0, -1}}     |
|                                             |
|o1 : List                                    |
+---------------------------------------------+
|i2 : coneList={{0,1},{1,2},{2,3},{3,0}}      |
|                                             |
|o2 = {{0, 1}, {1, 2}, {2, 3}, {3, 0}}        |
|                                             |
|o2 : List                                    |
+---------------------------------------------+
|i3 : X = normalToricVariety(rayList,coneList)|
|                                             |
|o3 = X                                       |
|                                             |
|o3 : NormalToricVariety                      |
+---------------------------------------------+
|i4 : D = X_3                                 |
|                                             |
|o4 = X                                       |
|      3                                      |
|                                             |
|o4 : ToricDivisor on X                       |
+---------------------------------------------+
|i5 : E = {0,3}                               |
|                                             |
|o5 = {0, 3}                                  |
|                                             |
|o5 : List                                    |
+---------------------------------------------+
|i6 : F = {1,2}                               |
|                                             |
|o6 = {1, 2}                                  |
|                                             |
|o6 : List                                    |
+---------------------------------------------+
|i7 : isTransverse(D,E)                       |
|                                             |
|o7 = false                                   |
+---------------------------------------------+
|i8 : isTransverse(D,F)                       |
|                                             |
|o8 = true                                    |
+---------------------------------------------+

Ways to use isTransverse:
=========================

  * "isTransverse(ToricDivisor,List)"

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

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

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

The source of this document is in TropicalToric/ToricCycleDoc.m2:29:0.

makeTransverse -- Find a divisor linearly equivalent to a toric divisor D that is transverse to a given cone C
**************************************************************************************************************

  * Usage:
        makeTransverse(D,C)
  * Inputs:
      * D, a toric divisor (NormalToricVarieties),
      * C, a list (Macaulay2Doc),
  * Outputs:
      * D, a toric divisor (NormalToricVarieties),

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

This function calculates a linearly equivalent divisor of a given divisor D
that is transverse to a given cone C.

+--------------------------------------------------------------------+
|i1 : rayList={{1,0},{1,1},{0,1},{-1,-1}};                           |
+--------------------------------------------------------------------+
|i2 : coneList={{0,1},{1,2},{2,3},{3,0}};                            |
+--------------------------------------------------------------------+
|i3 : X = normalToricVariety fan (transpose matrix rayList,coneList);|
+--------------------------------------------------------------------+
|i4 : D = X_0+X_1;                                                   |
|                                                                    |
|o4 : ToricDivisor on X                                              |
+--------------------------------------------------------------------+
|i5 : C = {1,2};                                                     |
+--------------------------------------------------------------------+
|i6 : isTransverse(D,C)                                              |
|                                                                    |
|o6 = false                                                          |
+--------------------------------------------------------------------+
|i7 : makeTransverse(D,C)                                            |
|                                                                    |
|o7 = 2*X  + 0 + 0 + X                                               |
|        0            3                                              |
|                                                                    |
|o7 : ToricDivisor on X                                              |
+--------------------------------------------------------------------+

Ways to use makeTransverse:
===========================

  * "makeTransverse(ToricDivisor,List)"

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

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

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

The source of this document is in TropicalToric/ToricCycleDoc.m2:56:0.

NormalToricVariety _ List -- Create toric cycles
************************************************

  * Operator: _ (Macaulay2Doc),
  * Usage:
        X_L
  * Inputs:
      * X, a normal toric variety (NormalToricVarieties),
      * L, a list (Macaulay2Doc),

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

Create a toric cycle directly from the toric variety

+---------------------------------------------+
|i1 : rayList={{1,0},{0,1},{-1,-1},{0,-1}}    |
|                                             |
|o1 = {{1, 0}, {0, 1}, {-1, -1}, {0, -1}}     |
|                                             |
|o1 : List                                    |
+---------------------------------------------+
|i2 : coneList={{0,1},{1,2},{2,3},{3,0}}      |
|                                             |
|o2 = {{0, 1}, {1, 2}, {2, 3}, {3, 0}}        |
|                                             |
|o2 : List                                    |
+---------------------------------------------+
|i3 : X = normalToricVariety(rayList,coneList)|
|                                             |
|o3 = X                                       |
|                                             |
|o3 : NormalToricVariety                      |
+---------------------------------------------+
|i4 : X_{1}                                   |
|                                             |
|o4 = X                                       |
|      {1}                                    |
|                                             |
|o4 : ToricCycle on X                         |
+---------------------------------------------+
|i5 : X_{0,2}                                 |
|                                             |
|o5 = X                                       |
|      {0, 2}                                 |
|                                             |
|o5 : ToricCycle on X                         |
+---------------------------------------------+
|i6 : 2 * X_{2} - X_{3}                       |
|                                             |
|o6 = 2*X    - X                              |
|        {2}    {3}                           |
|                                             |
|o6 : ToricCycle on X                         |
+---------------------------------------------+

See also
========

  * ToricCycle + ToricCycle -- perform
    arithmetic on toric cycles

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

  * NormalToricVariety _ List -- Create
    toric cycles
-------------------------------------------------------------------------------

The source of this document is in TropicalToric/ToricCycleDoc.m2:368:0.

poincareDuality -- Apply the isomorphism Hom(A^k(X),ZZ) = A_k(X)
****************************************************************

  * Usage:
        poincareDuality(l, X, k)
  * Inputs:
      * l, a list (Macaulay2Doc),
      * X, a normal toric variety (NormalToricVarieties),
      * k, an integer (Macaulay2Doc),
  * Outputs:
      * Y, a list (Macaulay2Doc),

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

This function calculates the list of coefficients of a toric cycle
corresponding to a list of Minkowski weights.

+--------------------------------+
|i1 : X = toricProjectiveSpace 3;|
+--------------------------------+
|i2 : k = 2;                     |
+--------------------------------+
|i3 : l = toList(#orbits(X,1):3) |
|                                |
|o3 = {3, 3, 3, 3, 3, 3}         |
|                                |
|o3 : List                       |
+--------------------------------+
|i4 : poincareDuality(l, X, k)   |
|                                |
|o4 = {3, 0, 0, 0}               |
|                                |
|o4 : List                       |
+--------------------------------+
|i5 : poincareMatrix(X,2)        |
|                                |
|o5 = | 1 1 1 1 |                |
|     | 1 1 1 1 |                |
|     | 1 1 1 1 |                |
|     | 1 1 1 1 |                |
|     | 1 1 1 1 |                |
|     | 1 1 1 1 |                |
|                                |
|              6        4        |
|o5 : Matrix QQ  <--- QQ         |
+--------------------------------+

Ways to use poincareDuality:
============================

  * "poincareDuality(List,NormalToricVariety,ZZ)"

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

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

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

The source of this document is in TropicalToric/TropicalToricDoc.m2:110:0.

polymakeConeContains -- Check if a vector is contained in a cone using polymake
*******************************************************************************

  * Usage:
        polymakeConeContains(v,C)
  * Inputs:
      * v, a list (Macaulay2Doc),
      * C, a list (Macaulay2Doc),
  * Outputs:
      * b, a Boolean value (Macaulay2Doc),

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

This method checks if a vector, given as a list, is contained in a cone, where
the cone is given as a list containing lists representing the vectors spanning
the cone.

+-----------------------------------+
|i1 : v = {1,0,0};                  |
+-----------------------------------+
|i2 : C = {{1,0,0},{0,1,0},{0,0,1}};|
+-----------------------------------+
|i3 : polymakeConeContains(v,C)     |
|                                   |
|o3 = true                          |
+-----------------------------------+
+-----------------------------------+
|i4 : v = {1,0,0};                  |
+-----------------------------------+
|i5 : C = {{2,1,0},{0,1,0},{0,0,1}};|
+-----------------------------------+
|i6 : polymakeConeContains(v,C)     |
|                                   |
|o6 = false                         |
+-----------------------------------+

Ways to use polymakeConeContains:
=================================

  * "polymakeConeContains(List,List)"

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

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

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

The source of this document is in TropicalToric/polymakeContainsDoc.m2:27:0.

pushforwardMultiplicity -- pushforward of Minkowski weights
***********************************************************

  * Usage:
        pushforwardMultiplicity(X,X',mult,k)
  * Inputs:
      * X, a normal toric variety (NormalToricVarieties),
      * X', a normal toric variety (NormalToricVarieties),
      * mult, a list (Macaulay2Doc),
      * k, an integer (Macaulay2Doc),
  * Outputs:
      * prod, a list (Macaulay2Doc), list of intersection products

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

The list mult is the list of multiplicities of the tropicalization of the
intersection of a subvariety Y of X with the torus. The tropicalization has the
fan structure of the fan of X', and k is the dimension of Y. This function
calculates the intersection products of Y and V(sigma), where sigma is a cone
of X of dimension k. This is done by calculating the pullback of V(sigma) in
X', and substituting V(sigma') with m(sigma'), where sigma' is a cone of
dimension k in X'. This is the same as taking the class in X' corresponding to
the Minkowski weights given by Y and computing the Minkowski weights
corresponding to the pushforward of this class on X.

+---------------------------------------------------+
|i1 : X = toricProjectiveSpace 3;                   |
+---------------------------------------------------+
|i2 : R = QQ[x_1 .. x_3];                           |
+---------------------------------------------------+
|i3 : f = x_1*x_2*x_3 + x_1*x_2 + x_1*x_3 + x_2*x_3;|
+---------------------------------------------------+
|i4 : T = tropicalVariety(ideal f);                 |
+---------------------------------------------------+
|i5 : F = gfanFanCommonRefinement(fan X, fan T);    |
+---------------------------------------------------+
|i6 : X' = makeSimplicial (normalToricVariety F);   |
+---------------------------------------------------+
|i7 : mult = refineMultiplicity(T,X');              |
+---------------------------------------------------+
|i8 : pushforwardMultiplicity(X,X',mult,dim T)      |
|                                                   |
|o8 = {3, 3, 3, 3, 3, 3}                            |
|                                                   |
|o8 : List                                          |
+---------------------------------------------------+

Ways to use pushforwardMultiplicity:
====================================

  * "pushforwardMultiplicity(NormalToricVariety,NormalToricVariety,List,ZZ)"

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

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

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

The source of this document is in TropicalToric/TropicalToricDoc.m2:81:0.

refineMultiplicity -- Compute the multiplicities of a refinement of a tropical variety
**************************************************************************************

  * Usage:
        refineMultiplicity(T,X)
  * Inputs:
      * T, a tropical cycle (Tropical),
      * X, a normal toric variety (NormalToricVarieties),
        which fan refines T
  * Outputs:
      * mult, a list (Macaulay2Doc), list of the multiplicities,
        indexed by cones of X of the same dimension of T

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

This function calculate the multiplicities of a refinement of a tropical
variety T. The output is a list of integers indexed by orbits(X,n-k), where k =
dim T, n = dim X and X is the normal toric variety of the refinement.

+---------------------------------------------------+
|i1 : X = toricProjectiveSpace 3;                   |
+---------------------------------------------------+
|i2 : R = QQ[x_1 .. x_3];                           |
+---------------------------------------------------+
|i3 : f = x_1*x_2*x_3 + x_1*x_2 + x_1*x_3 + x_2*x_3;|
+---------------------------------------------------+
|i4 : T = tropicalVariety(ideal f);                 |
+---------------------------------------------------+
|i5 : F = gfanFanCommonRefinement(fan X, fan T);    |
+---------------------------------------------------+
|i6 : X' = makeSimplicial (normalToricVariety F);   |
+---------------------------------------------------+
|i7 : multiplicities T                              |
|                                                   |
|o7 = {1, 1, 1, 1, 1, 1}                            |
|                                                   |
|o7 : List                                          |
+---------------------------------------------------+
|i8 : refineMultiplicity(T,X')                      |
|                                                   |
|o8 = {1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1}          |
|                                                   |
|o8 : List                                          |
+---------------------------------------------------+

Ways to use refineMultiplicity:
===============================

  * "refineMultiplicity(List,Fan,NormalToricVariety)"
  * "refineMultiplicity(TropicalCycle,NormalToricVariety)"

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

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

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

The source of this document is in TropicalToric/TropicalToricDoc.m2:45:0.

support(ToricCycle) -- Get the list of cones with non-zero coefficients in the cycle
************************************************************************************

  * Function: support (Macaulay2Doc),
  * Usage:
        support C
  * Inputs:
      * C, a toric cycle,
  * Outputs:
      * a list (Macaulay2Doc), a list of integer vectors describing
        cones in the fan of variety(C)

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

This function returns the list of cones, corresponding to torus-invariant
cycles, appearing in the support of a ToricCycle.

+-----------------------------------------------------------+
|i1 : X = toricProjectiveSpace 4                            |
|                                                           |
|o1 = X                                                     |
|                                                           |
|o1 : NormalToricVariety                                    |
+-----------------------------------------------------------+
|i2 : Z1 = toricCycle({{0,1} => 3,{0,2} => 7,{1,2} => 82},X)|
|                                                           |
|o2 = 3*X       + 7*X       + 82*X                          |
|        {0, 1}      {0, 2}       {1, 2}                    |
|                                                           |
|o2 : ToricCycle on X                                       |
+-----------------------------------------------------------+
|i3 : Z2 = toricCycle({{0,1} => 4,{0,2} => 5},X)            |
|                                                           |
|o3 = 4*X       + 5*X                                       |
|        {0, 1}      {0, 2}                                 |
|                                                           |
|o3 : ToricCycle on X                                       |
+-----------------------------------------------------------+
|i4 : support Z1                                            |
|                                                           |
|o4 = {{0, 1}, {0, 2}, {1, 2}}                              |
|                                                           |
|o4 : List                                                  |
+-----------------------------------------------------------+
|i5 : support Z2                                            |
|                                                           |
|o5 = {{0, 1}, {0, 2}}                                      |
|                                                           |
|o5 : List                                                  |
+-----------------------------------------------------------+

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

  * support(ToricCycle) -- Get the list of
    cones with non-zero coefficients in the cycle
-------------------------------------------------------------------------------

The source of this document is in TropicalToric/ToricCycleDoc.m2:155:0.

ToricCycle -- the class of a toric cycle on a NormalToricVariety
****************************************************************

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

A toric cycle on X is a finite formal sum of closed torus orbits corresponding
to cones in the fan of X.

Examples can be found on the toricCycle constructor page.

See also
========

  * toricCycle -- Creates a ToricCycle

Functions and methods returning a toric cycle:
==============================================

  * classFromTropical -- compute a toric cycle of X
    which class is the same as a given subvariety of X
  * classWonderfulCompactification, --
    compute a toric cycle of X which class is the same as a given subvariety of
    X
  * toricCycle -- Creates a ToricCycle
  * "- ToricCycle" -- see ToricCycle + ToricCycle,
    -- perform arithmetic on toric cycles
  * "QQ * ToricCycle" -- see ToricCycle + ToricCycle,
    -- perform arithmetic on toric cycles
  * ToricCycle + ToricCycle -- perform
    arithmetic on toric cycles
  * "ToricCycle + ToricDivisor" -- see ToricCycle + ToricCycle,
    -- perform arithmetic on toric cycles
  * "ToricCycle - ToricCycle" -- see ToricCycle + ToricCycle,
    -- perform arithmetic on toric cycles
  * "ToricCycle - ToricDivisor" -- see ToricCycle + ToricCycle,
    -- perform arithmetic on toric cycles
  * "ToricDivisor + ToricCycle" -- see ToricCycle + ToricCycle,
    -- perform arithmetic on toric cycles
  * "ToricDivisor - ToricCycle" -- see ToricCycle + ToricCycle,
    -- perform arithmetic on toric cycles
  * "ZZ * ToricCycle" -- see ToricCycle + ToricCycle,
    -- perform arithmetic on toric cycles
  * ToricCycle _ List -- Coefficients of toric
    cycle
  * "ToricCycle _ ZZ" -- see ToricCycle _ List, --
    Coefficients of toric cycle

Methods that use a toric cycle:
===============================

  * "degCycle(ToricCycle)" -- see degCycle, -- Compute the
    degree of a cycle of maximal codimension
  * support(ToricCycle) -- Get the list of
    cones with non-zero coefficients in the cycle
  * "expression(ToricCycle)"
  * "net(ToricCycle)"
  * ToricCycle * ToricCycle -- intersection
    product of two toric cycles
  * ToricCycle == ToricCycle -- equality of
    toric cycles
  * "toricCycle(ToricCycle)" -- see toricCycle(ToricDivisor),
    -- Creates a ToricCycle from a ToricDivisor
  * "ToricCycle * ToricDivisor" -- see ToricDivisor * ToricCycle,
    -- intersection product of a ToricDivisor and
    ToricCycle
  * ToricDivisor * ToricCycle, --
    intersection product of a ToricDivisor and ToricCycle
  * "toricDivisorFromCycle(ToricCycle)" -- see toricDivisorFromCycle,
    -- Convert a codimension one toric cycle into a
    toric divisor
  * variety(ToricCycle) -- Get the ambient
    variety of the cycle

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

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

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

The source of this document is in TropicalToric/ToricCycleDoc.m2:72:0.

toricCycle -- Creates a ToricCycle
**********************************

  * Usage:
        toricCycle(L,X)
        toricCycle(D)
  * Inputs:
      * L, a list (Macaulay2Doc), a list of options (sigma => d)
        where d is the coefficient of the cycle associated to the cone sigma
      * X, a normal toric variety (NormalToricVarieties),
        the variety the cycle lives
        on
  * Outputs:
      * a toric cycle,

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

Toric cycles can be created with the constructor, and as they form an abelian
group under addition, arithmetic can be done with them.

+-----------------------------------------------+
|i1 : rayList={{1,0},{0,1},{-1,-1},{0,-1}}      |
|                                               |
|o1 = {{1, 0}, {0, 1}, {-1, -1}, {0, -1}}       |
|                                               |
|o1 : List                                      |
+-----------------------------------------------+
|i2 : coneList={{0,1},{1,2},{2,3},{3,0}}        |
|                                               |
|o2 = {{0, 1}, {1, 2}, {2, 3}, {3, 0}}          |
|                                               |
|o2 : List                                      |
+-----------------------------------------------+
|i3 : X = normalToricVariety(rayList,coneList)  |
|                                               |
|o3 = X                                         |
|                                               |
|o3 : NormalToricVariety                        |
+-----------------------------------------------+
|i4 : cyc = toricCycle({{2,3} =>1,{3,0} => 4},X)|
|                                               |
|o4 = X       + 4*X                             |
|      {2, 3}      {3, 0}                       |
|                                               |
|o4 : ToricCycle on X                           |
+-----------------------------------------------+
|i5 : altcyc = (-2)*cyc                         |
|                                               |
|o5 = - 2*X       - 8*X                         |
|          {2, 3}      {3, 0}                   |
|                                               |
|o5 : ToricCycle on X                           |
+-----------------------------------------------+
|i6 : cyc + altcyc                              |
|                                               |
|o6 = - X       - 4*X                           |
|        {2, 3}      {3, 0}                     |
|                                               |
|o6 : ToricCycle on X                           |
+-----------------------------------------------+
|i7 : cyc - altcyc                              |
|                                               |
|o7 = 3*X       + 12*X                          |
|        {2, 3}       {3, 0}                    |
|                                               |
|o7 : ToricCycle on X                           |
+-----------------------------------------------+
|i8 : -cyc                                      |
|                                               |
|o8 = - X       - 4*X                           |
|        {2, 3}      {3, 0}                     |
|                                               |
|o8 : ToricCycle on X                           |
+-----------------------------------------------+

See also
========

  * ToricCycle + ToricCycle -- perform
    arithmetic on toric cycles

Ways to use toricCycle:
=======================

  * "toricCycle(List,List,NormalToricVariety)"
  * "toricCycle(List,NormalToricVariety)"
  * "toricCycle(ToricCycle)" -- see toricCycle(ToricDivisor),
    -- Creates a ToricCycle from a ToricDivisor
  * toricCycle(ToricDivisor) -- Creates a
    ToricCycle from a ToricDivisor

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

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

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

The source of this document is in TropicalToric/ToricCycleDoc.m2:106:0.

ToricCycle * ToricCycle -- intersection product of two toric cycles
*******************************************************************

  * Operator: * (Macaulay2Doc),
  * Usage:
        D*C
  * Inputs:
      * D, a toric cycle,
      * C, a toric cycle,

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

Computes the intersection product of a ToricCycle with another ToricCycle.

+-------------------------------------------------+
|i1 : X = toricProjectiveSpace 5                  |
|                                                 |
|o1 = X                                           |
|                                                 |
|o1 : NormalToricVariety                          |
+-------------------------------------------------+
|i2 : D = X_{0,1}+5*X_{1,3}-X_{2}+2*X_{3}         |
|                                                 |
|o2 = X       - X    + 2*X    + 5*X               |
|      {0, 1}    {2}      {3}      {1, 3}         |
|                                                 |
|o2 : ToricCycle on X                             |
+-------------------------------------------------+
|i3 : C = X_{2,3}                                 |
|                                                 |
|o3 = X                                           |
|      {2, 3}                                     |
|                                                 |
|o3 : ToricCycle on X                             |
+-------------------------------------------------+
|i4 : D*C                                         |
|                                                 |
|o4 = X          + X             + 5*X            |
|      {2, 3, 5}    {0, 1, 2, 3}      {1, 2, 3, 5}|
|                                                 |
|o4 : ToricCycle on X                             |
+-------------------------------------------------+

Self intersection of the exceptional divisor.

+-------------------------------+
|i5 : X = toricProjectiveSpace 2|
|                               |
|o5 = X                         |
|                               |
|o5 : NormalToricVariety        |
+-------------------------------+
|i6 : Y = toricBlowup({0,1},X)  |
|                               |
|o6 = Y                         |
|                               |
|o6 : NormalToricVariety        |
+-------------------------------+
|i7 : D = Y_{3}                 |
|                               |
|o7 = Y                         |
|      {3}                      |
|                               |
|o7 : ToricCycle on Y           |
+-------------------------------+
|i8 : D*D                       |
|                               |
|o8 = - Y                       |
|        {1, 3}                 |
|                               |
|o8 : ToricCycle on Y           |
+-------------------------------+

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

  * ToricCycle * ToricCycle -- intersection
    product of two toric cycles
-------------------------------------------------------------------------------

The source of this document is in TropicalToric/ToricCycleDoc.m2:298:0.

ToricCycle + ToricCycle -- perform arithmetic on toric cycles
*************************************************************

  * Operator: + (Macaulay2Doc),
  * Usage:
        C1 + C2
        C1 - C2
        5*C1
        (1/2)*C1
        -C1
  * Inputs:
      * C1, a toric cycle,
      * C2, a toric cycle,
  * Outputs:
      * a toric cycle,

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

The set of torus-invariant cycles forms an abelian group under addition.  The
basic operations arising from this structure, including addition, subtraction,
negation, and scalar multiplication by integers, are available.

We illustrate a few of the possibilities on one variety.

+------------------------------------------------+
|i1 : rayList={{1,0},{0,1},{-1,-1},{0,-1}}       |
|                                                |
|o1 = {{1, 0}, {0, 1}, {-1, -1}, {0, -1}}        |
|                                                |
|o1 : List                                       |
+------------------------------------------------+
|i2 : coneList={{0,1},{1,2},{2,3},{3,0}}         |
|                                                |
|o2 = {{0, 1}, {1, 2}, {2, 3}, {3, 0}}           |
|                                                |
|o2 : List                                       |
+------------------------------------------------+
|i3 : X = normalToricVariety(rayList,coneList)   |
|                                                |
|o3 = X                                          |
|                                                |
|o3 : NormalToricVariety                         |
+------------------------------------------------+
|i4 : cyc = toricCycle({{2,3} => 1,{3,0} => 4},X)|
|                                                |
|o4 = X       + 4*X                              |
|      {2, 3}      {3, 0}                        |
|                                                |
|o4 : ToricCycle on X                            |
+------------------------------------------------+
|i5 : altcyc = (-2)*cyc                          |
|                                                |
|o5 = - 2*X       - 8*X                          |
|          {2, 3}      {3, 0}                    |
|                                                |
|o5 : ToricCycle on X                            |
+------------------------------------------------+
|i6 : cyc + altcyc                               |
|                                                |
|o6 = - X       - 4*X                            |
|        {2, 3}      {3, 0}                      |
|                                                |
|o6 : ToricCycle on X                            |
+------------------------------------------------+
|i7 : cyc - altcyc                               |
|                                                |
|o7 = 3*X       + 12*X                           |
|        {2, 3}       {3, 0}                     |
|                                                |
|o7 : ToricCycle on X                            |
+------------------------------------------------+
|i8 : -cyc                                       |
|                                                |
|o8 = - X       - 4*X                            |
|        {2, 3}      {3, 0}                      |
|                                                |
|o8 : ToricCycle on X                            |
+------------------------------------------------+
|i9 : X_{0} + X_{1}                              |
|                                                |
|o9 = X    + X                                   |
|      {0}    {1}                                |
|                                                |
|o9 : ToricCycle on X                            |
+------------------------------------------------+
|i10 : 2*X_{0,1} - X_{0,2}                       |
|                                                |
|o10 = 2*X       - X                             |
|         {0, 1}    {0, 2}                       |
|                                                |
|o10 : ToricCycle on X                           |
+------------------------------------------------+

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

  * ToricCycle + ToricCycle -- perform
    arithmetic on toric cycles
  * "ToricCycle + ToricDivisor"
  * "ToricDivisor + ToricCycle"
-------------------------------------------------------------------------------

The source of this document is in TropicalToric/ToricCycleDoc.m2:344:0.

ToricCycle == ToricCycle -- equality of toric cycles
****************************************************

  * Operator: == (Macaulay2Doc),
  * Usage:
        C == D
  * Inputs:
      * C, a toric cycle,
      * D, a toric cycle,
  * Outputs:
      * a Boolean value (Macaulay2Doc),

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

This function checks whether the varieties of both cycles are the same, and
whether the coefficients in each orbit of the toric variety are the same in
both toric cycles.

+---------------------------------------------+
|i1 : rayList={{1,0},{0,1},{-1,-1},{0,-1}}    |
|                                             |
|o1 = {{1, 0}, {0, 1}, {-1, -1}, {0, -1}}     |
|                                             |
|o1 : List                                    |
+---------------------------------------------+
|i2 : coneList={{0,1},{1,2},{2,3},{3,0}}      |
|                                             |
|o2 = {{0, 1}, {1, 2}, {2, 3}, {3, 0}}        |
|                                             |
|o2 : List                                    |
+---------------------------------------------+
|i3 : X = normalToricVariety(rayList,coneList)|
|                                             |
|o3 = X                                       |
|                                             |
|o3 : NormalToricVariety                      |
+---------------------------------------------+
|i4 : D = X_3                                 |
|                                             |
|o4 = X                                       |
|      3                                      |
|                                             |
|o4 : ToricDivisor on X                       |
+---------------------------------------------+
|i5 : D*{2} == toricCycle({{2,3} => 1},X)     |
|                                             |
|o5 = true                                    |
+---------------------------------------------+
|i6 : D*{1} == toricCycle({},X)               |
|                                             |
|o6 = true                                    |
+---------------------------------------------+

The elements of the list in the constructor of toric cycle must be in order.
For example, the following example has {3,0} instead of {0,3}.

+----------------------------------------+
|i7 : D*{0} == toricCycle({{0,3} => 1},X)|
|                                        |
|o7 = true                               |
+----------------------------------------+

See also
========

  * ToricDivisor * List (missing documentation)

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

  * ToricCycle == ToricCycle -- equality of
    toric cycles
-------------------------------------------------------------------------------

The source of this document is in TropicalToric/ToricCycleDoc.m2:241:0.

ToricCycle _ List -- Coefficients of toric cycle
************************************************

  * Operator: _ (Macaulay2Doc),
  * Usage:
        C_L
  * Inputs:
      * C, a toric cycle,
      * L, a list (Macaulay2Doc),
  * Outputs:
      * a toric cycle,

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

Another way to get the coefficients of a cycle C

+----------------------------------------------+
|i1 : rayList={{1,0},{0,1},{-1,-1},{0,-1}}     |
|                                              |
|o1 = {{1, 0}, {0, 1}, {-1, -1}, {0, -1}}      |
|                                              |
|o1 : List                                     |
+----------------------------------------------+
|i2 : coneList={{0,1},{1,2},{2,3},{3,0}}       |
|                                              |
|o2 = {{0, 1}, {1, 2}, {2, 3}, {3, 0}}         |
|                                              |
|o2 : List                                     |
+----------------------------------------------+
|i3 : X = normalToricVariety(rayList,coneList) |
|                                              |
|o3 = X                                        |
|                                              |
|o3 : NormalToricVariety                       |
+----------------------------------------------+
|i4 : C = X_{0,1} + X_{0,2} - 2*X_{0,3} + X_{0}|
|                                              |
|o4 = X    + X       + X       - 2*X           |
|      {0}    {0, 1}    {0, 2}      {0, 3}     |
|                                              |
|o4 : ToricCycle on X                          |
+----------------------------------------------+
|i5 : C_{0,1}                                  |
|                                              |
|o5 = 1                                        |
+----------------------------------------------+
|i6 : C_{0,2}                                  |
|                                              |
|o6 = 1                                        |
+----------------------------------------------+
|i7 : C_{0,3}                                  |
|                                              |
|o7 = -2                                       |
|                                              |
|o7 : QQ                                       |
+----------------------------------------------+
|i8 : C_0                                      |
|                                              |
|o8 = 1                                        |
+----------------------------------------------+

See also
========

  * ToricCycle + ToricCycle -- perform
    arithmetic on toric cycles

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

  * ToricCycle _ List -- Coefficients of toric
    cycle
  * "ToricCycle _ ZZ"
-------------------------------------------------------------------------------

The source of this document is in TropicalToric/ToricCycleDoc.m2:395:0.

toricCycle(ToricDivisor) -- Creates a ToricCycle from a ToricDivisor
********************************************************************

  * Function: toricCycle,
  * Usage:
        toricCycle(D)
  * Inputs:
      * D, a toric divisor (NormalToricVarieties),
  * Outputs:
      * a toric cycle,

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

This method converts a ToricDivisor into a ToricCycle.

+--------------------------------+
|i1 : X = toricProjectiveSpace 3;|
+--------------------------------+
|i2 : toricCycle(X_0)            |
|                                |
|o2 = X                          |
|      {0}                       |
|                                |
|o2 : ToricCycle on X            |
+--------------------------------+
|i3 : toricCycle(X_1+X_2)        |
|                                |
|o3 = X    + X                   |
|      {1}    {2}                |
|                                |
|o3 : ToricCycle on X            |
+--------------------------------+

See also
========

  * ToricCycle + ToricCycle -- perform
    arithmetic on toric cycles

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

  * "toricCycle(ToricCycle)"
  * toricCycle(ToricDivisor) -- Creates a
    ToricCycle from a ToricDivisor
-------------------------------------------------------------------------------

The source of this document is in TropicalToric/ToricCycleDoc.m2:129:0.

ToricDivisor * List -- restriction of a Cartier toric divisor to the orbit closure of a cone
********************************************************************************************

  * Operator: * (Macaulay2Doc),
  * Usage:
        D*C
  * Inputs:
      * D, a toric divisor (NormalToricVarieties),
      * C, a list (Macaulay2Doc),
  * Outputs:
      * a toric cycle, Returns the toric cycle given by
        restricting a Cartier toric divisor to the orbit closure of the given
        cone

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

+---------------------------------------------+
|i1 : rayList={{1,0},{0,1},{-1,-1},{0,-1}}    |
|                                             |
|o1 = {{1, 0}, {0, 1}, {-1, -1}, {0, -1}}     |
|                                             |
|o1 : List                                    |
+---------------------------------------------+
|i2 : coneList={{0,1},{1,2},{2,3},{3,0}}      |
|                                             |
|o2 = {{0, 1}, {1, 2}, {2, 3}, {3, 0}}        |
|                                             |
|o2 : List                                    |
+---------------------------------------------+
|i3 : X = normalToricVariety(rayList,coneList)|
|                                             |
|o3 = X                                       |
|                                             |
|o3 : NormalToricVariety                      |
+---------------------------------------------+
|i4 : D = X_3                                 |
|                                             |
|o4 = X                                       |
|      3                                      |
|                                             |
|o4 : ToricDivisor on X                       |
+---------------------------------------------+

The only cone containing rays 2 and 3 is the cone {2,3}. There is no cone
containing rows 1 and 3.

+--------------------+
|i5 : D*{2}          |
|                    |
|o5 = X              |
|      {2, 3}        |
|                    |
|o5 : ToricCycle on X|
+--------------------+
|i6 : D*{1}          |
|                    |
|o6 = 0              |
|                    |
|o6 : ToricCycle on X|
+--------------------+

This can also compute more complicated sums.

+------------------------------------+
|i7 : D = X_0 + 2*X_1 + 3*X_2 + 4*X_3|
|                                    |
|o7 = X  + 2*X  + 3*X  + 4*X         |
|      0      1      2      3        |
|                                    |
|o7 : ToricDivisor on X              |
+------------------------------------+
|i8 : C = (orbits X)#1#0             |
|                                    |
|o8 = {0}                            |
|                                    |
|o8 : List                           |
+------------------------------------+
|i9 : D*C                            |
|                                    |
|o9 = 6*X                            |
|        {0, 3}                      |
|                                    |
|o9 : ToricCycle on X                |
+------------------------------------+

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

  * ToricDivisor * List -- restriction of a
    Cartier toric divisor to the orbit closure of a cone
-------------------------------------------------------------------------------

The source of this document is in TropicalToric/ToricCycleDoc.m2:210:0.

ToricDivisor * ToricCycle -- intersection product of a ToricDivisor and ToricCycle
**********************************************************************************

  * Operator: * (Macaulay2Doc),
  * Usage:
        D*C
        C*D
  * Inputs:
      * D, a toric divisor (NormalToricVarieties),
      * C, a toric cycle,

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

Computes the intersection product of a ToricDivisor with a ToricCycle.

+-------------------------------+
|i1 : X = toricProjectiveSpace 4|
|                               |
|o1 = X                         |
|                               |
|o1 : NormalToricVariety        |
+-------------------------------+
|i2 : D = X_0+2*X_1+3*X_2+4*X_3 |
|                               |
|o2 = X  + 2*X  + 3*X  + 4*X    |
|      0      1      2      3   |
|                               |
|o2 : ToricDivisor on X         |
+-------------------------------+
|i3 : C = X_{2,3}               |
|                               |
|o3 = X                         |
|      {2, 3}                   |
|                               |
|o3 : ToricCycle on X           |
+-------------------------------+
|i4 : D*C                       |
|                               |
|o4 = 10*X                      |
|         {1, 2, 3}             |
|                               |
|o4 : ToricCycle on X           |
+-------------------------------+

Self intersection of the exceptional divisor.

+-------------------------------+
|i5 : X = toricProjectiveSpace 2|
|                               |
|o5 = X                         |
|                               |
|o5 : NormalToricVariety        |
+-------------------------------+
|i6 : Y = toricBlowup({0,1},X)  |
|                               |
|o6 = Y                         |
|                               |
|o6 : NormalToricVariety        |
+-------------------------------+
|i7 : D = Y_3                   |
|                               |
|o7 = Y                         |
|      3                        |
|                               |
|o7 : ToricDivisor on Y         |
+-------------------------------+
|i8 : C = Y_{3}                 |
|                               |
|o8 = Y                         |
|      {3}                      |
|                               |
|o8 : ToricCycle on Y           |
+-------------------------------+
|i9 : D*C                       |
|                               |
|o9 = - Y                       |
|        {1, 3}                 |
|                               |
|o9 : ToricCycle on Y           |
+-------------------------------+

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

  * "ToricCycle * ToricDivisor"
  * ToricDivisor * ToricCycle, --
    intersection product of a ToricDivisor and ToricCycle
-------------------------------------------------------------------------------

The source of this document is in TropicalToric/ToricCycleDoc.m2:271:0.

toricDivisorFromCycle -- Convert a codimension one toric cycle into a toric divisor
***********************************************************************************

  * Usage:
        degCycle(C)
  * Inputs:
      * C, a toric cycle,
  * Outputs:
      * d, an integer (Macaulay2Doc),

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

+--------------------------------+
|i1 : X = toricProjectiveSpace 2;|
+--------------------------------+
|i2 : D = X_{0} + X_{1};         |
|                                |
|o2 : ToricCycle on X            |
+--------------------------------+
|i3 : toricDivisorFromCycle D    |
|                                |
|o3 = X  + X                     |
|      0    1                    |
|                                |
|o3 : ToricDivisor on X          |
+--------------------------------+

Ways to use toricDivisorFromCycle:
==================================

  * "toricDivisorFromCycle(ToricCycle)"

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

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

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

The source of this document is in TropicalToric/ToricCycleDoc.m2:437:0.

torusIntersection -- compute the ideal of the intersection of a subvariety of a toric variety with the torus
************************************************************************************************************

  * Usage:
        torusIntersection(X,I)
  * Inputs:
      * X, a normal toric variety (NormalToricVarieties),
      * I, an ideal (Macaulay2Doc), inside the Cox ring of X
  * Outputs:
      * J, an ideal (Macaulay2Doc),

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

This function calculates the ideal of the intersection of subavariety of a
toric variety X with the torus of X. The output is a ideal (saturated with
respect to the product of variables) inside the Laurent ring of the torus. The
subvariety of X is given by its ideal in the Cox ring. It applies the
isomorphism of the Laurent polynomials with the degree zero part of the
localization with respect to the product of variables of the Cox ring.

+-----------------------------------------------------------------------------+
|i1 : X = NormalToricVarieties$cartesianProduct apply((1,1), i->              |
|-----------------------------------------------------------------------------|
|toricProjectiveSpace i);                                                     |
+-----------------------------------------------------------------------------+
|i2 : S = ring X;                                                             |
+-----------------------------------------------------------------------------+
|i3 : f = 2 * S_1 + 3 * S_3 + S_0;                                            |
+-----------------------------------------------------------------------------+
|i4 : torusIntersection(X,f)                                                  |
|                                                                             |
|o4 = 2y  + 3y  + 1                                                           |
|       1     2                                                               |
|                                                                             |
|o4 : QQ[y ..y ]                                                              |
|         1   2                                                               |
+-----------------------------------------------------------------------------+
|i5 : torusIntersection(X,ideal(f))                                           |
|                                                                             |
|o5 = ideal(2y  + 3y  + 1)                                                    |
|             1     2                                                         |
|                                                                             |
|o5 : Ideal of QQ[y ..y ]                                                     |
|                  1   2                                                      |
+-----------------------------------------------------------------------------+
+---------------------------------------------------------+
|i6 : X = toricProjectiveSpace 3;                         |
+---------------------------------------------------------+
|i7 : S = ring X;                                         |
+---------------------------------------------------------+
|i8 : f = S_0*S_1*S_2+S_0*S_1*S_3+S_0*S_2*S_3+S_1*S_2*S_3;|
+---------------------------------------------------------+
|i9 : torusIntersection(X,f)                              |
|                                                         |
|o9 = y y y  + y y  + y y  + y y                          |
|      1 2 3    1 2    1 3    2 3                         |
|                                                         |
|o9 : QQ[y ..y ]                                          |
|         1   3                                           |
+---------------------------------------------------------+
|i10 : I = ideal((S_1+S_2)*S_0, (S_1+S_2)*(S_0+S_1));     |
|                                                         |
|o10 : Ideal of S                                         |
+---------------------------------------------------------+
|i11 : torusIntersection(X,I)                             |
|                                                         |
|o11 = ideal(y  + y )                                     |
|             1    2                                      |
|                                                         |
|o11 : Ideal of QQ[y ..y ]                                |
|                   1   3                                 |
+---------------------------------------------------------+

Ways to use torusIntersection:
==============================

  * "torusIntersection(NormalToricVariety,Ideal)"
  * "torusIntersection(NormalToricVariety,Ideal,Ring)"
  * "torusIntersection(NormalToricVariety,RingElement)"
  * "torusIntersection(NormalToricVariety,RingElement,Ring)"

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

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

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

The source of this document is in TropicalToric/TropicalToricDoc.m2:213:0.

variety(ToricCycle) -- Get the ambient variety of the cycle
***********************************************************

  * Function: variety (Varieties),
  * Usage:
        variety C
  * Inputs:
      * C, a toric cycle,
  * Outputs:
      * a variety (Varieties),

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

This function returns the underlying toric variety of the toric cycle.

+----------------------------------------------------------+
|i1 : X = toricProjectiveSpace 2                           |
|                                                          |
|o1 = X                                                    |
|                                                          |
|o1 : NormalToricVariety                                   |
+----------------------------------------------------------+
|i2 : Z = toricCycle({{0,1} => 3,{0,2} => 7,{1,2} => 82},X)|
|                                                          |
|o2 = 3*X       + 7*X       + 82*X                         |
|        {0, 1}      {0, 2}       {1, 2}                   |
|                                                          |
|o2 : ToricCycle on X                                      |
+----------------------------------------------------------+
|i3 : variety Z                                            |
|                                                          |
|o3 = X                                                    |
|                                                          |
|o3 : NormalToricVariety                                   |
+----------------------------------------------------------+

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

  * variety(ToricCycle) -- Get the ambient
    variety of the cycle
-------------------------------------------------------------------------------

The source of this document is in TropicalToric/ToricCycleDoc.m2:176:0.