This is BinomialEdgeIdeals.info, produced by Macaulay2, version 1.21

BinomialEdgeIdeals -- binomial edge ideals
******************************************

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

BinomialEdgeIdeals is a package for computations with binomial edge ideals

Literature
  * [HHHTR2010] Binomial edge ideals and conditional independence statements
    (J. Herzog, T. Hibi, F. Hreinsdottir, T. Kahle, J. Rauh, 2010).
  * [HMMW2014] On the ideal of orthogonal representations of a graph in R^2 (J.
    Herzog, A. Macchia, S. Madani, V. Welker, 2014).
  * [KSW2015] Parity binomial edge ideals (T. Kahle, C. Sarmiento, T. Windisch,
    2015)

Author
======

  * Tobias Windisch (see http://www.uni-magdeburg.de/windisch/ )
    <windisch@ovgu.de>

Version
=======

This documentation describes version 1.0 of BinomialEdgeIdeals.

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

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

Exports
=======

  * Functions and commands
      * bei -- Binomial edge ideal
      * binomialEdgeIdeal -- Binomial edge ideals
      * disconnectors -- Disconnectors of a graph
      * isDisconnector -- A test for being a
        disconnector
      * isEffective -- A test for being an effective
        disconnector
      * parityBinomialEdgeIdeal -- parity
        binomial edge ideals
      * pbei -- Parity binomial edge ideal
      * weightedConnectedComponents, --
        Counting the weighted number of connected components of a graph
  * Methods
      * "binomialEdgeIdeal(List)" -- see binomialEdgeIdeal,
        -- Binomial edge ideals
      * "disconnectors(List)" -- see disconnectors, --
        Disconnectors of a graph
      * "isDisconnector(List,List)" -- see isDisconnector,
        -- A test for being a disconnector
      * "isDisconnector(List,Set)" -- see isDisconnector,
        -- A test for being a disconnector
      * "isEffective(List,List)" -- see isEffective, -- A
        test for being an effective disconnector
      * "isEffective(List,Set)" -- see isEffective, -- A
        test for being an effective disconnector
      * "parityBinomialEdgeIdeal(List)" -- see parityBinomialEdgeIdeal,
        -- parity binomial edge ideals
      * "weightedConnectedComponents(List)" -- see
        weightedConnectedComponents, -- Counting
        the weighted number of connected components of a graph
  * Symbols
      * EffectiveOnly (missing documentation)
      * Field (missing documentation)
      * Permanental (missing documentation)
      * TermOrder (missing documentation)
      * UseHypergraphs (missing documentation)
      * WeightMethod (missing documentation)

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

The object BinomialEdgeIdeals, is a package (Macaulay2Doc).

bei -- Binomial edge ideal
**************************

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

bei is a synonym for binomialEdgeIdeal.

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

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

binomialEdgeIdeal -- Binomial edge ideals
*****************************************

Synopsis
========

  * Usage:
        binomialEdgeIdeal G
  * Inputs:
      * G, a Graph or a List
  * Optional inputs (Macaulay2Doc),:
      * Field (missing documentation) => ..., default value QQ, null
      * Permanental (missing documentation) => ..., default value false, null
      * TermOrder (missing documentation) => ..., default value Lex, null
  * Outputs:
      * the binomial edge ideal of G

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

This routine returns the (permanental) binomial edge ideal of G.
+--------------------------------------------------+
|i1 : G={{1,2},{2,3},{3,1}}                        |
|                                                  |
|o1 = {{1, 2}, {2, 3}, {3, 1}}                     |
|                                                  |
|o1 : List                                         |
+--------------------------------------------------+
|i2 : I = binomialEdgeIdeal(G,Field=>ZZ/2)         |
|                                                  |
|o2 = ideal (x y  + x y , x y  + x y , x y  + x y )|
|             1 2    2 1   1 3    3 1   2 3    3 2 |
|                                                  |
|              ZZ                                  |
|o2 : Ideal of --[x ..y ]                          |
|               2  1   3                           |
+--------------------------------------------------+
|i3 : J = binomialEdgeIdeal(G,Permanental=>true)   |
|                                                  |
|o3 = ideal (x y  + x y , x y  + x y , x y  + x y )|
|             1 2    2 1   1 3    3 1   2 3    3 2 |
|                                                  |
|o3 : Ideal of QQ[x ..y ]                          |
|                  1   3                           |
+--------------------------------------------------+
|i4 : needsPackage("Graphs")                       |
|                                                  |
|o4 = Graphs                                       |
|                                                  |
|o4 : Package                                      |
+--------------------------------------------------+
|i5 : H=graph({{1,2},{2,3},{3,1}})                 |
|                                                  |
|o5 = Graph{1 => {2, 3}}                           |
|           2 => {1, 3}                            |
|           3 => {1, 2}                            |
|                                                  |
|o5 : Graph                                        |
+--------------------------------------------------+
|i6 : I = binomialEdgeIdeal(H)                     |
|                                                  |
|o6 = ideal (x y  - x y , x y  - x y , x y  - x y )|
|             1 2    2 1   1 3    3 1   2 3    3 2 |
|                                                  |
|o6 : Ideal of QQ[x ..y ]                          |
|                  1   3                           |
+--------------------------------------------------+
A synonym for this function is bei.

See also
========

  * bei -- Binomial edge ideal
  * parityBinomialEdgeIdeal -- parity binomial
    edge ideals

Ways to use binomialEdgeIdeal :
===============================

  * "binomialEdgeIdeal(List)"

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

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

disconnectors -- Disconnectors of a graph
*****************************************

Synopsis
========

  * Usage:
        disconnectors G
  * Inputs:
      * G, a Graph or a List
  * Optional inputs (Macaulay2Doc),:
      * EffectiveOnly (missing documentation) => ..., default value false, null
  * Outputs:
      * the disconnectors of G

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

This routine computes the disconnectors of the parity binomial edge ideal and
the permanental binomial edge ideal of G
+---------------------------------------------+
|i1 : G={{1,2},{2,3},{3,1}}                   |
|                                             |
|o1 = {{1, 2}, {2, 3}, {3, 1}}                |
|                                             |
|o1 : List                                    |
+---------------------------------------------+
|i2 : d = disconnectors(G)                    |
|                                             |
|o2 = {{}, {1}, {2}, {3}}                     |
|                                             |
|o2 : List                                    |
+---------------------------------------------+
|i3 : d = disconnectors(G,EffectiveOnly=>true)|
|                                             |
|o3 = {{}, {3}, {2}, {1}}                     |
|                                             |
|o3 : List                                    |
+---------------------------------------------+

See also
========

  * isEffective -- A test for being an effective
    disconnector

Ways to use disconnectors :
===========================

  * "disconnectors(List)"

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

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

EffectiveOnly
*************

Functions with optional argument named EffectiveOnly :
======================================================

  * disconnectors(...,EffectiveOnly=>...) (missing documentation)

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

The object EffectiveOnly (missing documentation) is a symbol (Macaulay2Doc).

Field
*****

Functions with optional argument named Field :
==============================================

  * binomialEdgeIdeal(...,Field=>...) (missing documentation)
  * parityBinomialEdgeIdeal(...,Field=>...) (missing documentation)

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

The object Field (missing documentation) is a symbol (Macaulay2Doc).

isDisconnector -- A test for being a disconnector
*************************************************

Synopsis
========

  * Usage:
        isDisconnector(G,S)
  * Inputs:
      * G, a Graph or a List
      * S, a List or a Set
  * Outputs:
      * true or false, depending on wheater S is a disconnector of G

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

This routine checks wheater a Set or a List is a disconnector of a graph
+---------------------------------+
|i1 : needsPackage("Graphs")      |
|                                 |
|o1 = Graphs                      |
|                                 |
|o1 : Package                     |
+---------------------------------+
|i2 : G=graph({{1,2},{2,3},{3,1}})|
|                                 |
|o2 = Graph{1 => {2, 3}}          |
|           2 => {1, 3}           |
|           3 => {1, 2}           |
|                                 |
|o2 : Graph                       |
+---------------------------------+
|i3 : S={1}                       |
|                                 |
|o3 = {1}                         |
|                                 |
|o3 : List                        |
+---------------------------------+
|i4 : isDisconnector(G,S)         |
|                                 |
|o4 = true                        |
+---------------------------------+

See also
========

  * disconnectors -- Disconnectors of a graph

Ways to use isDisconnector :
============================

  * "isDisconnector(List,List)"
  * "isDisconnector(List,Set)"

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

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

isEffective -- A test for being an effective disconnector
*********************************************************

Synopsis
========

  * Usage:
        isEffective(G,S)
  * Inputs:
      * G, a Graph or a List
      * S, a List or a Set
  * Optional inputs (Macaulay2Doc),:
      * UseHypergraphs (missing documentation) => ..., default value false,
        null
  * Outputs:
      * true or false, depending on whether S is an effective disconnector of G

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

This routine checks whether a Set or a List is an effective disconnector of a
graph
+---------------------------------+
|i1 : needsPackage("Graphs")      |
|                                 |
|o1 = Graphs                      |
|                                 |
|o1 : Package                     |
+---------------------------------+
|i2 : G=graph({{1,2},{2,3},{3,1}})|
|                                 |
|o2 = Graph{1 => {2, 3}}          |
|           2 => {1, 3}           |
|           3 => {1, 2}           |
|                                 |
|o2 : Graph                       |
+---------------------------------+
|i3 : S={1}                       |
|                                 |
|o3 = {1}                         |
|                                 |
|o3 : List                        |
+---------------------------------+
|i4 : isEffective(G,S)            |
|                                 |
|o4 = false                       |
+---------------------------------+

See also
========

  * disconnectors -- Disconnectors of a graph

Ways to use isEffective :
=========================

  * "isEffective(List,List)"
  * "isEffective(List,Set)"

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

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

parityBinomialEdgeIdeal -- parity binomial edge ideals
******************************************************

Synopsis
========

  * Usage:
        parityBinomialEdgeIdeal G
  * Inputs:
      * G, a Graph or a List
  * Optional inputs (Macaulay2Doc),:
      * Field (missing documentation) => ..., default value QQ, null
      * Permanental (missing documentation) => ..., default value false, null
      * TermOrder (missing documentation) => ..., default value Lex, null
  * Outputs:
      * the parity binomial edge ideal of G

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

This routine returns the (permanental) parity binomial edge ideal of G.
+--------------------------------------------------+
|i1 : G={{1,2},{2,3},{3,1}}                        |
|                                                  |
|o1 = {{1, 2}, {2, 3}, {3, 1}}                     |
|                                                  |
|o1 : List                                         |
+--------------------------------------------------+
|i2 : I = parityBinomialEdgeIdeal(G,Field=>ZZ/2)   |
|                                                  |
|o2 = ideal (x x  + y y , x x  + y y , x x  + y y )|
|             1 2    1 2   1 3    1 3   2 3    2 3 |
|                                                  |
|              ZZ                                  |
|o2 : Ideal of --[x ..y ]                          |
|               2  1   3                           |
+--------------------------------------------------+
|i3 : J = parityBinomialEdgeIdeal(G)               |
|                                                  |
|o3 = ideal (x x  - y y , x x  - y y , x x  - y y )|
|             1 2    1 2   1 3    1 3   2 3    2 3 |
|                                                  |
|o3 : Ideal of QQ[x ..y ]                          |
|                  1   3                           |
+--------------------------------------------------+
|i4 : needsPackage("Graphs")                       |
|                                                  |
|o4 = Graphs                                       |
|                                                  |
|o4 : Package                                      |
+--------------------------------------------------+
|i5 : H=graph({{1,2},{2,3},{3,1}})                 |
|                                                  |
|o5 = Graph{1 => {2, 3}}                           |
|           2 => {1, 3}                            |
|           3 => {1, 2}                            |
|                                                  |
|o5 : Graph                                        |
+--------------------------------------------------+
|i6 : I = binomialEdgeIdeal(H)                     |
|                                                  |
|o6 = ideal (x y  - x y , x y  - x y , x y  - x y )|
|             1 2    2 1   1 3    3 1   2 3    3 2 |
|                                                  |
|o6 : Ideal of QQ[x ..y ]                          |
|                  1   3                           |
+--------------------------------------------------+
A synonym for this function is pbei.

See also
========

  * pbei -- Parity binomial edge ideal
  * binomialEdgeIdeal -- Binomial edge ideals

Ways to use parityBinomialEdgeIdeal :
=====================================

  * "parityBinomialEdgeIdeal(List)"

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

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

pbei -- Parity binomial edge ideal
**********************************

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

pbei is a synonym for parityBinomialEdgeIdeal.

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

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

Permanental
***********

Functions with optional argument named Permanental :
====================================================

  * binomialEdgeIdeal(...,Permanental=>...) (missing documentation)
  * parityBinomialEdgeIdeal(...,Permanental=>...) (missing documentation)

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

The object Permanental (missing documentation) is a symbol (Macaulay2Doc).

TermOrder
*********

Functions with optional argument named TermOrder :
==================================================

  * binomialEdgeIdeal(...,TermOrder=>...) (missing documentation)
  * parityBinomialEdgeIdeal(...,TermOrder=>...) (missing documentation)

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

The object TermOrder (missing documentation) is a symbol (Macaulay2Doc).

UseHypergraphs
**************

Functions with optional argument named UseHypergraphs :
=======================================================

  * isEffective(...,UseHypergraphs=>...) (missing documentation)

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

The object UseHypergraphs (missing documentation) is a symbol (Macaulay2Doc).

weightedConnectedComponents -- Counting the weighted number of connected components of a graph
**********************************************************************************************

Synopsis
========

  * Usage:
        weightedConnectedComponents(G)
  * Inputs:
      * G, a Graph or a List
  * Optional inputs (Macaulay2Doc),:
      * WeightMethod (missing documentation) => ..., default value "PBEI", null
  * Outputs:
      * the (weighted) number of connected components of G

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

This computes the (weighted) number of connected components of a graph. The
weights are all one if WeightMethod='BEI' is chosen and if WeightMethod='PBEI',
then bipartite components count twice.
+--------------------------------------------------------+
|i1 : G={{1,2},{2,3},{3,1},{4,5},{6,7},{7,8},{6,8}};     |
+--------------------------------------------------------+
|i2 : weightedConnectedComponents(G,WeightMethod=>"BEI") |
|                                                        |
|o2 = 3                                                  |
+--------------------------------------------------------+
|i3 : weightedConnectedComponents(G,WeightMethod=>"PBEI")|
|                                                        |
|o3 = 4                                                  |
+--------------------------------------------------------+

See also
========

  * disconnectors -- Disconnectors of a graph

Ways to use weightedConnectedComponents :
=========================================

  * "weightedConnectedComponents(List)"

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

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

WeightMethod
************

Functions with optional argument named WeightMethod :
=====================================================

  * weightedConnectedComponents(...,WeightMethod=>...) (missing documentation)

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

The object WeightMethod (missing documentation) is a symbol (Macaulay2Doc).