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

IncidenceCorrespondenceCohomology -- Cohomology on the incidence correspondence, bundle of principal parts, Han-Monsky multiplication, and Lefschetz properties
***************************************************************************************************************************************************************

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

This package computes the sheaf cohomology of line bundles on the incidence
correspondence, the torus equivariant splitting type of the bundle of principal
parts for $\mathcal{O}(d)$ on $\mathbb{P}^1$, the multiplication in the graded
Han-Monsky representation ring, and checks the Weak Lefschetz property.

This Macaulay2 package implements algorithms based on the theoretical results
from

  * Annet Kyomuhangi, Emanuela Marangone, Claudiu Raicu, and Ethan Reed,
    Cohomology on the incidence correspondence and related questions,
    https://arxiv.org/abs/2411.13450  arXiv, 2024
  * Annet Kyomuhangi, Emanuela Marangone, Claudiu Raicu, and Ethan Reed,
    Computing the cohomology of line bundles on the incidence correspondence
    and related invariants,arXiv, 2025

This package also checks Strong Lefschetz Property in positive characteristic
based on the classification from

  * Lisa Nicklasson, The strong Lefschetz property of monomial complete
    intersections in two variables, Collectanea Mathematica, 2018

Notation:

We indicate $\Omega$ the tangent bundle on $\mathbb{P}^{n-1}$, and with
$\mathcal{R}=\Omega(1)$ the universal rank (n-1) subsheaf. $D^d \mathcal{R}$
denotes the d-th divided power of $\mathcal{R}$.

We indicate the incidence correspondence with $X$. Each line bundle on $X$ is
the restriction of a line bundle on $\mathbb{P}\times\mathbb{P}^\vee$: we
denote with $\mathcal{O}_X(a,b)$ the restriction to $X$ of the line bundle
$\mathcal{O}(a)\times\mathcal{O}(b)$.

