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

NeuralIdeals -- neural ideals and their canonical forms
*******************************************************

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

NeuralIdeals allows computation of a neural ideal or its canonical form from a
neural code

Caveat
======

In progress

Authors
=======

  * Hugh Geller (see https://hughgeller.com/ ) <geller.hugh@gmail.com>
  * Rebecca R.G. (see https://sites.google.com/site/rebeccargmath/ )
    <rrebhuhn@gmu.edu>

Version
=======

This documentation describes version 1.0 of NeuralIdeals, released July 22,
2025.

Citation
========

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

+----------------------------------------------------------------------------+
|@misc{NeuralIdealsSource,                                                   |
|  title = {{NeuralIdeals: canonical forms of neural ideals. Version~1.0}},  |
|  author = {Hugh Geller and Rebecca R.G.},                                  |
|  howpublished = {A \emph{Macaulay2} package available at                   |
|    \url{https://github.com/Macaulay2/M2/tree/stable/M2/Macaulay2/packages}}|
|}                                                                           |
|                                                                            |
+----------------------------------------------------------------------------+

Exports
=======

  * Types
      * NeuralCode -- type of a neural code
  * Functions and commands
      * allCodeWords (missing documentation)
      * canonicalForm -- computes the canonical form of a
        neural ideal
      * canonicalResolution -- canonical resolution
        of a neural code
      * codeSupport -- lists which neurons fire together
      * depolarizationMap -- creates the
        depolarization map
      * isCanonical -- determines whether a neural ideal is
        in canonical form
      * neuralCode -- creates a NeuralCode object
      * neuralIdeal -- computes the neural ideal of a
        neural code.
      * polarizedCanonicalForm -- computes the
        polarized canonical form
      * polarizedCanonicalIdeal -- polarized
        ideal generated by the canonical form
      * polarizedCanonicalResolution, --
        computes the polarized canonical resolution
      * polarizedRing -- returns the polarized ring of a
        NeuralCode
      * polarizeList -- polarizes a list of ring elements
      * polarizePseudomonomial -- polarizes a
        pseudomonomial
      * receptiveFieldRelation -- gives the
        receptive field relation corresponding ot a pseudomonomial
  * Methods
      * "NeuralCode == NeuralCode" -- see ==, -- determines whether
        two NeuralCodes are equal
      * allCodeWords(ZZ) (missing documentation)
      * "canonicalForm(Ideal)" -- see canonicalForm, --
        computes the canonical form of a neural ideal
      * "canonicalForm(NeuralCode)" -- see canonicalForm,
        -- computes the canonical form of a neural ideal
      * "canonicalResolution(NeuralCode)" -- see canonicalResolution,
        -- canonical resolution of a neural code
      * "codeSupport(NeuralCode)" -- see codeSupport, --
        lists which neurons fire together
      * "depolarizationMap(Ring,Ring)" -- see depolarizationMap,
        -- creates the depolarization map
      * "dim(NeuralCode)" -- see dim, -- dimension of a NeuralCode
      * "isCanonical(Ideal)" -- see isCanonical, --
        determines whether a neural ideal is in canonical form
      * "isWellDefined(NeuralCode)" -- see isWellDefined,
        -- determines whether a NeuralCode is well-defined
      * "neuralCode(Ideal)" -- see neuralCode, -- creates a
        NeuralCode object
      * "neuralCode(List)" -- see neuralCode, -- creates a
        NeuralCode object
      * "neuralCode(List,Ring)" -- see neuralCode, -- creates
        a NeuralCode object
      * "neuralCode(List,Ring,Ring)" -- see neuralCode, --
        creates a NeuralCode object
      * "neuralCode(List,String,String)" -- see neuralCode,
        -- creates a NeuralCode object
      * "neuralIdeal(NeuralCode)" -- see neuralIdeal, --
        computes the neural ideal of a neural code.
      * "polarizedCanonicalForm(Ideal)" -- see polarizedCanonicalForm,
        -- computes the polarized canonical form
      * "polarizedCanonicalForm(Ideal,Ring)" -- see
        polarizedCanonicalForm, -- computes the
        polarized canonical form
      * "polarizedCanonicalForm(NeuralCode)" -- see
        polarizedCanonicalForm, -- computes the
        polarized canonical form
      * "polarizedCanonicalIdeal(Ideal)" -- see polarizedCanonicalIdeal,
        -- polarized ideal generated by the canonical
        form
      * "polarizedCanonicalIdeal(Ideal,Ring)" -- see
        polarizedCanonicalIdeal, -- polarized ideal
        generated by the canonical form
      * "polarizedCanonicalIdeal(NeuralCode)" -- see
        polarizedCanonicalIdeal, -- polarized ideal
        generated by the canonical form
      * "polarizedCanonicalResolution(NeuralCode)" -- see
        polarizedCanonicalResolution, -- computes
        the polarized canonical resolution
      * "polarizedRing(NeuralCode)" -- see polarizedRing,
        -- returns the polarized ring of a NeuralCode
      * "polarizeList(List)" -- see polarizeList, --
        polarizes a list of ring elements
      * "polarizeList(List,Ring)" -- see polarizeList, --
        polarizes a list of ring elements
      * "polarizePseudomonomial(RingElement)" -- see
        polarizePseudomonomial, -- polarizes a
        pseudomonomial
      * "polarizePseudomonomial(RingElement,Ring)" -- see
        polarizePseudomonomial, -- polarizes a
        pseudomonomial
      * "receptiveFieldRelation(RingElement)" -- see
        receptiveFieldRelation, -- gives the receptive
        field relation corresponding ot a pseudomonomial
      * "ring(NeuralCode)" -- see ring, -- ring of a NeuralCode
  * Symbols
      * codeWords -- of a neural code
      * Iterative -- the default method for computing the
        canonical form of a neural code
      * Polar (missing documentation)
      * Polarized -- determine whether a polarized ideal is
        in canonical form
      * SharedIndex -- the default method for computing the
        canonical form of a neural ideal

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

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

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

The source of this document is in NeuralIdeals.m2:638:0.

== -- determines whether two NeuralCodes are equal
**************************************************

  * Usage:
        C == D
  * Inputs:
      * C and D, two NeuralCodes
  * Outputs:
      * Boolean

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

Determines whether two NeuralCodes are equal by comparing their dimension and
list of codewords. This function does not look at the ring and polarized ring
of the neural codes.

Ways to use symbol ==:
======================

  * "NeuralCode == NeuralCode"
  * "Matrix == Matrix" -- see basic arithmetic of matrices (Macaulay2Doc),
  * "Ideal == Ideal" -- see equality and containment (Macaulay2Doc),
  * "Ideal == ZZ" -- see equality and containment (Macaulay2Doc),
  * "ZZ == Ideal" -- see equality and containment (Macaulay2Doc),
  * "Module == Module" -- see equality and containment of modules (Macaulay2Doc),

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

The object == (Macaulay2Doc), is a keyword (Macaulay2Doc).

This operator may be used as a binary operator in an expression like x==y. The
user may install binary methods (Macaulay2Doc), for
handling such expressions with code such as

         X == Y := (x,y) -> ...

where X is the class of x and Y is the class of y.

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

The source of this document is in NeuralIdeals.m2:737:0.

allCodeWords
************

Ways to use allCodeWords:
=========================

  * allCodeWords(ZZ) (missing documentation)

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

The object allCodeWords (missing documentation) is a method function (Macaulay2Doc).

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

The source of this document is in currentString:1:378.

canonicalForm -- computes the canonical form of a neural ideal
**************************************************************

  * Usage:
        canonicalForm(I) or canonicalForm(C)
  * Inputs:
      * I, a squarefree pseudomonomial ideal, or C, a NeuralCode
  * Outputs:
      * a List of pseudomonomials in ring(I) (resp. ring(C))

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

Optional Inputs =>SharedIndex => ...,default value true, when true uses the
shared index method of Geller and R.G. to compute the canonical form instead of
the primary decomposition method of Curto, Itskov, et alIterative =>
...,default value true, when true computes the canonical form of a neural code
using the iterative method of Petersen, Youngs, et al instead of computing the
neural ideal and then its canonical formComputes the canonical form of a neural
ideal or a neural code, with several options for how to compute it.
+----------------------------------+
|i1 : R=ZZ/2[x_1..x_3];            |
+----------------------------------+
|i2 : I=ideal(x_1*x_3,x_2*(1-x_1));|
|                                  |
|o2 : Ideal of R                   |
+----------------------------------+
|i3 : canonicalForm(I)             |
|                                  |
|o3 = {x x , x x  + x , x x }      |
|       1 3   1 2    2   2 3       |
|                                  |
|o3 : List                         |
+----------------------------------+
|i4 : R=ZZ/2[x_1..x_3];            |
+----------------------------------+
|i5 : C=neuralCode({"000","001"}); |
+----------------------------------+
|i6 : canonicalForm(C)             |
|                                  |
|o6 = {x , x }                     |
|       1   2                      |
|                                  |
|o6 : List                         |
+----------------------------------+

Ways to use canonicalForm:
==========================

  * "canonicalForm(Ideal)"
  * "canonicalForm(NeuralCode)"

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

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

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

The source of this document is in NeuralIdeals.m2:792:0.

canonicalResolution -- canonical resolution of a neural code
************************************************************

  * Usage:
        canonicalResolution(C)
  * Inputs:
      * C, a NeuralCode
  * Outputs:
      * a free resolution over ring(C)

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

A method that returns the canonical resolution of a neural code, as in
Gunturkun, Jeffries, Sun
+------------------------------------+
|i1 : C=neuralCode({"00","10","01"});|
+------------------------------------+
|i2 : canonicalResolution(C)         |
|                                    |
|      ZZ         1      ZZ         1|
|o2 = (--[x ..x ])  <-- (--[x ..x ]) |
|       2  1   2          2  1   2   |
|                                    |
|     0                 1            |
|                                    |
|o2 : Complex                        |
+------------------------------------+

Ways to use canonicalResolution:
================================

  * "canonicalResolution(NeuralCode)"

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

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

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

The source of this document is in NeuralIdeals.m2:978:0.

codeSupport -- lists which neurons fire together
************************************************

  * Usage:
        codeSupport(C)
  * Inputs:
      * C, a NeuralCode
  * Outputs:
      * a List of lists of neurons.

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

Given a NeuralCode, this returns a list of the sets of neurons that fire
together.
+---------------------------------------------------+
|i1 : C=neuralCode({"000","100","110","001","101"});|
+---------------------------------------------------+
|i2 : codeSupport(C)                                |
|                                                   |
|o2 = {{}, {1}, {1, 2}, {3}, {1, 3}}                |
|                                                   |
|o2 : List                                          |
+---------------------------------------------------+

Ways to use codeSupport:
========================

  * "codeSupport(NeuralCode)"

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

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

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

The source of this document is in NeuralIdeals.m2:823:0.

codeWords -- of a neural code
*****************************

  * Usage:
        C.codeWords
  * Inputs:
      * C, a NeuralCode
  * Outputs:
      * a list of binary strings of length dim C

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

+-------------------------------+
|i1 : C=neuralCode({"00","01"});|
+-------------------------------+
|i2 : C.codeWords               |
|                               |
|o2 = {00, 01}                  |
|                               |
|o2 : List                      |
+-------------------------------+

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

The object codeWords, is a symbol (Macaulay2Doc).

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

The source of this document is in NeuralIdeals.m2:702:0.

depolarizationMap -- creates the depolarization map
***************************************************

  * Usage:
        depolarizationMap(R,S)
  * Inputs:
      * R, a polynomial ring
      * S, a polynomial ring in twice as many variables as R
  * Outputs:
      * a ring map S to R that depolarizes squarefree monomials

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

A method that returns the depolarization map of Gunturkun, Jeffries, and Sun.
+-----------------------------------------------------+
|i1 : R=ZZ/2[x_1..x_3];                               |
+-----------------------------------------------------+
|i2 : S=ZZ/2[x_1..x_3,y_1..y_3];                      |
+-----------------------------------------------------+
|i3 : depolarizationMap(R,S)                          |
|                                                     |
|o3 = map (R, S, {x , x , x , x  + 1, x  + 1, x  + 1})|
|                  1   2   3   1       2       3      |
|                                                     |
|o3 : RingMap R <-- S                                 |
+-----------------------------------------------------+

Ways to use depolarizationMap:
==============================

  * "depolarizationMap(Ring,Ring)"

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

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

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

The source of this document is in NeuralIdeals.m2:965:0.

dim -- dimension of a NeuralCode
********************************

  * Usage:
        dim(C)
  * Inputs:
      * C, a NeuralCode
  * Outputs:
      * a positive integer

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

Returns the dimension of a neural code, i.e. the length of its code words.

Ways to use dim:
================

  * "dim(NeuralCode)"
  * dim(Ideal) (Macaulay2Doc) -- compute the Krull
    dimension
  * "dim(MonomialIdeal)" -- see dim(Ideal) (Macaulay2Doc),
    -- compute the Krull dimension
  * dim(Module) (Macaulay2Doc) -- compute the Krull
    dimension
  * dim(ProjectiveHilbertPolynomial) (Macaulay2Doc)
    -- the degree of the
    Hilbert polynomial
  * "dim(FractionField)" -- see dim(Ring) (Macaulay2Doc),
    -- compute the Krull dimension
  * "dim(GaloisField)" -- see dim(Ring) (Macaulay2Doc), --
    compute the Krull dimension
  * "dim(InexactField)" -- see dim(Ring) (Macaulay2Doc), --
    compute the Krull dimension
  * "dim(PolynomialRing)" -- see dim(Ring) (Macaulay2Doc),
    -- compute the Krull dimension
  * "dim(QuotientRing)" -- see dim(Ring) (Macaulay2Doc), --
    compute the Krull dimension
  * dim(Ring) (Macaulay2Doc) -- compute the Krull
    dimension

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

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

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

The source of this document is in NeuralIdeals.m2:711:0.

isCanonical -- determines whether a neural ideal is in canonical form
*********************************************************************

  * Usage:
        isCanonical(I)
  * Inputs:
      * I, a neural ideal
  * Optional inputs (Macaulay2Doc),:
      * Polarized => ..., default value false
  * Outputs:
      * Boolean

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

A method that determines whether a neural ideal is in canonical form.
Currently, it computes the canonical form and compares, so it may not be
accurate and is not quick.
+------------------------------+
|i1 : R=ZZ/2[x_1..x_3];        |
+------------------------------+
|i2 : I=ideal(x_1,x_2*(1-x_1));|
|                              |
|o2 : Ideal of R               |
+------------------------------+
|i3 : isCanonical(I)           |
|                              |
|o3 = false                    |
+------------------------------+

Ways to use isCanonical:
========================

  * "isCanonical(Ideal)"

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

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

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

The source of this document is in NeuralIdeals.m2:929:0.

isWellDefined -- determines whether a NeuralCode is well-defined
****************************************************************

  * Usage:
        isWellDefined(C)
  * Inputs:
      * C, a NeuralCode
  * Outputs:
      * Boolean

Ways to use isWellDefined:
==========================

  * "isWellDefined(Matrix)" -- see isWellDefined (Macaulay2Doc),
    -- whether a map is well defined
  * "isWellDefined(NeuralCode)"
  * "isWellDefined(RingMap)" -- see isWellDefined (Macaulay2Doc),
    -- whether a map is well defined

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

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

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

The source of this document is in NeuralIdeals.m2:728:0.

Iterative -- the default method for computing the canonical form of a neural code
*********************************************************************************

  * Usage:
        canonicalForm(C,Iterative=>false)
  * Inputs:
      * C, a NeuralCode
  * Outputs:
      * a List of pseudomonomials in ring(C)

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

By default, the canonical form of a neural code is computed using the iterative
method of Petersen, Youngs, et al. If set to false, this instead computes the
neural ideal and then its canonical form using the primary decomposition method
of Curto, Itskov, et al.

Functions with optional argument named Iterative:
=================================================

  * "canonicalForm(NeuralCode,Iterative=>...)" -- see canonicalForm,
    -- computes the canonical form of a neural ideal

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

The object Iterative, is a symbol (Macaulay2Doc).

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

The source of this document is in NeuralIdeals.m2:810:0.

NeuralCode -- type of a neural code
***********************************

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

Stores the data of a neural code, specifically its code words, dimension, ring,
and polarized ring.

Functions and methods returning a neural code:
==============================================

  * "neuralCode(Ideal)" -- see neuralCode, -- creates a
    NeuralCode object
  * "neuralCode(List)" -- see neuralCode, -- creates a
    NeuralCode object
  * "neuralCode(List,Ring)" -- see neuralCode, -- creates a
    NeuralCode object
  * "neuralCode(List,Ring,Ring)" -- see neuralCode, --
    creates a NeuralCode object
  * "neuralCode(List,String,String)" -- see neuralCode, --
    creates a NeuralCode object

Methods that use a neural code:
===============================

  * "NeuralCode == NeuralCode" -- see ==, -- determines whether two
    NeuralCodes are equal
  * "canonicalForm(NeuralCode)" -- see canonicalForm, --
    computes the canonical form of a neural ideal
  * "canonicalResolution(NeuralCode)" -- see canonicalResolution,
    -- canonical resolution of a neural code
  * "codeSupport(NeuralCode)" -- see codeSupport, -- lists
    which neurons fire together
  * "dim(NeuralCode)" -- see dim, -- dimension of a NeuralCode
  * "isWellDefined(NeuralCode)" -- see isWellDefined, --
    determines whether a NeuralCode is well-defined
  * "neuralIdeal(NeuralCode)" -- see neuralIdeal, --
    computes the neural ideal of a neural code.
  * "polarizedCanonicalForm(NeuralCode)" -- see polarizedCanonicalForm,
    -- computes the polarized canonical form
  * "polarizedCanonicalIdeal(NeuralCode)" -- see polarizedCanonicalIdeal,
    -- polarized ideal generated by the canonical form
  * "polarizedCanonicalResolution(NeuralCode)" -- see
    polarizedCanonicalResolution, -- computes the
    polarized canonical resolution
  * "polarizedRing(NeuralCode)" -- see polarizedRing, --
    returns the polarized ring of a NeuralCode
  * "ring(NeuralCode)" -- see ring, -- ring of a NeuralCode

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

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

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

The source of this document is in NeuralIdeals.m2:644:0.

neuralCode -- creates a NeuralCode object
*****************************************

  * Usage:
        neuralCode(L) or neuralCode(L,s,t) or neuralCode(L,R,S) or neuralCode(L,R) or neuralCode(I)
  * Inputs:
      * L, a list of binary strings of the same length like 000 and 101
      * s and t, strings to names the variables in the ring of C and the
        polarized ring of C
      * R and S, the ring of C and polarized ring of C, or R, the ring of C
      * I, an squarefree pseudomonomial ideal or squarefree monomial ideal
  * Outputs:
      * a NeuralCode

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

Create a NeuralCode from a list of binary strings or an ideal. By default,
Macaulay2 will choose the ring and polarized ring of the code, but these can be
specified by giving strings for the variable names or inputting rings.
+---------------------------------------+
|i1 : C=neuralCode({"000","001","101"});|
+---------------------------------------+
|i2 : dim C                             |
|                                       |
|o2 = 3                                 |
+---------------------------------------+
|i3 : ring C                            |
|                                       |
|     ZZ                                |
|o3 = --[x ..x ]                        |
|      2  1   3                         |
|                                       |
|o3 : PolynomialRing                    |
+---------------------------------------+
|i4 : polarizedRing C                   |
|                                       |
|     ZZ                                |
|o4 = --[x ..y ]                        |
|      2  1   3                         |
|                                       |
|o4 : PolynomialRing                    |
+---------------------------------------+
+---------------------------------------+
|i5 : D=neuralCode({"00","10"},"z","w");|
+---------------------------------------+
|i6 : ring D                            |
|                                       |
|     ZZ                                |
|o6 = --[z ..z ]                        |
|      2  1   2                         |
|                                       |
|o6 : PolynomialRing                    |
+---------------------------------------+
|i7 : polarizedRing D                   |
|                                       |
|     ZZ                                |
|o7 = --[z ..z , w ..w ]                |
|      2  1   2   1   2                 |
|                                       |
|o7 : PolynomialRing                    |
+---------------------------------------+
+-----------------------------------------+
|i8 : R=ZZ/2[x_1,x_2];                    |
+-----------------------------------------+
|i9 : S=ZZ/2[x_1,x_2,y_1,y_2];            |
+-----------------------------------------+
|i10 : E=neuralCode({"00","10","11"},R,S);|
+-----------------------------------------+
|i11 : ring E                             |
|                                         |
|o11 = R                                  |
|                                         |
|o11 : PolynomialRing                     |
+-----------------------------------------+
|i12 : polarizedRing E                    |
|                                         |
|o12 = S                                  |
|                                         |
|o12 : PolynomialRing                     |
+-----------------------------------------+
+----------------------------------------------+
|i13 : R=ZZ/2[x_1,x_2];                        |
+----------------------------------------------+
|i14 : I=ideal(x_1*x_2);                       |
|                                              |
|o14 : Ideal of R                              |
+----------------------------------------------+
|i15 : neuralCode(I)                           |
|                                              |
|o15 = NeuralCode{cache => CacheTable{...2...}}|
|                 codeWords => {00, 01, 10}    |
|                 dimension => 2               |
|                                              |
|o15 : NeuralCode                              |
+----------------------------------------------+
+----------------------------------------------+
|i16 : S=ZZ/2[x_1,x_2,y_1,y_2];                |
+----------------------------------------------+
|i17 : I=ideal(x_1*y_2);                       |
|                                              |
|o17 : Ideal of S                              |
+----------------------------------------------+
|i18 : F=neuralCode(I,Polarized=>true)         |
|                                              |
|o18 = NeuralCode{cache => CacheTable{...2...}}|
|                 codeWords => {00, 01, 11}    |
|                 dimension => 2               |
|                                              |
|o18 : NeuralCode                              |
+----------------------------------------------+

Ways to use neuralCode:
=======================

  * "neuralCode(Ideal)"
  * "neuralCode(List)"
  * "neuralCode(List,Ring)"
  * "neuralCode(List,Ring,Ring)"
  * "neuralCode(List,String,String)"

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

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

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

The source of this document is in NeuralIdeals.m2:690:0.

neuralIdeal -- computes the neural ideal of a neural code.
**********************************************************

  * Usage:
        neuralIdeal(C)
  * Inputs:
      * C, a NeuralCode
  * Outputs:
      * an ideal, the neural ideal of C in ring C

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

This method computes the neural ideal using the method of Curto, Itskov, et al.
The returned ideal is not in general in canonical form.
+-----------------------------------------------------------------------------+
|i1 : C=neuralCode({"000","001"});                                            |
+-----------------------------------------------------------------------------+
|i2 : ring C;                                                                 |
+-----------------------------------------------------------------------------+
|i3 : I=neuralIdeal(C)                                                        |
|                                                                             |
|o3 = ideal (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    2 3    2   1 2 3    2 3   1 2 3    1 2    1 3   |
|     ------------------------------------------------------------------------|
|     x , x x x  + x x , x x x  + x x , x x x )                               |
|      1   1 2 3    1 3   1 2 3    1 2   1 2 3                                |
|                                                                             |
|              ZZ                                                             |
|o3 : Ideal of --[x ..x ]                                                     |
|               2  1   3                                                      |
+-----------------------------------------------------------------------------+
|i4 : ring I                                                                  |
|                                                                             |
|     ZZ                                                                      |
|o4 = --[x ..x ]                                                              |
|      2  1   3                                                               |
|                                                                             |
|o4 : PolynomialRing                                                          |
+-----------------------------------------------------------------------------+

Ways to use neuralIdeal:
========================

  * "neuralIdeal(NeuralCode)"

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

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

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

The source of this document is in NeuralIdeals.m2:769:0.

Polar
*****

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

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

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

The source of this document is in currentString:1:378.

Polarized -- determine whether a polarized ideal is in canonical form
*********************************************************************

  * Usage:
        isCanonical(C,Polarized=>true)
  * Inputs:
      * C, a NeuralCode
  * Outputs:
      * Boolean

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

Use this option if trying to determine whether a polarized ideal is in
canonical form.

Functions with optional argument named Polarized:
=================================================

  * "isCanonical(...,Polarized=>...)" -- see isCanonical, --
    determines whether a neural ideal is in canonical form
  * "neuralCode(Ideal,Polarized=>...)" -- see neuralCode, --
    creates a NeuralCode object

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

The object Polarized, is a symbol (Macaulay2Doc).

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

The source of this document is in NeuralIdeals.m2:938:0.

polarizedCanonicalForm -- computes the polarized canonical form
***************************************************************

  * Usage:
        polarizedCanonicalForm(C,S) or polarizedCanonicalForm(C) or polarizedCanonicalForm(I,S)
  * Inputs:
      * C,a neural code or I, an ideal
      * S, a ring where the polarization will live
  * Outputs:
      * a List of squarefree monomials (in S if S is specified, else in
        polarizedRing(C)

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

A method that returns the polarized canonical form of a neural code or neural
ideal
+---------------------------------------------------+
|i1 : S=ZZ/2[x_1..x_3,y_1..y_3];                    |
+---------------------------------------------------+
|i2 : C=neuralCode({"000","100","110","101","001"});|
+---------------------------------------------------+
|i3 : polarizedCanonicalForm(C)                     |
|                                                   |
|o3 = {x y , x x }                                  |
|       2 1   2 3                                   |
|                                                   |
|o3 : List                                          |
+---------------------------------------------------+
+--------------------------------+
|i4 : R=ZZ/2[x_1..x_3];          |
+--------------------------------+
|i5 : I=ideal(x_1,x_2*(1-x_1));  |
|                                |
|o5 : Ideal of R                 |
+--------------------------------+
|i6 : S=ZZ/2[x_1..x_3,y_1..y_3]; |
+--------------------------------+
|i7 : polarizedCanonicalForm(I,S)|
|                                |
|o7 = {x , x }                   |
|       1   2                    |
|                                |
|o7 : List                       |
+--------------------------------+

Ways to use polarizedCanonicalForm:
===================================

  * "polarizedCanonicalForm(Ideal)"
  * "polarizedCanonicalForm(Ideal,Ring)"
  * "polarizedCanonicalForm(NeuralCode)"

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

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

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

The source of this document is in NeuralIdeals.m2:891:0.

polarizedCanonicalIdeal -- polarized ideal generated by the canonical form
**************************************************************************

  * Usage:
        polarizedCanonicalIdeal(C) or polarizedCanonicalIdeal(I,S)
  * Inputs:
      * C, a NeuralCode, or I, a squarefree pseudomonomial ideal
      * S a ring where the polarization will live
  * Outputs:
      * A squarefree monomial ideal, in polarizedRing(C) or in S.

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

A method that returns the ideal generated by the polarized canonical form of a
neural code or neural ideal.
+-------------------------------+
|i1 : C=neuralCode({"00","10"});|
+-------------------------------+
|i2 : polarizedCanonicalIdeal(C)|
|                               |
|o2 = ideal x                   |
|            2                  |
|                               |
|              ZZ               |
|o2 : Ideal of --[x ..y ]       |
|               2  1   2        |
+-------------------------------+
+---------------------------------+
|i3 : R=ZZ/2[x_1,x_2];            |
+---------------------------------+
|i4 : I=ideal(x_1*x_2);           |
|                                 |
|o4 : Ideal of R                  |
+---------------------------------+
|i5 : S=ZZ/2[x_1,x_2,y_1,y_2];    |
+---------------------------------+
|i6 : polarizedCanonicalIdeal(I,S)|
|                                 |
|o6 = ideal(x x )                 |
|            1 2                  |
|                                 |
|o6 : Ideal of S                  |
+---------------------------------+

Ways to use polarizedCanonicalIdeal:
====================================

  * "polarizedCanonicalIdeal(Ideal)"
  * "polarizedCanonicalIdeal(Ideal,Ring)"
  * "polarizedCanonicalIdeal(NeuralCode)"

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

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

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

The source of this document is in NeuralIdeals.m2:913:0.

polarizedCanonicalResolution -- computes the polarized canonical resolution
***************************************************************************

  * Usage:
        polarizedCanonicalResolution(C)
  * Inputs:
      * C, a NeuralCode
  * Outputs:
      * a free resolution over polarizedRing(C)

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

A method that computes the polarized canonical resolution of a neural code,
i.e. the minimal free resolution of the ideal generated by its polarized
canonical form. When depolarized, this gives the canonical resolution of
Gunturkun, Jeffries, and Sun.
+------------------------------------+
|i1 : C=neuralCode({"00","10","01"});|
+------------------------------------+
|i2 : polarizedCanonicalResolution(C)|
|                                    |
|      ZZ         1      ZZ         1|
|o2 = (--[x ..y ])  <-- (--[x ..y ]) |
|       2  1   2          2  1   2   |
|                                    |
|     0                 1            |
|                                    |
|o2 : Complex                        |
+------------------------------------+

Ways to use polarizedCanonicalResolution:
=========================================

  * "polarizedCanonicalResolution(NeuralCode)"

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

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

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

The source of this document is in NeuralIdeals.m2:951:0.

polarizedRing -- returns the polarized ring of a NeuralCode
***********************************************************

  * Usage:
        polarizedRing(C)
  * Inputs:
      * C, a NeuralCode
  * Outputs:
      * a ring, the polarized ring of the neural code

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

Return the polarized ring of a neural code, i.e. a ring with 2n variables,
where n is the dimension of the neural code.
+---------------------------------------+
|i1 : C=neuralCode({"000","001","101"});|
+---------------------------------------+
|i2 : polarizedRing(C)                  |
|                                       |
|     ZZ                                |
|o2 = --[x ..y ]                        |
|      2  1   3                         |
|                                       |
|o2 : PolynomialRing                    |
+---------------------------------------+
+--------------------------------------------+
|i3 : D=neuralCode({"00","10","11"},"z","w");|
+--------------------------------------------+
|i4 : polarizedRing(D)                       |
|                                            |
|     ZZ                                     |
|o4 = --[z ..z , w ..w ]                     |
|      2  1   2   1   2                      |
|                                            |
|o4 : PolynomialRing                         |
+--------------------------------------------+

Ways to use polarizedRing:
==========================

  * "polarizedRing(NeuralCode)"

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

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

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

The source of this document is in NeuralIdeals.m2:754:0.

polarizeList -- polarizes a list of ring elements
*************************************************

  * Usage:
        polarizeList(L,S) or polarizeList(L)
  * Inputs:
      * L, a list of squarefree pseudomonomials in a polynomial ring R
      * S, a ring with twice as many variables as R, where the polarization
        will live
  * Outputs:
      * a list of squarefree monomials (in S if S is given)

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

A method which takes a list of pseudomonomials in a polynomial ring and
replaces every instance of (1-var) with a new variable. It is recommended that
you specify the ring in which the new monomial will live, see examples below.
+---------------------------------+
|i1 : R=ZZ/2[x_1..x_3];           |
+---------------------------------+
|i2 : L={x_1*(1-x_2),x_2*(1-x_3)};|
+---------------------------------+
|i3 : S=ZZ/2[x_1..x_3,y_1..y_3];  |
+---------------------------------+
|i4 : polarizeList(L,S)           |
|                                 |
|o4 = {x y , x y }                |
|       1 2   2 3                 |
|                                 |
|o4 : List                        |
+---------------------------------+

Ways to use polarizeList:
=========================

  * "polarizeList(List)"
  * "polarizeList(List,Ring)"

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

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

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

The source of this document is in NeuralIdeals.m2:868:0.

polarizePseudomonomial -- polarizes a pseudomonomial
****************************************************

  * Usage:
        polarizePseudomonomial(f,S) or polarizePseudomonomial(f)
  * Inputs:
      * f, a squarefree pseudomonomial
      * S, a ring with twice as many variables as ring(f), where the
        polarization will live
  * Outputs:
      * a squarefree monomial (in S if S is given)

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

A method which takes a pseudomonomial in a polynomial ring and replaces every
instance of (1-var) with a new variable. It is recommended that you specify the
ring in which the new monomial will live, see examples below.
+--------------------------------+
|i1 : R=ZZ/2[x_1..x_3];          |
+--------------------------------+
|i2 : f=x_1*(1-x_2);             |
+--------------------------------+
|i3 : S=ZZ/2[x_1..x_3,y_1..y_3]; |
+--------------------------------+
|i4 : polarizePseudomonomial(f,S)|
|                                |
|o4 = x y                        |
|      1 2                       |
|                                |
|o4 : S                          |
+--------------------------------+

Ways to use polarizePseudomonomial:
===================================

  * "polarizePseudomonomial(RingElement)"
  * "polarizePseudomonomial(RingElement,Ring)"

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

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

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

The source of this document is in NeuralIdeals.m2:853:0.

receptiveFieldRelation -- gives the receptive field relation corresponding ot a pseudomonomial
**********************************************************************************************

  * Usage:
        receptiveFieldRelation(f)
  * Inputs:
      * f, a squarefree pseudomonomial
  * Outputs:
      * a List of two Lists

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

A method which returns the receptive field relation corresponding to a
pseudomonomial. It returns it as a list containing two lists, such that the
intersection of the firing fields corresponding to the elements of the first
list is contained in the union of the firing fields corresponding to the
elements of the second list.
+------------------------------+
|i1 : R=ZZ/2[x_1..x_3];        |
+------------------------------+
|i2 : f=x_1*(1-x_2)*(1-x_3);   |
+------------------------------+
|i3 : receptiveFieldRelation(f)|
|                              |
|o3 = {{1}, {2, 3}}            |
|                              |
|o3 : List                     |
+------------------------------+

Ways to use receptiveFieldRelation:
===================================

  * "receptiveFieldRelation(RingElement)"

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

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

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

The source of this document is in NeuralIdeals.m2:838:0.

ring -- ring of a NeuralCode
****************************

  * Usage:
        ring(C)
  * Inputs:
      * C, a NeuralCode
  * Outputs:
      * a ring

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

Returns the ring of a neural code, i.e. a ring with one variable per neuron,
where the neural ideal will live.

Ways to use ring:
=================

  * "ring(CC)" -- see ring (Macaulay2Doc), -- get the associated
    ring of an object
  * "ring(CCi)" -- see ring (Macaulay2Doc), -- get the associated
    ring of an object
  * "ring(GroebnerBasis)" -- see ring (Macaulay2Doc), -- get the
    associated ring of an object
  * "ring(Ideal)" -- see ring (Macaulay2Doc), -- get the associated
    ring of an object
  * "ring(Matrix)" -- see ring (Macaulay2Doc), -- get the associated
    ring of an object
  * "ring(Module)" -- see ring (Macaulay2Doc), -- get the associated
    ring of an object
  * "ring(MutableMatrix)" -- see ring (Macaulay2Doc), -- get the
    associated ring of an object
  * "ring(NeuralCode)"
  * "ring(Number)" -- see ring (Macaulay2Doc), -- get the associated
    ring of an object
  * "ring(RingElement)" -- see ring (Macaulay2Doc), -- get the
    associated ring of an object
  * "ring(RR)" -- see ring (Macaulay2Doc), -- get the associated
    ring of an object
  * "ring(RRi)" -- see ring (Macaulay2Doc), -- get the associated
    ring of an object
  * "ring(Vector)" -- see ring (Macaulay2Doc), -- get the associated
    ring of an object
  * ring(ComplexField) (missing documentation)
  * ring(Constant) (missing documentation)
  * ring(RealField) (missing documentation)

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

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

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

The source of this document is in NeuralIdeals.m2:720:0.

SharedIndex -- the default method for computing the canonical form of a neural ideal
************************************************************************************

  * Usage:
        canonicalForm(I,SharedIndex=>true)
  * Inputs:
      * I, a squarefree pseudomonomial ideal
  * Outputs:
      * a List of pseudomonomials in ring(I)

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

By default, the canonical form of a squarefree pseudomonomial ideal is computed
by the shared index method of Geller and R.G., but if set to false this instead
computes the canonical form using the primary decomposition method of Curto,
Itskov, et al.

Functions with optional argument named SharedIndex:
===================================================

  * "canonicalForm(Ideal,SharedIndex=>...)" -- see canonicalForm,
    -- computes the canonical form of a neural ideal

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

The object SharedIndex, is a symbol (Macaulay2Doc).

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

The source of this document is in NeuralIdeals.m2:801:0.