Authors
=======

  * Annet Kyomuhangi (see https://people.busitema.ac.ug/staff/academic-staff/
    annet-kyomuhangi ) <annet.kyomuhangi@gmail.com>
  * Emanuela Marangone (see https://emanuelamarangone.wixsite.com/marangone )
    <emanuela.marangone@umanitoba.ca>
  * Claudiu Raicu (see https://www3.nd.edu/~craicu/ ) <craicu@nd.edu>
  * Ethan Reed (see https://sites.google.com/view/ethan-reed/home )
    <ereed4@nd.edu>

Version
=======

This documentation describes version 0.1 of IncidenceCorrespondenceCohomology,
released February 2, 2024.

Citation
========

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

+-----------------------------------------------------------------------------+
|@misc{IncidenceCorrespondenceCohomologySource,                               |
|  title = {{IncidenceCorrespondenceCohomology: A \emph{Macaulay2} package.   |
|  author = {Annet Kyomuhangi and Emanuela Marangone and Claudiu Raicu and    |
|  howpublished = {A \emph{Macaulay2} package available at                    |
|    \url{https://github.com/Macaulay2/M2/tree/stable/M2/Macaulay2/packages   |
|}                                                                            |
|-----------------------------------------------------------------------------|
| Version~0.1}},                                                              |
|Ethan Reed},                                                                 |
|                                                                             |
|}}                                                                           |
+-----------------------------------------------------------------------------+

Exports
=======

  * Functions and commands
      * hanMonsky -- Computes the multiplication in the
        graded Han-Monsky representation ring
      * hasSLP -- Checks whether a monomial complete
        intersection over a field of characteristic p has the Strong Lefschetz
        Property (SLP)
      * hasWLP -- Checks whether a graded Artinian algebra has
        the Weak Lefschetz Property (WLP)
      * incidenceCohomology -- Computes dimension
        or character of sheaf cohomology of line bundles on the incidence
        correspondence
      * monomialCIsWithoutWLP -- Lists all the
        monomial complete intersections of socle s and height n that fail the
        Weak Lefschetz Property
      * nimDividedCohomology -- Computes the
        dimension or character of sheaf cohomology of twists of divided powers
        of the cotangent sheaf on projective space, in characteristic 2
      * recursiveDividedCohomology, --
        Computes dimension or character of sheaf cohomology of twists of
        divided powers of the cotangent sheaf on projective space
      * splittingFdr -- Computes the torus equivariant
        splitting type of the bundles $\mathcal{F}^d_r$ introduced in [KMRR,24]
      * splittingPrincipalParts -- Computes the
        torus equivariant splitting type of the bundle of principal parts on
        $\mathbb{P}^1$
  * Methods
      * "hanMonsky(ZZ,List)" -- see hanMonsky, -- Computes the
        multiplication in the graded Han-Monsky representation ring
      * "hasSLP(ZZ,List)" -- see hasSLP, -- Checks whether a
        monomial complete intersection over a field of characteristic p has the
        Strong Lefschetz Property (SLP)
      * "hasWLP(PolynomialRing,Ideal)" -- see hasWLP, -- Checks
        whether a graded Artinian algebra has the Weak Lefschetz Property (WLP)
      * "hasWLP(ZZ,List)" -- see hasWLP, -- Checks whether a
        graded Artinian algebra has the Weak Lefschetz Property (WLP)
      * "incidenceCohomology(List)" -- see incidenceCohomology,
        -- Computes dimension or character of sheaf
        cohomology of line bundles on the incidence correspondence
      * "incidenceCohomology(List,PolynomialRing)" -- see
        incidenceCohomology, -- Computes dimension or
        character of sheaf cohomology of line bundles on the incidence
        correspondence
      * "monomialCIsWithoutWLP(ZZ,ZZ,ZZ)" -- see monomialCIsWithoutWLP,
        -- Lists all the monomial complete intersections
        of socle s and height n that fail the Weak Lefschetz Property
      * "nimDividedCohomology(ZZ,ZZ,ZZ,PolynomialRing)" -- see
        nimDividedCohomology, -- Computes the dimension
        or character of sheaf cohomology of twists of divided powers of the
        cotangent sheaf on projective space, in characteristic 2
      * "nimDividedCohomology(ZZ,ZZ,ZZ,ZZ)" -- see nimDividedCohomology,
        -- Computes the dimension or character of sheaf
        cohomology of twists of divided powers of the cotangent sheaf on
        projective space, in characteristic 2
      * "recursiveDividedCohomology(List)" -- see
        recursiveDividedCohomology, -- Computes
        dimension or character of sheaf cohomology of twists of divided powers
        of the cotangent sheaf on projective space
      * "recursiveDividedCohomology(List,PolynomialRing)" -- see
        recursiveDividedCohomology, -- Computes
        dimension or character of sheaf cohomology of twists of divided powers
        of the cotangent sheaf on projective space
      * "splittingFdr(ZZ,ZZ,ZZ)" -- see splittingFdr, --
        Computes the torus equivariant splitting type of the bundles
        $\mathcal{F}^d_r$ introduced in [KMRR,24]
      * "splittingPrincipalParts(ZZ,ZZ,ZZ)" -- see
        splittingPrincipalParts, -- Computes the torus
        equivariant splitting type of the bundle of principal parts on
        $\mathbb{P}^1$
  * Symbols
      * FindCharacter -- An option to compute the
        character instead of the dimension
      * GorensteinAlg -- An option to check the WLP for
        Gorenstein algebras
      * MonomialAlg -- An option to check the WLP for R/I
        with I Monomial ideal
      * Multidegree -- An option to compute the
        multidegrees arising from a torus action on $\mathbb{P}^1$
      * UseConjecture -- An option that, whenever the
        Han-Monsky is computed, allows the user to choose if employ Conjecture
        4.1 [KMRR,25] or not

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

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

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

The source of this document is in IncidenceCorrespondenceCohomology.m2:1226:0.

splittingFdr -- Computes the torus equivariant splitting type of the bundles $\mathcal{F}^d_r$ introduced in [KMRR,24]
**********************************************************************************************************************

  * Usage:
        L = splittingFdr(p,d,r)
  * Inputs:
      * p, an integer (Macaulay2Doc), prime or zero, characteristic
        of the field
      * d, an integer (Macaulay2Doc), twist of the line bundle
      * r, an integer (Macaulay2Doc), which bundle of principal part
  * Optional inputs (Macaulay2Doc),:
      * Multidegree, => ..., default value false, An option
        to compute the multidegrees arising from a torus action on
        $\mathbb{P}^1$
  * Outputs:
      * L, a list (Macaulay2Doc), list which gives the splitting
        type as a direct sum of line bundles for $\mathcal{F}^d_r$ in
        characteristic p By default, only the twists appear in the list, but if
        Multidegree is set to true then it returns a list of list of three
        integers: the first is the twist while the second and third are the
        multidegrees

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

This function computes the splitting type as a direct sum of line bundles for
$\mathcal{F}^d_r$ over a field of characteristic p using Theorem 3.2 [KMRR,24].

The user inputs the prime p and the integers d and r.

The output is a list whose entries are either integers if Multidegree is false,
or lists of three integers if Multidegree is true. When Multidegree is false,
the integers in the list are the twists for the line bundles occurring in the
decomposition. When Multidegree is true, for each element of the list, the
first entry is the corresponding twist for the line bundle, and the second and
third entries are the multidegrees arising from a torus action upon choosing
coordinates for $\mathbb{P^1}$.

+----------------------------+
|i1 : p = 5;                 |
+----------------------------+
|i2 : d = 8; r = 6;          |
+----------------------------+
|i4 : splittingFdr(p,d,r)    |
|                            |
|o4 = {-3, -3, -4, -4, -4, 0}|
|                            |
|o4 : List                   |
+----------------------------+

We compute the same example but now we also see the multidegrees.

+----------------------------------------------------------------------------+
|i5 : p = 5;                                                                 |
+----------------------------------------------------------------------------+
|i6 : d = 8; r= 6;                                                           |
+----------------------------------------------------------------------------+
|i8 : splittingFdr(p,d,r, Multidegree=>true)                                 |
|                                                                            |
|o8 = {{-3, 8, 3}, {-3, 3, 8}, {-4, 7, 5}, {-4, 6, 6}, {-4, 5, 7}, {0, 4, 4}}|
|                                                                            |
|o8 : List                                                                   |
+----------------------------------------------------------------------------+
+-----------------------------------------------------------------------------+
|i9 : p = 0;                                                                  |
+-----------------------------------------------------------------------------+
|i10 : d = 8; r= 6;                                                           |
+-----------------------------------------------------------------------------+
|i12 : splittingFdr(p,d,r, Multidegree=>true)                                 |
|                                                                             |
|o12 = {{-3, 8, 3}, {-3, 7, 4}, {-3, 6, 5}, {-3, 5, 6}, {-3, 4, 7}, {-3, 3,   |
|      -----------------------------------------------------------------------|
|      8}}                                                                    |
|                                                                             |
|o12 : List                                                                   |
+-----------------------------------------------------------------------------+

Ways to use splittingFdr:
=========================

  * "splittingFdr(ZZ,ZZ,ZZ)"

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

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

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

The source of this document is in IncidenceCorrespondenceCohomology.m2:1277:0.

splittingPrincipalParts -- Computes the torus equivariant splitting type of the bundle of principal parts on $\mathbb{P}^1$
***************************************************************************************************************************

  * Usage:
        L = splittingPrincipalParts(p,m,k)
  * Inputs:
      * p, an integer (Macaulay2Doc), prime or zero, characteristic
        of the field
      * m, an integer (Macaulay2Doc), twist of line bundle
      * k, an integer (Macaulay2Doc), which bundle of principal part
  * Optional inputs (Macaulay2Doc),:
      * Multidegree, => ..., default value false, An option
        to compute the multidegrees arising from a torus action on
        $\mathbb{P}^1$
  * Outputs:
      * L, a list (Macaulay2Doc), list which gives the splitting
        type as a direct sum of line bundles for the k-th bundle of principal
        parts $\mathcal{P}^k(\mathcal{O}(m))$ on $\mathbb{P}^1$ in
        characteristic p By default, only the twists appear in the list, but if
        Multidegree is set to true then it returns a list of list of three
        integers the first being the twist and the second and third being
        multidegrees

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

This function computes the splitting type as a direct sum of line bundles of
the k-th bundle of principal parts for $\mathcal{O}(m)$ on $\mathbb{P}^1$ over
a field of characteristic p using the relationship between
$\mathcal{P}^k(\mathcal{O}(m))$ and the bundle $\mathcal{F}^d_r$ as described
in [KMRR,24].

The user inputs the prime p and the integers m and k.

The output is a list whose entries are either integers if Multidegree is false,
or lists of three integers if Multidegree is true. When Multidegree is false,
the integers in the list are the twists for the line bundles occurring in the
decomposition. When Multidegree is true, for each element of the list, the
first entry is the corresponding twist for the line bundle, and the second and
third entries are the multidegrees arising from a torus action upon choosing
coordinates for $\mathbb{P}^1$.

+-----------------------------------+
|i1 : p = 5;                        |
+-----------------------------------+
|i2 : m = 10; k = 7;                |
+-----------------------------------+
|i4 : splittingPrincipalParts(p,m,k)|
|                                   |
|o4 = {5, 2, 2, 5, 2, 2, 3, 3}      |
|                                   |
|o4 : List                          |
+-----------------------------------+
+-----------------------------------+
|i5 : p = 0;                        |
+-----------------------------------+
|i6 : m = 10; k = 7;                |
+-----------------------------------+
|i8 : splittingPrincipalParts(p,m,k)|
|                                   |
|o8 = {3, 3, 3, 3, 3, 3, 3, 3}      |
|                                   |
|o8 : List                          |
+-----------------------------------+

We compute the same example but now we also compute the multidegrees.

+-----------------------------------------------------------------------------+
|i9 : p = 5;                                                                  |
+-----------------------------------------------------------------------------+
|i10 : m = 10; r= 7;                                                          |
+-----------------------------------------------------------------------------+
|i12 : splittingPrincipalParts(p,m,k, Multidegree=>true)                      |
|                                                                             |
|o12 = {{5, 0, 5}, {2, 1, 7}, {2, 2, 6}, {5, 5, 0}, {2, 6, 2}, {2, 7, 1}, {3, |
|      -----------------------------------------------------------------------|
|      3, 4}, {3, 4, 3}}                                                      |
|                                                                             |
|o12 : List                                                                   |
+-----------------------------------------------------------------------------+

Ways to use splittingPrincipalParts:
====================================

  * "splittingPrincipalParts(ZZ,ZZ,ZZ)"

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

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

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

The source of this document is in IncidenceCorrespondenceCohomology.m2:1323:0.

Multidegree -- An option to compute the multidegrees arising from a torus action on $\mathbb{P}^1$
**************************************************************************************************

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

The default value is false. When defined to be true, the function will output
the multidegrees in addition to the twist of line bundles occurring in the
decomposition.

See also
========

  * splittingFdr -- Computes the torus equivariant
    splitting type of the bundles $\mathcal{F}^d_r$ introduced in [KMRR,24]
  * splittingPrincipalParts -- Computes the
    torus equivariant splitting type of the bundle of principal parts on
    $\mathbb{P}^1$

Functions with optional argument named Multidegree:
===================================================

  * "splittingFdr(...,Multidegree=>...)"
  * "splittingPrincipalParts(...,Multidegree=>...)"

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

The object Multidegree, is a symbol (Macaulay2Doc).

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

The source of this document is in IncidenceCorrespondenceCohomology.m2:1341:0.

hanMonsky -- Computes the multiplication in the graded Han-Monsky representation ring
*************************************************************************************

  * Usage:
        HM = hanMonsky(p, L)
  * Inputs:
      * p, an integer (Macaulay2Doc), prime or zero, characteristic
        of the field
      * L, a list (Macaulay2Doc), list of integers $a_1,...,a_n$
  * Optional inputs (Macaulay2Doc),:
      * UseConjecture, => ..., default value true, An
        option that, whenever the Han-Monsky is computed, allows the user to
        choose if employ Conjecture 4.1 [KMRR,25] or not
  * Outputs:
      * MH, a hash table (Macaulay2Doc), Hash Table
        representing the product
        $\delta_{a_1}*\delta_{a_2}*....*\delta_{a_n}$: each pair on the Hash
        Table is of the form {c => $f(q)$} where $f(q)$ is a polynomial in
        ZZ[q] with non-negative coefficients such that $b$ $q^j$ is a term in
        $f(q)$ if and only if $\delta_c(-j)$ is a summand with multiplicity b
        in  $\delta_{a_1}*\delta_{a_2}*....*\delta_{a_n}$

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

Computes the Han-Monsky multiplication
$\delta_{a_1}*\delta_{a_2}*....*\delta_{a_n}$. In positive characteristic, the
default instance employs Conjecture 4.1 [KMRR,25] to allow faster computations.

+-----------------------------------+
|i1 : p = 5;                        |
+-----------------------------------+
|i2 : L = {3,7,8};                  |
+-----------------------------------+
|i3 : hanMonsky(p, L)               |
|                                   |
|                      7            |
|o3 = HashTable{2 => 2q            }|
|                     6             |
|               4 => q              |
|                      6     5      |
|               5 => 2q  + 2q       |
|                     5             |
|               6 => q              |
|                      4            |
|               8 => 2q             |
|                      4     3    2 |
|               10 => q  + 3q  + q  |
|                       2           |
|               12 => 2q            |
|               14 => q             |
|               15 => q + 1         |
|                                   |
|o3 : HashTable                     |
+-----------------------------------+
+-------------------------+
|i4 : p = 0;              |
+-------------------------+
|i5 : L = {3,7,8};        |
+-------------------------+
|i6 : hanMonsky(p, L)     |
|                         |
|                      7  |
|o6 = HashTable{2 => 2q  }|
|                      6  |
|               4 => 3q   |
|                      5  |
|               6 => 3q   |
|                      4  |
|               8 => 3q   |
|                       3 |
|               10 => 3q  |
|                       2 |
|               12 => 3q  |
|               14 => 2q  |
|               16 => 1   |
|                         |
|o6 : HashTable           |
+-------------------------+

It is possible to compute it without employing Conjecture 4.1 [KMRR,25] setting
the option “UseConjecture” to be false.

+-------------------------------------------+
|i7 : p = 5;                                |
+-------------------------------------------+
|i8 : L = {3,7,8}                           |
|                                           |
|o8 = {3, 7, 8}                             |
|                                           |
|o8 : List                                  |
+-------------------------------------------+
|i9 : hanMonsky(p, L, UseConjecture =>false)|
|                                           |
|                      7                    |
|o9 = HashTable{2 => 2q            }        |
|                     6                     |
|               4 => q                      |
|                      6     5              |
|               5 => 2q  + 2q               |
|                     5                     |
|               6 => q                      |
|                      4                    |
|               8 => 2q                     |
|                      4     3    2         |
|               10 => q  + 3q  + q          |
|                       2                   |
|               12 => 2q                    |
|               14 => q                     |
|               15 => q + 1                 |
|                                           |
|o9 : HashTable                             |
+-------------------------------------------+

Ways to use hanMonsky:
======================

  * "hanMonsky(ZZ,List)"

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

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

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

The source of this document is in IncidenceCorrespondenceCohomology.m2:1389:0.

hasWLP -- Checks whether a graded Artinian algebra has the Weak Lefschetz Property (WLP)
****************************************************************************************

  * Usage:
        hasWLP(p,L)
        hasWLP(R,I)
  * Inputs:
      * p, an integer (Macaulay2Doc), prime characteristic of the
        field
      * L, a list (Macaulay2Doc), list of integers $a_1,...,a_n$
      * R, a polynomial ring (Macaulay2Doc),
      * I, an ideal (Macaulay2Doc), ideal of R, such that R/I is
        Artinian
  * Optional inputs (Macaulay2Doc),:
      * GorensteinAlg, => ..., default value false, An
        option to check the WLP for Gorenstein algebras
      * MonomialAlg, => ..., default value false, An option
        to check the WLP for R/I with I Monomial ideal
      * UseConjecture, => ..., default value true, An
        option that, whenever the Han-Monsky is computed, allows the user to
        choose if employ Conjecture 4.1 [KMRR,25] or not
  * Outputs:
      * a Boolean value (Macaulay2Doc), whether the monomial
        complete intersections $A=k[x_1,...,x_n]/(x_1^{a_1}, …, x_n^{a_n})$,
        where k is a field of characteristic p, has the Weak Lefschetz property
        (hasWLP(p,L)). whether the monomial complete intersections A=R/I  has
        the Weak Lefschetz Property (hasWLP(R,I)).

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

hasWLP(p,L) check if the monomial complete intersections
$A=k[x_1,...,x_n]/(x_1^{a_1}, …, x_n^{a_n})$, where k is a field of
characteristic p has the Weak Lefschetz property. For p=2 this method uses
Theorem 8.1 in [KMRR,24]. For p>2, it uses the Han-Monsky multiplication
obtained with Conjecture 4.1 [KMRR,25].

+-----------------+
|i1 : p = 3;      |
+-----------------+
|i2 : L = {3,3,3};|
+-----------------+
|i3 : hasWLP(p, L)|
|                 |
|o3 = false       |
+-----------------+
+-----------------+
|i4 : p = 3;      |
+-----------------+
|i5 : L = {4,5,7};|
+-----------------+
|i6 : hasWLP(p, L)|
|                 |
|o6 = true        |
+-----------------+

It is possible to check the WLP without employing the Han-Monsky
multiplication, setting the option UseConjecture to be false.

+----------------------------------------+
|i7 : p = 5;                             |
+----------------------------------------+
|i8 : L = {3,7,8}                        |
|                                        |
|o8 = {3, 7, 8}                          |
|                                        |
|o8 : List                               |
+----------------------------------------+
|i9 : hasWLP(p, L, UseConjecture =>false)|
|                                        |
|o9 = true                               |
+----------------------------------------+

hasWLP(R,I) check if the graded Artinian algebra R/I, where R is a standard
graded polynomial ring, has the Weak Lefschetz property.

+------------------------------------+
|i10 : R=QQ[x,y,z];                  |
+------------------------------------+
|i11 : I=ideal(x^3, y^3, z^3, x*y*z);|
|                                    |
|o11 : Ideal of R                    |
+------------------------------------+
|i12 : hasWLP(R,I)                   |
|                                    |
|o12 = false                         |
+------------------------------------+
+-----------------------------------------------+
|i13 : R=QQ[x,y,z];                             |
+-----------------------------------------------+
|i14 : I=ideal(x*z, x*y, z^3,y^3,x^4+6*y^2*z^2);|
|                                               |
|o14 : Ideal of R                               |
+-----------------------------------------------+
|i15 : hasWLP(R,I)                              |
|                                               |
|o15 = true                                     |
+-----------------------------------------------+

The options  GorensteinAlg and MonomialAlg allow simplifying the computation
when the input I is respectively a Gorenstein or a monomial ideal.

+---------------------------------------+
|i16 : R=QQ[x,y,z];                     |
+---------------------------------------+
|i17 : I=ideal(x^9,y^9,z^9,x^3*y^3*z^3);|
|                                       |
|o17 : Ideal of R                       |
+---------------------------------------+
|i18 : hasWLP(R,I, MonomialAlg => true) |
|                                       |
|o18 = false                            |
+---------------------------------------+
+------------------------------------------------------------+
|i19 : R=ZZ/7[x,y,z];                                        |
+------------------------------------------------------------+
|i20 :  I=ideal(x*z, x*y, z^3,y^3,x^4+6*y^2*z^2);--Gorenstein|
|                                                            |
|o20 : Ideal of R                                            |
+------------------------------------------------------------+
+----------------------------------------------------+
|i21 : hasWLP(R,I,GorensteinAlg => true)             |
|                                                    |
|o21 = true                                          |
+----------------------------------------------------+
|i22 : R=ZZ/17[x,y,z];                               |
+----------------------------------------------------+
|i23 : I=ideal(3*x^4+y^4,z*y^3, x^5-z^5);--Gorenstein|
|                                                    |
|o23 : Ideal of R                                    |
+----------------------------------------------------+

Caveat
======

The instances hasWLP(R,I) and hasWLP(R,I, GorensteinAlg=>true) require R to be
a standard graded polynomial ring over a sufficiently large field k, e.g.,
R=QQ[x_1,…,x_n]. If R is a polynomial ring over a finite field, then when
hasWLP(R, I) outputs false, it confirms that R/I fails the WLP. However, when
hasWLP(R, I) outputs true, we can only conclude that R/I has the WLP over a
field extension. The same holds for hasWLP(R,I, GorensteinAlg=>true).

This does not apply to hasWLP(p,L) and hasWLP(R,I, MonomialAlg=>true), which
work over any field k.

Ways to use hasWLP:
===================

  * "hasWLP(PolynomialRing,Ideal)"
  * "hasWLP(ZZ,List)"

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

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

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

The source of this document is in IncidenceCorrespondenceCohomology.m2:1467:0.

monomialCIsWithoutWLP -- Lists all the monomial complete intersections of socle s and height n that fail the Weak Lefschetz Property
************************************************************************************************************************************

  * Usage:
        L= monomialCIsWithoutWLP(p,n,s)
  * Inputs:
      * p, an integer (Macaulay2Doc), prime characteristic of the
        field
      * n, an integer (Macaulay2Doc), number of variables
      * s, an integer (Macaulay2Doc), socle degree
  * Optional inputs (Macaulay2Doc),:
      * UseConjecture, => ..., default value true, An
        option that, whenever the Han-Monsky is computed, allows the user to
        choose if employ Conjecture 4.1 [KMRR,25] or not
  * Outputs:
      * L, a list (Macaulay2Doc), list of  n-tuples
        ($a_1,....,a_n$) such that $a_1+.......+a_n-n=s$ and $2\leq a_1\leq
        ....\leq a_n$ for which $k[x_1,...,x_n]/(x_1^{a_1}, …, x_n^{a_n})$ does
        not have the WLP in characteristic p

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

This method lists all the n-tuples $(a_1,....,a_n)$, up to order, such that
$a_1+.......+a_n-n=s$  and  $k[x_1,...,x_n]/(x_1^{a_1}, …, x_n^{a_n})$ fails
the WLP with characteristic p, using the method hasWLP. The default value of
the option UseConjecture is true, so the computations are based on Conjecture
4.1 [KMRR,25]. When UseConjecture is set to false, the method does not use
Conjecture 4.1 [KMRR,25].

+---------------------------------------------------------------------------+
|i1 : p = 5;                                                                |
+---------------------------------------------------------------------------+
|i2 : s = 10;                                                               |
+---------------------------------------------------------------------------+
|i3 : n = 4;                                                                |
+---------------------------------------------------------------------------+
|i4 : L = monomialCIsWithoutWLP(p,n,s)                                      |
|                                                                           |
|o4 = {{2, 2, 5, 5}, {2, 3, 4, 5}, {2, 4, 4, 4}, {3, 3, 3, 5}, {3, 3, 4, 4}}|
|                                                                           |
|o4 : List                                                                  |
+---------------------------------------------------------------------------+

See also
========

  * hasWLP -- Checks whether a graded Artinian algebra has the
    Weak Lefschetz Property (WLP)

Ways to use monomialCIsWithoutWLP:
==================================

  * "monomialCIsWithoutWLP(ZZ,ZZ,ZZ)"

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

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

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

The source of this document is in IncidenceCorrespondenceCohomology.m2:1500:0.

hasSLP -- Checks whether a monomial complete intersection over a field of characteristic p has the Strong Lefschetz Property (SLP)
**********************************************************************************************************************************

  * Usage:
        hasSLP(p,L)
  * Inputs:
      * p, an integer (Macaulay2Doc), prime characteristic of the
        field
      * L, a list (Macaulay2Doc), list of integers $a_1,...,a_n$
  * Optional inputs (Macaulay2Doc),:
      * UseConjecture, => ..., default value false, An
        option that, whenever the Han-Monsky is computed, allows the user to
        choose if employ Conjecture 4.1 [KMRR,25] or not
  * Outputs:
      * a Boolean value (Macaulay2Doc), whether the monomial
        complete intersections $A=k[x_1,...,x_n]/(x_1^{a_1}, …, x_n^{a_n})$,
        where k is a field of characteristic p, has the Strong Lefschetz
        property.

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

Check if the monomial complete intersections $A=k[x_1,...,x_n]/(x_1^{a_1}, …,
x_n^{a_n})$, where k is a field of characteristic p has the Strong Lefschetz
property using Theorem 3.4 of [Nicklasson,18].

+-----------------+
|i1 : p = 3;      |
+-----------------+
|i2 : L = {4,5,7} |
|                 |
|o2 = {4, 5, 7}   |
|                 |
|o2 : List        |
+-----------------+
|i3 : hasSLP(p, L)|
|                 |
|o3 = false       |
+-----------------+
+-----------------+
|i4 : p = 13;     |
+-----------------+
|i5 : L = {3,3,19}|
|                 |
|o5 = {3, 3, 19}  |
|                 |
|o5 : List        |
+-----------------+
|i6 : hasSLP(p, L)|
|                 |
|o6 = true        |
+-----------------+

By default, this method does not use the Han-Monsky multiplication. When
UseConjecture is set to true, the method uses the Han-Monsky obtained from
Conjecture 4.1 [KMRR,25].

+---------------------------------------+
|i7 : p = 5;                            |
+---------------------------------------+
|i8 : L = {3,7,8}                       |
|                                       |
|o8 = {3, 7, 8}                         |
|                                       |
|o8 : List                              |
+---------------------------------------+
|i9 : hasSLP(p, L, UseConjecture =>true)|
|                                       |
|o9 = false                             |
+---------------------------------------+

Ways to use hasSLP:
===================

  * "hasSLP(ZZ,List)"

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

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

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

The source of this document is in IncidenceCorrespondenceCohomology.m2:1539:0.

UseConjecture -- An option that, whenever the Han-Monsky is computed, allows the user to choose if employ Conjecture 4.1 [KMRR,25] or not
*****************************************************************************************************************************************

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

The default value in hanMonsky is true, so the Han-Monsky multiplication is
computed based on Conjecture 4.1 [KMRR,25]. When defined to be false, the
function will not use Conjecture 4.1 [KMRR,25]. This will significantly
increase the time of computation for the method hanMonsky.

The default value in hasWLP(p,L) and monomialCIsWithoutWLP is true, when is set
to be false the computations are done with different methods, without computing
the hanMonsky multiplication. This option does not affect hasWLP(R,L) that does
not use the hanMonsky multiplication. In hasSLP, instead, the default value is
false.

See also
========

  * hanMonsky -- Computes the multiplication in the graded
    Han-Monsky representation ring
  * hasWLP -- Checks whether a graded Artinian algebra has the
    Weak Lefschetz Property (WLP)
  * hasSLP -- Checks whether a monomial complete intersection
    over a field of characteristic p has the Strong Lefschetz Property (SLP)
  * monomialCIsWithoutWLP -- Lists all the
    monomial complete intersections of socle s and height n that fail the Weak
    Lefschetz Property

Functions with optional argument named UseConjecture:
=====================================================

  * "hanMonsky(...,UseConjecture=>...)"
  * "hasSLP(...,UseConjecture=>...)"
  * "hasWLP(...,UseConjecture=>...)"
  * "monomialCIsWithoutWLP(...,UseConjecture=>...)"

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

The object UseConjecture, is a symbol (Macaulay2Doc).

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

The source of this document is in IncidenceCorrespondenceCohomology.m2:1565:0.

GorensteinAlg -- An option to check the WLP for Gorenstein algebras
*******************************************************************

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

The default value is false. When defined to be true, the function hasWLP(R,I)
assumes R/I Gorenstein.

See also
========

  * hasWLP -- Checks whether a graded Artinian algebra has the
    Weak Lefschetz Property (WLP)

Functions with optional argument named GorensteinAlg:
=====================================================

  * "hasWLP(...,GorensteinAlg=>...)"

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

The object GorensteinAlg, is a symbol (Macaulay2Doc).

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

The source of this document is in IncidenceCorrespondenceCohomology.m2:1582:0.

MonomialAlg -- An option to check the WLP for R/I with I Monomial ideal
***********************************************************************

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

The default value is false.  When defined to be false, the function hasWLP(R,I)
assumes I is monomial.

See also
========

  * hasWLP -- Checks whether a graded Artinian algebra has the
    Weak Lefschetz Property (WLP)

Functions with optional argument named MonomialAlg:
===================================================

  * "hasWLP(...,MonomialAlg=>...)"

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

The object MonomialAlg, is a symbol (Macaulay2Doc).

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

The source of this document is in IncidenceCorrespondenceCohomology.m2:1597:0.

recursiveDividedCohomology -- Computes dimension or character of sheaf cohomology of twists of divided powers of the cotangent sheaf on projective space
********************************************************************************************************************************************************

  * Usage:
        C = recursiveDividedCohomology(L)
        C = recursiveDividedCohomology(L, R)
  * Inputs:
      * L, a list (Macaulay2Doc), List of integers {i,p,d,e,n}
        where i = 0,1 is the cohomological degree, p is the characteristic of
        the field, d is the Divided power, e allows for additional twists, and
        n is the dimension of projective space + 1
      * R, a polynomial ring (Macaulay2Doc), Ambient ring
        for the character of the cohomology group, i.e. ZZ[x_1..x_n] where n-1
        is the dimension of projective space
  * Optional inputs (Macaulay2Doc),:
      * FindCharacter, => ..., default value false, An
        option to compute the character instead of the dimension
  * Outputs:
      * C, an integer (Macaulay2Doc), Dimension of the cohomology
        group (with the option to instead have the character)

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

recursiveDividedCohomology({i,p,d,e,n}) computes the dimension of
$H^i(\mathbb{P}^{n-1}, D^d R(e))$, where $D^d \mathcal{R}$ is the d-th divided
power of the universal rank (n-1) subsheaf $\mathcal{R}$.

The cohomology index i is 0 or 1 and the underlying characteristic of the field
is p (prime or 0).

+--------------------------------------------+
|i1 : i = 1; p = 3; d = 7; e = 6; n = 3;     |
+--------------------------------------------+
|i6 : recursiveDividedCohomology({i,p,d,e,n})|
|                                            |
|o6 = 9                                      |
+--------------------------------------------+
+---------------------------------------------+
|i7 : i = 1; p = 0; d = 7; e = 6; n = 3;      |
+---------------------------------------------+
|i12 : recursiveDividedCohomology({i,p,d,e,n})|
|                                             |
|o12 = 0                                      |
+---------------------------------------------+

We could instead ask for the character instead of just the dimension, setting
the option FindCharacter to be true.

+-----------------------------------------------------------------------------+
|i13 : i = 1; p = 3; d = 7; e = 6; n = 3;                                     |
+-----------------------------------------------------------------------------+
|i18 : recursiveDividedCohomology({i,p,d,e,n}, FindCharacter => true)         |
|                                                                             |
|       6 5 2    5 6 2    5 5 3    6 2 5    5 3 5    3 5 5    2 6 5    5 2 6  |
|o18 = x x x  + x x x  + x x x  + x x x  + x x x  + x x x  + x x x  + x x x  +|
|       1 2 3    1 2 3    1 2 3    1 2 3    1 2 3    1 2 3    1 2 3    1 2 3  |
|      -----------------------------------------------------------------------|
|       2 5 6                                                                 |
|      x x x                                                                  |
|       1 2 3                                                                 |
|                                                                             |
|o18 : ZZ[x ..x ]                                                             |
|          1   3                                                              |
+-----------------------------------------------------------------------------+
+-----------------------------------------------------------------------------+
|i19 : i = 1; p = 0; d = 5; e = 3; n = 3;                                     |
+-----------------------------------------------------------------------------+
|i24 : recursiveDividedCohomology({i,p,d,e,n}, FindCharacter => true)         |
|                                                                             |
|       4 4    4 3      3 4      4 2 2    3 3 2    2 4 2    4   3    3 2 3    |
|o24 = x x  + x x x  + x x x  + x x x  + x x x  + x x x  + x x x  + x x x  +  |
|       1 2    1 2 3    1 2 3    1 2 3    1 2 3    1 2 3    1 2 3    1 2 3    |
|      -----------------------------------------------------------------------|
|       2 3 3      4 3    4 4    3   4    2 2 4      3 4    4 4               |
|      x x x  + x x x  + x x  + x x x  + x x x  + x x x  + x x                |
|       1 2 3    1 2 3    1 3    1 2 3    1 2 3    1 2 3    2 3               |
|                                                                             |
|o24 : ZZ[x ..x ]                                                             |
|          1   3                                                              |
+-----------------------------------------------------------------------------+

Additional input of a polynomial ring allows the user to control the ambient
ring of the character.

+-----------------------------------------------------------------------------+
|i25 : i = 1; p = 3; d = 7; e = 6; R = ZZ[x_1..x_3];                          |
+-----------------------------------------------------------------------------+
|i30 : recursiveDividedCohomology({i,p,d,e},R)                                |
|                                                                             |
|       6 5 2    5 6 2    5 5 3    6 2 5    5 3 5    3 5 5    2 6 5    5 2 6  |
|o30 = x x x  + x x x  + x x x  + x x x  + x x x  + x x x  + x x x  + x x x  +|
|       1 2 3    1 2 3    1 2 3    1 2 3    1 2 3    1 2 3    1 2 3    1 2 3  |
|      -----------------------------------------------------------------------|
|       2 5 6                                                                 |
|      x x x                                                                  |
|       1 2 3                                                                 |
|                                                                             |
|o30 : R                                                                      |
+-----------------------------------------------------------------------------+

Ways to use recursiveDividedCohomology:
=======================================

  * "recursiveDividedCohomology(List)"
  * "recursiveDividedCohomology(List,PolynomialRing)"

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

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

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

The source of this document is in IncidenceCorrespondenceCohomology.m2:1648:0.

nimDividedCohomology -- Computes the dimension or character of sheaf cohomology of twists of divided powers of the cotangent sheaf on projective space, in characteristic 2
***************************************************************************************************************************************************************************

  * Usage:
        C = nimDividedCohomology(i,d,e,n)
        C = nimDividedCohomology(i,d,e,R)
  * Inputs:
      * i, an integer (Macaulay2Doc), cohomological degree
      * d, an integer (Macaulay2Doc), divided power of the cotangent
        sheaf
      * e, an integer (Macaulay2Doc), twist of the sheaf
      * n, an integer (Macaulay2Doc), dimension of projective space +
        1
      * R, a polynomial ring (Macaulay2Doc), ambient
        polynomial ring of the character, i.e. ZZ[x_1..x_n] where n-1 is the
        dimension of projective space
  * Optional inputs (Macaulay2Doc),:
      * FindCharacter, => ..., default value false, An
        option to compute the character instead of the dimension
  * Outputs:
      * C, an integer (Macaulay2Doc), dimension of the cohomology
        group H^i(P^{n-1}, D^d Omega (d+e)), with the option to instead have
        the character

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

This function computes in characteristic 2 the sheaf cohomology of twists of
divided powers of the cotangent sheaf on projective space
$H^i(\mathbb{P}^{n-1}, D^d \mathcal{R}(d))$, where $D^d \mathcal{R}$ is the
d-th divided power of the universal rank (n-1) subsheaf $\mathcal{R}$.

+----------------------------------+
|i1 : i =1; d = 5; e = 4; n = 3;   |
+----------------------------------+
|i5 : nimDividedCohomology(i,d,e,n)|
|                                  |
|o5 = 8                            |
+----------------------------------+

This function can also output the character instead of just the dimension,
setting the option FindCharacter to be true.

+-------------------------------------------------------------------+
|i6 : i = 1; d = 5; e = 4; n = 3;                                   |
+-------------------------------------------------------------------+
|i10 : nimDividedCohomology(i,d,e,n, FindCharacter => true)         |
|                                                                   |
|       4 3 2    3 4 2    4 2 3     3 3 3    2 4 3    3 2 4    2 3 4|
|o10 = x x x  + x x x  + x x x  + 2x x x  + x x x  + x x x  + x x x |
|       1 2 3    1 2 3    1 2 3     1 2 3    1 2 3    1 2 3    1 2 3|
|                                                                   |
|o10 : ZZ[x ..x ]                                                   |
|          1   3                                                    |
+-------------------------------------------------------------------+

This function allows the user to control the ambient ring of the character,
using the ambient ring R as the fourth input instead then n.

+-------------------------------------------------------------------+
|i11 : i = 1; d = 5; e = 4; R = ZZ[x_1..x_3];                       |
+-------------------------------------------------------------------+
|i15 : nimDividedCohomology(i,d,e,R)                                |
|                                                                   |
|       4 3 2    3 4 2    4 2 3     3 3 3    2 4 3    3 2 4    2 3 4|
|o15 = x x x  + x x x  + x x x  + 2x x x  + x x x  + x x x  + x x x |
|       1 2 3    1 2 3    1 2 3     1 2 3    1 2 3    1 2 3    1 2 3|
|                                                                   |
|o15 : R                                                            |
+-------------------------------------------------------------------+

Ways to use nimDividedCohomology:
=================================

  * "nimDividedCohomology(ZZ,ZZ,ZZ,PolynomialRing)"
  * "nimDividedCohomology(ZZ,ZZ,ZZ,ZZ)"

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

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

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

The source of this document is in IncidenceCorrespondenceCohomology.m2:1692:0.

incidenceCohomology -- Computes dimension or character of sheaf cohomology of line bundles on the incidence correspondence
**************************************************************************************************************************

  * Usage:
        C = incidenceCohomology(L)
        C = incidenceCohomology(L, R)
  * Inputs:
      * L, a list (Macaulay2Doc), List of integers {i,p,a,b,n} List
        of integers {i,p,a,b,n} where i is the cohomological degree, p is the
        characteristic of the field, the couple (a,b) indicates the line bundle
        $\mathcal{O}_X(a,b)$ on the incidence correspondence $X\subseteq
        \mathbb{P}\times \mathbb{P}^\vee$, and $n$ is the dimension of
        $\mathbb{P} +1
      * R, a polynomial ring (Macaulay2Doc), Laurent
        polynomial ring, ambient ring for the character of the cohomology
        group, i.e. ZZ[x_1..x_n,x_1^{-1}..x_n^{-1}] where n-1 is the dimension
        of projective space
  * Optional inputs (Macaulay2Doc),:
      * FindCharacter, => ..., default value false, An
        option to compute the character instead of the dimension
  * Outputs:
      * C, an integer (Macaulay2Doc), dimension of the cohomology
        group (with the option to instead have the character)

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

This function computes the sheaf cohomology  $H^i(X, \mathcal{O}_X(a,b))$, of
the line bundle $\mathcal{O}_X(a,b)$ on the incidence correspondence $X$. The
underlying characteristic of the field is p, prime or zero.

+---------------------------------------+
|i1 : i = 0; p = 0; a = 7; b = 6; n = 3;|
+---------------------------------------+
|i6 : incidenceCohomology({i,p,a,b,n})  |
|                                       |
|o6 = 420                               |
+---------------------------------------+
+----------------------------------------+
|i7 : i = 1; p = 3; a = 6; b = -8; n = 3;|
+----------------------------------------+
|i12 : incidenceCohomology({i,p,a,b,n})  |
|                                        |
|o12 = 9                                 |
+----------------------------------------+
+-----------------------------------------+
|i13 : i = 1; p = 0; a = 6; b = -8; n = 3;|
+-----------------------------------------+
|i18 : incidenceCohomology({i,p,a,b,n})   |
|                                         |
|o18 = 0                                  |
+-----------------------------------------+

We could instead ask for the character instead of just the dimension, setting
the option FindCharacter to be true.

+-----------------------------------------------------------------------------+
|i19 : i = 3; p = 0; a = -2; b = -6; n = 3;                                   |
+-----------------------------------------------------------------------------+
|i24 : incidenceCohomology({i,p,a,b,n}, FindCharacter => true)                |
|                                                                             |
|       4    3      3      2 2    2        2 2      3      2          2      3|
|o24 = x  + x x  + x x  + x x  + x x x  + x x  + x x  + x x x  + x x x  + x x |
|       1    1 2    1 3    1 2    1 2 3    1 3    1 2    1 2 3    1 2 3    1 3|
|      -----------------------------------------------------------------------|
|         4    3      2 2      3    4                                         |
|      + x  + x x  + x x  + x x  + x                                          |
|         2    2 3    2 3    2 3    3                                         |
|                                                                             |
|o24 : ZZ[x ..x ]                                                             |
|          1   3                                                              |
+-----------------------------------------------------------------------------+
+-----------------------------------------------------------------------------+
|i25 : i = 1; p = 3; a = 6; b = -8; n = 3;                                    |
+-----------------------------------------------------------------------------+
|i30 : incidenceCohomology({i,p,a,b,n}, FindCharacter => true)                |
|                                                                             |
|       6 6 2    6 5 3    6 3 5    6 2 6    5 6 3    5 3 6    3 6 5    3 5 6  |
|o30 = x x x  + x x x  + x x x  + x x x  + x x x  + x x x  + x x x  + x x x  +|
|       1 2 3    1 2 3    1 2 3    1 2 3    1 2 3    1 2 3    1 2 3    1 2 3  |
|      -----------------------------------------------------------------------|
|       2 6 6                                                                 |
|      x x x                                                                  |
|       1 2 3                                                                 |
|                                                                             |
|o30 : ZZ[x ..x ]                                                             |
|          1   3                                                              |
+-----------------------------------------------------------------------------+

Additional input of a polynomial ring allows the user to control the ambient
ring of the character.

+-----------------------------------------------------------------------------+
|i31 : i = 2; p = 3; a = 7; b = -10; R = ZZ[x_1..x_3, Inverses=>true,         |
|-----------------------------------------------------------------------------|
|MonomialOrder=>Lex];                                                         |
+-----------------------------------------------------------------------------+
|i36 : incidenceCohomology({i,p,a,b},R)                                       |
|                                                                             |
|       8 8      8 7 2    8 6 3    8 5 4    8 4 5    8 3 6    8 2 7    8   8  |
|o36 = x x x  + x x x  + x x x  + x x x  + x x x  + x x x  + x x x  + x x x  +|
|       1 2 3    1 2 3    1 2 3    1 2 3    1 2 3    1 2 3    1 2 3    1 2 3  |
|      -----------------------------------------------------------------------|
|       7 8 2    7 7 3    7 6 4    7 5 5    7 4 6    7 3 7    7 2 8    6 8 3  |
|      x x x  + x x x  + x x x  + x x x  + x x x  + x x x  + x x x  + x x x  +|
|       1 2 3    1 2 3    1 2 3    1 2 3    1 2 3    1 2 3    1 2 3    1 2 3  |
|      -----------------------------------------------------------------------|
|       6 7 4    6 6 5    6 5 6    6 4 7    6 3 8    5 8 4    5 7 5    5 6 6  |
|      x x x  + x x x  + x x x  + x x x  + x x x  + x x x  + x x x  + x x x  +|
|       1 2 3    1 2 3    1 2 3    1 2 3    1 2 3    1 2 3    1 2 3    1 2 3  |
|      -----------------------------------------------------------------------|
|       5 5 7    5 4 8    4 8 5    4 7 6    4 6 7    4 5 8    3 8 6    3 7 7  |
|      x x x  + x x x  + x x x  + x x x  + x x x  + x x x  + x x x  + x x x  +|
|       1 2 3    1 2 3    1 2 3    1 2 3    1 2 3    1 2 3    1 2 3    1 2 3  |
|      -----------------------------------------------------------------------|
|       3 6 8    2 8 7    2 7 8      8 8                                      |
|      x x x  + x x x  + x x x  + x x x                                       |
|       1 2 3    1 2 3    1 2 3    1 2 3                                      |
|                                                                             |
|o36 : R                                                                      |
+-----------------------------------------------------------------------------+

Ways to use incidenceCohomology:
================================

  * "incidenceCohomology(List)"
  * "incidenceCohomology(List,PolynomialRing)"

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

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

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

The source of this document is in IncidenceCorrespondenceCohomology.m2:1740:0.

FindCharacter -- An option to compute the character instead of the dimension
****************************************************************************

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

The default value is false.  When defined to be true, the function will output
the character instead of the dimension for the cohomology.

See also
========

  * recursiveDividedCohomology -- Computes
    dimension or character of sheaf cohomology of twists of divided powers of
    the cotangent sheaf on projective space
  * nimDividedCohomology -- Computes the dimension
    or character of sheaf cohomology of twists of divided powers of the
    cotangent sheaf on projective space, in characteristic 2
  * incidenceCohomology -- Computes dimension or
    character of sheaf cohomology of line bundles on the incidence
    correspondence

Functions with optional argument named FindCharacter:
=====================================================

  * "incidenceCohomology(...,FindCharacter=>...)"
  * "nimDividedCohomology(...,FindCharacter=>...)"
  * "recursiveDividedCohomology(...,FindCharacter=>...)"

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

The object FindCharacter, is a symbol (Macaulay2Doc).

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

The source of this document is in IncidenceCorrespondenceCohomology.m2:1763:0.