Macaulay2 : Table of Contents

• Macaulay2
  • Copyright and license
    • COPYING -- the Macaulay 2 license agreement
    • Singular-Factory
    • Singular-Libfac
    • GNU MP
    • GC garbage collector
  • Acknowledgements
  • The authors
    • Daniel R. Grayson
    • Michael E. Stillman
    • David Eisenbud
  • Other sources of information about Macaulay 2
  • getting started
    • checking your Macaulay2 installation -- and bookmarking the Macaulay2 documentation
    • finding the Macaulay 2 files
    • teaching M2 how to find its shared libraries
    • teaching your shell how to find M2
    • moving or copying the Macaulay 2 files
    • setting up the Macaulay2 emacs interface
    • teaching emacs how to find M2-init.el
    • teaching emacs how to find M2
    • using Macaulay2 with emacs
    • a first Macaulay 2 session
    • reading the documentation
    • getting help or reporting bugs
    • what to read next??
  • rings
    • basic rings of numbers
    • integers modulo a prime
    • finite fields
    • polynomial rings
    • monoid -- make or retrieve a monoid
    • monomial orderings
      • examples of specifying alternate monomial orders
      • monomial orders for free modules
        • Schreyer orders -- induced monomial order on a free module
      • packing monomials for efficiency
      • GRevLex -- graded reverse lexicographical monomial order.
      • Lex -- lexicographical monomial order.
      • GLex -- graded lexicographic ordering
      • Weights -- assigning weights to the variables
      • Eliminate -- elimination order
      • GroupLex -- defines a ring where some variables are inverted
      • GroupRevLex
      • definition of product (block) orders
      • RevLex -- reverse lexicographic ordering
      • NCLex -- Non-commutative lexicographical order.
      • MonomialOrder -- monomial ordering
      • obtaining the monomial order of a ring
    • graded and multigraded polynomial rings
    • quotient rings
    • manipulating polynomials
    • factoring polynomials
    • fraction fields
    • finite field extensions
    • exterior algebras
    • symmetric algebras
    • tensor products of rings
    • Weyl algebras
    • associative algebras
  • ideals
    • creating an ideal
    • ideals to and from matrices
    • ideals to and from modules
    • sums, products, and powers of ideals
    • equality and containment
    • extracting generators of an ideal
    • dimension, codimension, and degree
    • intersection of ideals
    • ideal quotients and saturation
    • radical of an ideal
    • minimal primes of an ideal
    • associated primes of an ideal
    • primary decomposition
  • matrices
    • inputting a matrix
    • projections, inclusions, and permutations
    • random and generic matrices
    • extracting information about a matrix
    • basic arithmetic of matrices
    • concatenating matrices
    • submatrices
    • differentiation
    • rank of a matrix
    • determinants and minors
    • Pfaffians
    • exterior power of a matrix
    • format and display of matrices in Macaulay 2
    • importing and exporting matrices
  • substitution and maps between rings
    • substitute -- substituting values for variables
    • working with multiple rings
    • basic construction, source and target of a ring map
    • evaluation and composition of ring maps
    • kernel and image of a ring map
    • preimage of an ideal -- missing documentation
    • graphIdeal(RingMap) -- the ideal of the graph of the regular map corresponding to a ring map
    • graphRing(RingMap) -- the coordinate ring of the graph of the regular map corresponding to a ring map
  • modules
    • free modules
    • matrices to and from modules -- including kernel, cokernel and image
    • submodules and quotients
    • subquotient modules -- the way Macaulay 2 represents modules
    • module homomorphisms
    • canonical maps between modules -- empty
    • right modules or left modules?
    • direct sums of modules -- empty
    • tensor products of modules -- empty
    • Hom modules and homomorphisms -- empty
    • annihilators and submodule quotients -- empty
    • Hilbert functions and free resolutions -- including degree and betti numbers
    • degrees of elements and free modules -- empty
    • degree and multiplicity of a module -- empty
    • basis -- basis of all or part of a module or ring
    • Hilbert functions and polynomials -- empty
    • homogenization -- empty
    • truncation and homogeneous components of a graded module -- empty
    • exterior power of a module
    • Fitting ideals -- empty
    • adjoints of maps -- empty
    • Ext and Tor -- empty
    • local cohomology -- empty
    • is a module Cohen-Macaulay? -- empty
  • chain complexes
    • free resolutions of modules
    • extracting information from chain complexes
    • making chain complexes by hand
    • manipulating chain complexes
    • maps between chain complexes
  • varieties
    • algebraic varieties -- missing documentation
    • coherent sheaves
    • Variety -- the class of all algebraic varieties
  • Groebner bases
    • what is a Groebner basis?
    • Groebner basis examples and applications
      • simple Groebner basis computations over various rings
      • Groebner bases in local rings -- missing documentation
    • computing Groebner bases
    • partial computation of a Groebner basis -- missing documentation
    • Hilbert driven Groebner basis -- missing documentation
  • normal forms
  • Hilbert functions
  • elimination of variables
  • syzygies
  • saturation
  • fibers of a map between varieties
  • solving systems of polynomial equations
  • integralClosure -- compute the integral closure of a ring
  • primaryDecomposition -- irredundant primary decomposition of an ideal
  • combinatorial functions
  • The Macaulay2 language
    • variables
      • valid names
      • assigning values
      • local variables in a file
      • viewing the symbols defined so far
      • subscripted variables
      • numbered variables
    • numeric types
    • strings and nets
      • /// -- delineate a string
      • concatenate -- join strings
      • format -- format a string
      • lines -- split a string into lines
      • separate -- split a string into pieces
      • regular expressions
        • match -- regular expression matching
          • match(String,String) -- regular expression matching
        • regex -- regular expression matching
          • regex(String,String) -- regular expression matching
          • regex(String,ZZ,String) -- regular expression matching
        • replace -- regular expression replacement
          • replace(String,String,String) -- regular expression replacement
        • select(String,String) -- select substrings matching a regular expression from a string
        • select(String,String,String) -- select substrings matching a regular expression from a string
      • horizontalJoin -- join nets or strings horizontally
      • stack -- join nets or string vertically
      • unstack -- list the rows of a net
      • String -- the class of all strings
      • Net -- the class of all nets and strings
    • lists and sequences
      • ranges and repetitions
      • # BasicList -- length
      • BasicList # ZZ -- get element from list
      • BasicList #? ZZ -- check for element in list
      • VisibleList _ ZZ -- get element from list
      • VisibleList _ List -- get some entries of a list
      • first -- first element of a list
      • last -- last element of a list
      • toList -- list of elements
      • toSequence -- convert to sequence
      • sequence -- make a sequence
      • unsequence -- extract the single element from a sequence of length 1
      • append -- append an element to a list
      • between -- insert something between elements of a list
      • delete -- delete elements of a list
      • drop -- drop some elements from a list or sequence
      • flatten -- flatten a list by unnesting lists
      • fold -- apply binary operator repeatedly
      • join -- join lists
      • List | List -- join lists, sequences or arrays
      • mingle -- mingle elements of several lists
      • pack -- pack elements of a list into shorter ones
      • prepend -- add an element to the beginning of a list
      • reverse(BasicList) -- reverse a list
      • rsort -- sort a list or matrix in reverse order
      • sort -- sort a list or columns of a matrix
      • subtable -- extract a subtable from a table
      • table -- make a table (nested list)
      • take -- take some elements from a list
      • unique -- eliminate duplicates from a list
      • apply(BasicList,Function) -- apply a function to each element of a list
      • scan(BasicList,Function) -- apply a function to each element of a list
      • all(BasicList,Function) -- whether all elements of a list satisfy a specified condition
      • any(BasicList,Function) -- whether any elements of a list satisfy a specified condition
      • position -- find first element of a list satisfying a condition
      • positions -- which elements of a list satisfy a condition
      • select(BasicList,Function) -- select elements from a list
      • select(ZZ,BasicList,Function) -- select a limited number of elements from a list
      • VisibleList -- the class of all visible lists
        • List -- the class of all lists -- {...}
        • Sequence -- the class of all sequences -- (...)
        • Array -- the class of all arrays -- [...]
      • BasicList -- the class of all basic lists
    • hash tables
      • copy -- copy an object
      • hashTable -- make a hash table
      • keys -- keys used in a hash table
      • values -- values in a hash table
      • pairs -- list the pairs in a hash table
      • mutable -- whether something may be modified
      • remove -- remove an entry from a hash table
      • applyKeys -- apply a function to each key in a hash table
      • applyValues -- apply a function to each value
      • applyPairs -- apply a function to each pair in a hash table
      • merge(HashTable,HashTable,Function) -- merge hash tables
      • combine -- combine hash tables
      • hashing
      • HashTable -- the class of all hash tables
      • MutableHashTable -- the class of all mutable hash tables
    • operators
      • = -- assignment
      • := -- assignment of method or new local variable
      • <- -- assignment with left side evaluated
      • == -- equality
      • != -- inequality
      • === -- strict equality
      • =!= -- strict inequality
      • < -- less than
      • <= -- less than or equal
      • > -- greater than
      • >= -- greater than or equal
      • ? -- comparison operator
      • and -- conjunction
      • or -- disjunction
      • not -- negation
      • SPACE -- blank operator; often used for function application, making polynomial rings
      • -> -- make a function
      • @@ -- a binary operator
      • \\ -- a binary operator
      • \ -- a binary operator
      • _ -- a binary operator, used for subscripting and access to elements
      • . -- access to elements whose key is a symbol
      • .? -- check for presence of elements whose key is a symbol
      • # -- length, or access to elements
      • #? -- check for presence of elements
      • ! -- factorial
      • + -- a unary or binary operator, usually used for addition
      • - -- a unary or binary operator, usually used for negation or subtraction
      • * -- a binary operator, usually used for multiplication
      • / -- a binary operator, usually used for division
      • // -- a binary operator, usually used for quotient
      • % -- a binary operator, usually used for remainder and reduction
      • ^ -- a binary operator, usually used for powers
      • & -- a binary operator
      • ++ -- a binary operator, usually used for direct sum
      • ** -- a binary operator, usually used for tensor product or Cartesian product
      • ^** -- a binary operator, usually used for tensor or Cartesian power
      • ~ -- a unary postfix operator
      • (*) -- a unary postfix operator, used for indicating a graded object
      • : -- a binary operator, uses include repetition; ideal quotients
      • .. -- a binary operator, uses include ranges; sequence of consecutive items
      • << -- a binary operator (file output, ...)
      • >> -- a binary operator, uses include bit shifting, or attaching optional inputs to functions
      • | -- a binary operator, often used for horizontal concatenation
      • || -- a binary operator, often used for vertical concatenation
      • @ -- a binary operator
      • ^^ -- a binary operator
      • |- -- a binary operator
      • <==> -- a binary operator
      • ===> -- a binary operator
      • ==> -- a binary operator
      • => -- produce an Option
      • , -- the comma, used for separating entries in a list or sequence
      • ; -- statement separator
      • precedence of operators
      • operatorAttributes
    • assignment -- missing documentation
    • conditional execution -- if-then-else statements
    • while -- while loops
    • for -- for loops
    • mapping over lists -- apply a function to each element of a list
    • mapping over hash tables -- apply a function to each element of a hash table
    • error handling -- signalling and trapping errors
      • error -- deliver error message
      • try -- catch an error
    • catch -- catch a thrown exception
    • using functions
    • using functions with optional inputs
    • making functions
    • local variables in a function
    • making functions with a variable number of arguments
    • making new functions with optional arguments
    • what a class is
      • class -- class of an object
      • parent -- parent type of an object
      • instance -- whether something has a certain type
      • ancestor(Type,Type) -- whether one type is an ancestor of another
    • installing methods
    • binary methods
    • inheritance
    • making new classes
    • new -- new objects and new types
      • newClass -- set the class and parent of an object
    • printing and formatting for new classes
    • making a new method function
      • method -- make a new method function
    • printing to the screen
    • reading files
    • getting input from the user
    • creating and writing files
    • saving polynomials and matrices in files
    • two dimensional formatting
    • file manipulation -- Unix file manipulation functions
      • fileExists -- whether a file exists
      • isRegularFile -- whether a file is a regular file
      • isDirectory -- whether a file is a directory
      • fileTime -- get or set file modified time
      • copyFile(String,String)
      • moveFile(String,String)
      • removeFile -- unlink a file
      • findFiles(String) -- find files recursively
      • symlinkFile -- make a symbolic link to a file
      • linkFile(String,String) -- make a new link to a file
      • readlink -- readlink fn
      • mkdir
      • makeDirectory(String) -- make a directory
      • copyDirectory(String,String)
      • removeDirectory -- remove a directory
      • symlinkDirectory(String,String) -- make symbolic links for all files in a directory tree
      • readDirectory -- read the contents of a directory
      • realpath -- convert a filename to one passing through no symbolic links
      • temporaryFileName -- make a temporary file name
    • communicating with programs
    • using sockets
    • packages
      • needsPackage -- load a package if not already loaded
      • loadPackage -- load a package
      • installPackage -- load and install a package and its documentation
      • loadedPackages
      • creating a package
        • an example of a package
        • newPackage(String) -- package item: start a new package
        • export -- package item: export functions
        • exportMutable -- package item: export writable variables
        • beginDocumentation -- package item: start documentation section
        • document -- package item: documentation node
        • TEST -- package item: register a test of the package
        • writing documentation
        • check -- perform tests of a package
        • informing others about your package
    • a sample package: Quaternions -- missing documentation
    • system facilities
      • autoload(Symbol,String) -- arrange for a function to be loaded automatically
      • initialization file
      • input -- read Macaulay 2 commands and echo
      • load -- read Macaulay 2 commands
      • needs -- read Macaulay 2 commands if necessary
      • clearEcho -- turn off echoing
      • setEcho -- turn on echoing
      • dumpdata -- dump state of the system to a file
      • loaddata -- load state of the system from a file
      • restart -- restart Macaulay 2
      • addStartFunction -- add a startup function
      • addEndFunction -- add an ending function
      • top level loop
      • alarm -- set an alarm
      • currentDirectory -- current working directory
      • exec -- execute another program
      • exit -- exit the program
      • fork -- fork the process
      • getenv -- get value of environment variable
      • processID -- the process identifier
      • path -- list of directories to look in
      • quit -- quit the program
      • run -- run an external command
      • sleep -- sleep for a while
      • time -- time a computation
      • timing -- time a computation
      • wait -- wait for child process
      • commandLine -- the command line arguments
      • environment -- the environment variables
      • version -- information about this version of the program
      • collectGarbage -- collect the garbage in memory
    • debugging
  • packages provided with Macaulay 2
  • handling hypertext
  • mathematical examples
    • Tutorial: Elementary uses of Groebner bases
    • Tutorial: Canonical Embeddings of Plane Curves and Gonality
    • Tutorial: Fano varieties
    • Tutorial: Divisors
  • basic commutative algebra
    • Elementary uses of Groebner bases I. Math 634 Fall 2005
    • modules in Macaulay2
    • M2SingularBook -- Macaulay2 examples for the Singular book
      • Singular Book 1.1.8 -- computation in fields
      • Singular Book 1.1.9 -- computation in polynomial rings
      • Singular Book 1.1.10 -- methods for creating ring maps
      • Singular Book 1.2.3 -- leading data
      • Singular Book 1.2.13 -- monomial orderings
      • Singular Book 1.3.3 -- properties of ring maps
      • Singular Book 1.3.13 -- computation in quotient rings
      • Singular Book 1.3.15 -- computing with radicals
      • Singular Book 1.4.9 -- global versus local rings
      • Singular Book 1.5.10 -- realization of rings
      • Singular Book 1.6.13 -- normal form
      • Singular Book 1.7.10 -- standard bases
      • Singular Book 1.7.12 -- highest corner
      • Singular Book 1.8.1 -- ideal membership
      • Singular Book 1.8.2 -- linear combination of ideal members
      • Singular Book 1.8.4 -- elimination of variables
      • Singular Book 1.8.6 -- Zariski closure of the image
      • Singular Book 1.8.7 -- solving equations
      • Singular Book 1.8.9 -- radical membership
      • Singular Book 1.8.11 -- intersection of ideals
      • Singular Book 1.8.13 -- quotient of ideals
      • Singular Book 1.8.15 -- saturation
      • Singular Book 1.8.18 -- kernel of a ring map
      • Singular Book 1.8.19 -- algebraic dependence
      • Singular Book 1.8.20 -- subalgebra membership
      • Singular Book 2.1.6 -- matrix operations
      • Singular Book 2.1.7 -- maps induced by Hom
      • Singular Book 2.1.10 -- Submodules of A^n
      • Singular Book 2.1.13 -- kernel, image and cokernel of a module homomorphism
      • Singular Book 2.1.20 -- sum, intersection, module quotient
      • Singular Book 2.1.24 -- submodules, presentation of a module
      • Singular Book 2.1.26 -- computation of Hom
      • Singular Book 2.1.34 -- minimal presentations, prune
      • Singular Book 2.2.15 -- graded rings and modules
      • Singular Book 2.3.10 -- normal form
      • Singular Book 2.3.12 -- standard bases
      • Singular Book 2.4.12 -- resolution and Betti numbers
      • Singular Book 2.4.15 -- homogeneous resolution and graded Betti numbers
      • Singular Book 2.5.5 -- syzygies
      • Singular Book 2.5.18 -- Schreyer resolution
      • Singular Book 2.6.3 -- diagonal form
      • Singular Book 2.6.11 -- cyclic decomposition
      • Singular Book 2.6.15 -- Jordan normal form
      • Singular Book 2.7.5 -- tensor product of maps
      • Singular Book 2.7.9 -- tensor product of modules
      • Singular Book 2.7.14 -- tensor product of rings
      • Singular Book 2.8.1 -- module membership
      • Singular Book 2.8.3 -- elimination of module components
      • Singular Book 2.8.5 -- intersection of modules
      • Singular Book 2.8.6 -- quotient of modules
      • Singular Book 2.8.7 -- radical, zerodivisors of modules
      • Singular Book 2.8.8 -- annihilator and Fitting ideal
      • Singular Book 2.8.9 -- kernel of a module homomorphism
      • Singular Book 2.8.10 -- solving linear equations
  • frequently encountered problems
  • replacements for commands and scripts from Macaulay
  • how Macaulay 2 finds its files
    • LAYOUT -- relative locations of Macaulay 2 files
    • prefixDirectory -- the prefix directory
    • buildHomeDirectory -- the directory where the Macaulay 2 program is being built
    • sourceHomeDirectory -- the directory where the source code is while Macaulay 2 is being built
  • Type -- the class of all types
  • Function -- the class of all functions
• # HashTable -- length
• # Set -- cardinality
• # String -- length
• - List -- negation of a vector
• -- -- comment
• > ZZ -- greater than
• >= ZZ -- greater than or equal
• abs -- absolute value function
• accumulate -- apply binary operator repeatedly
• accumulate(Function,Thing,VisibleList)
• accumulate(Function,VisibleList)
• accumulate(VisibleList,Function)
• accumulate(VisibleList,Thing,Function)
• acos -- compute the arccosine
• addHook(HashTable,Thing,Function) -- add a hook function to an object for later processing
• Adjacent -- the class of all adjacent expression pairs
• adjoint(Matrix,Module,Module) -- an adjoint map
• adjoint1(Matrix,Module,Module) -- an adjoint map
• AffineVariety -- the class of all affine varieties
• AfterEval -- top level method applied after evaluation
• AfterNoPrint -- top level method applied after not printing
• AfterPrint -- top level method applied after printing
• Algorithm
• Alignment
• all -- whether all elements satisfy a specified condition
• all(BasicList,BasicList,Function) -- whether all corresponding elements of a pair of lists satisfy a condition
• all(HashTable,Function) -- whether all key/value pairs in a hash table satisfy a specified condition
• allGenerators -- list of all generators
• ambient -- ambient free module of a subquotient, or ambient ring
• ambient(AffineVariety)
• ambient(CoherentSheaf)
• ambient(GaloisField) -- corresponding quotient ring
• ambient(GradedModule)
• ambient(Matrix)
• ambient(Module) -- ambient free module
• ambient(ProjectiveVariety)
• ambient(Ring) -- ambient polynomial ring
• ANCHOR -- hypertext anchor
• annihilator -- the annihilator ideal
• annihilator of a module
• any -- whether any elements satisfy a specified condition
• any(BasicList,BasicList,Function) -- whether any corresponding elements of a pair of lists satisfy a condition
• any(HashTable,Function) -- whether all key/value pairs in a hash table satisfy a specified condition
• append(BasicList,Thing) -- append an element to a list
• applicationDirectory -- the path to the user's application directory
• applicationDirectorySuffix -- suffix that determines the user's application directory
• apply -- apply a function to each element
• apply(BasicList,BasicList,Function) -- apply a function to pairs of elements, one from each list
• apply(ZZ,Function) -- apply a function to {0,..., n-1}
• applyTable -- apply a function to elements of a table
• apropos(String) -- symbols matching a pattern
• argument -- specify the function in a scripted functor for an argument
• Ascending
• ascii -- ASCII character conversion
• ascii(List) -- ASCII character conversion
• ascii(String) -- ASCII character conversion
• asin -- compute the arcsine
• assert -- assert something is true
• assign -- assign a value
• AssociativeExpression -- the class of associative expressions
• atan -- compute the arctangent
• atan(RR) -- compute the arctangent of a number
• atan(RR,RR) -- compute an angle of a certain triangle
• atEndOfFile(File) -- test for end of file
• backtrace -- whether a backtrace is displayed following an error message
• backupFileRegexp -- a regular expression for recognizing names of backup files
• Bag -- the class of all bags
• Bareiss
• baseFilename -- the base part of a filename or path
• baseName -- the base name of a generator
• baseRings -- store the list of base rings of a ring
• BaseRow
• BasisElementLimit -- stop when this number of basis elements is obtained
• Bayer -- a Strategy option value for saturate
• BeforePrint -- top level method applied before printing results
• benchmark -- accurate timing of execution
• betti -- display degrees
• betti(ChainComplex) -- display of degrees in a chain complex
• betti(GroebnerBasis) -- diagram of the degrees of a groebner basis
• betti(Ideal) -- gives the degrees of generators.
• betti(Matrix) -- display of the degrees of a map
• betti(Module) -- gives the generators and relations of a module or a coherent sheaf.
• BettiTally -- the class of all Betti tallies
• between(Thing,VisibleList) -- insert something between elements of a list
• BinaryOperation -- the class of all binary operation expressions
• binomial -- binomial coefficient
• BLOCKQUOTE -- hypertext BLOCKQUOTE item
• BODY -- hypertext BODY item
• BOLD -- hypertext BOLD item
• Boolean -- the class of Boolean values
• borel(Matrix) -- make a Borel fixed submodule
• Boxes
• BR -- line break
• br -- line break
• break -- break from a loop
• cache -- a key under which to store cache tables
• CacheTable -- hash tables for caching
• cacheValue -- cache values of functions in their arguments
• capture(String) -- evaluate Macaulay 2 code and capture the output (under development)
• CC -- the class of all complex numbers
• CCC -- high-precision complex numbers
• CDATA -- hypertext CDATA element
• ceiling -- ceiling function
• Center
• centerString -- center a string or net
• ChainComplex -- the class of all chain complexes
• chainComplex -- make a chain complex
• ChainComplex ** ChainComplex -- tensor product
• ChainComplex ** ChainComplexMap -- tensor product
• ChainComplex ** GradedModule -- tensor product
• ChainComplex ++ ChainComplex -- direct sum
• ChainComplex ^ ZZ -- access member, cohomological degree
• ChainComplex _ ZZ -- component
• ChainComplex Array -- degree shift
• chainComplex(GradedModule) -- make a chain complex from a graded module
• chainComplex(List) -- make a chain complex
• chainComplex(Matrix) -- make a small chain complex
• chainComplex(Ring) -- make an empty chain complex over a ring
• ChainComplexMap -- the class of all maps between chain complexes
• ChainComplexMap ** ChainComplex -- tensor product
• ChainComplexMap ** ChainComplexMap -- tensor product
• ChainComplexMap ^ ZZ -- iterated composition
• ChainComplexMap _ ZZ -- component map
• ChangeMatrix -- whether to produce the change of basis matrix
• char -- computes the characteristic of a field or ring
• characters -- get characters from a string
• clearAll -- forget everything
• clearOutput -- forget output values
• close -- close a file
• closeIn -- close an input file
• closeOut -- close an output file
• CODE -- hypertext CODE item
• code -- display source code
• codim -- compute the codimension
• codim(CoherentSheaf) -- codimension of the support of a coherent sheaf on a projective variety
• codim(Ideal) -- compute the codimension
• codim(Module) -- codimension of the support of a module
• codim(ProjectiveVariety) -- codimension of the projective variety
• codim(QuotientRing) -- compute the codimension
• CodimensionLimit -- stop when this codimension is reached
• coefficient -- coefficient of a monomial
• CoefficientRing
• coefficientRing -- get the coefficient ring
• coefficients -- monomials and their coefficients
• coefficients(..., Monomials => ...) -- specify monomials
• coefficients(..., Variables => ...) -- take coefficients using these variables
• Cofactor
• CoherentSheaf -- the class of all coherent sheaves
• CoherentSheaf (*) -- sum of twists
• CoherentSheaf ** CoherentSheaf -- tensor product of coherent sheaves
• CoherentSheaf ++ CoherentSheaf -- direct sum of coherent sheaves
• CoherentSheaf / CoherentSheaf -- quotient of coherent sheaves
• CoherentSheaf ^ ZZ -- direct sum
• CoherentSheaf ^** ZZ -- tensor power
• CoherentSheaf ZZ -- canonical twist of a coherent sheaf
• cohomology -- general cohomology functor
• cohomology(..., Degree => ...)
• coimage -- coimage of a map
• cokernel -- cokernel of a map of modules, graded modules, or chaincomplexes
• columnAdd -- add a multiple of one column to another
• columnate -- arrange strings in columns
• columnMult -- multiply a column by a ring element
• columnPermute -- permute some columns
• columnSwap -- interchange columns
• Command -- the class of all commands
• commandInterpreter -- the top level command interpreter
• COMMENT -- hypertext COMMENT element
• comodule -- submodule to quotient module
• compactMatrixForm -- global flag for compact printing
• comparison operators
• CompiledFunction -- the class of all compiled functions
• CompiledFunctionBody -- the class of all compiled function bodies
• CompiledFunctionClosure -- the class of all compiled function closures
• complement(Matrix) -- find the minimal generators for cokernel of a matrix (low level form)
• complete
• complete(ChainComplex) -- complete the internal parts
• CompleteIntersection -- provide a hint when computing a radical
• component example
• components -- list the components of a direct sum
• components(ChainComplex) -- list the components of a direct sum
• compositions -- compositions of an integer
• compress -- extract nonzero columns from a matrix
• computing resolutions
• computing syzygies
• conductor -- compute the conductor of a finite ring map
• cone -- mapping cone of a chain map
• cone(ChainComplexMap) -- mapping cone of a chain map
• conjugate -- complex conjugate
• conjugate(CC) -- complex conjugate
• conjugate(Partition) -- conjugate a partition
• connectionCount -- the number of connections
• constructing maps between modules
• content(RingElement) -- the content of a polynomial
• continue -- continue with the next iteration of a loop
• contract -- contract one matrix by another
• contract'(Matrix,Matrix) -- contract a matrix by a matrix, the dual notion
• contract(Matrix,Matrix) -- contract a matrix by a matrix
• conventions for documentation
• copyDirectory(..., UpdateOnly => ...)
• copyright -- a string containing the copyright notice for Macaulay 2
• cos -- compute the cosine
• cosh -- compute the hyperbolic cosine
• cotangentSheaf -- cotangent sheaf of a projective variety
• cotangentSheaf(ProjectiveVariety) -- cotangent sheaf of a projective variety
• cotangentSheaf(ZZ,ProjectiveVariety) -- exterior powers of the cotangent sheaf of a projective variety
• cover -- get the covering free module
• cover(Matrix) -- get the covering free module
• cover(Module) -- get the covering free module
• coverMap(Module) -- the surjective map from a free module to a module corresponding to the generators
• currentFileDirectory -- the directory containing the current input file
• currentFileName -- the current source file
• currentLineNumber -- current line number of the current input file
• currentPackage -- the current package
• currentTime -- get the current time
• Database -- the class of all database files
• Database # String -- get value from database
• Database #? String -- check for value in database
• DD -- hypertext DD element
• dd -- differential in a chain complex
• debug -- open private dictionary of a package
• debugError -- a function to debug
• DebuggingMode
• debuggingMode -- whether to enter the debugger when an error occurs
• debugLevel -- current level debugging
• deepSplice -- remove subsequences
• Degree
• degree
• degree(Ideal)
• degree(Matrix)
• degree(Module)
• degree(ProjectiveHilbertPolynomial)
• degree(ProjectiveVariety)
• degree(Ring)
• degree(RingElement)
• degree(RingElement,RingElement) -- degree with respect to a variable
• degreeLength -- the number of degrees
• DegreeLimit -- compute up to a certain degree
• DegreeMap
• DegreeOrder -- sort primarily by degree
• degrees -- degrees of generators
• degrees(CoherentSheaf) -- degrees of generators
• degrees(Ideal) -- degrees of generators
• degrees(Matrix) -- degrees of generators
• degrees(Module) -- degrees of generators
• degrees(Ring) -- degrees of generators
• degreesMonoid -- get the monoid of degrees
• degreesRing -- the ring of degrees
• degreesRing(Ring) -- the ring of degrees
• degreesRing(ZZ) -- the ring of degrees
• demark -- insert a string between elements of a list of strings
• denominator -- denominator of a fraction
• Dense
• depth -- depth of a net
• Descending -- specify descending order
• describe -- real description
• Description
• determinant -- determinant of a matrix
• determinant(..., Strategy => ...) -- choose between Bareiss and Cofactor algorithms
• Developer's Corner
  • engine
• diagonalMatrix -- make a diagonal matrix
• diagonalMatrix(Matrix) -- make a diagonal matrix from entries of a matrix
• diagonalMatrix(Ring,List) -- make a diagonal matrix from a list
• Dictionary -- the class of all dictionaries
• dictionary -- determine the dictionary to which a symbol belongs
• dictionaryPath
• diff -- differentiate or take difference
  • diff(RingElement,RingElement) -- differentiation
  • diff(RingElement,Matrix) -- differentiate each entry of a matrix
  • diff(Matrix,RingElement) -- differentiation
  • diff(Matrix,Matrix) -- differentiate a matrix by a matrix
  • diff(ProjectiveHilbertPolynomial)
  • diff(ProjectiveHilbertPolynomial,ZZ)
• diff and contract
• diff'(Matrix,Matrix) -- differentiate a matrix by a matrix, the dual notion
• difference -- difference
• dim -- compute the Krull dimension
• dim(AffineVariety) -- dimension of the affine variety
• dim(Ideal) -- compute the Krull dimension
• dim(Module) -- compute the Krull dimension
• dim(ProjectiveHilbertPolynomial) -- the degree of the Hilbert polynomial
• dim(ProjectiveVariety) -- dimension of the projective variety
• dim(Ring) -- compute the Krull dimension
• directSum -- direct sum of modules or maps
• disassemble -- disassemble pseudocode or a function
• dismiss -- dismiss a package
• DIV -- a hypertext division
• DIV1 -- a single-spaced paragraph separator
• Divide -- the class of all divide expressions
• divideByVariable -- divide all columns by a (power of a) variable
• DivideConquer
• DL -- hypertext DL element
• do -- loop control
• document(..., BaseFunction => ...) -- function for a documented feature
• document(..., Caveat => ...) -- warnings
• document(..., Consequences => ...) -- side-effects of a function
• document(..., Inputs => ...) -- inputs for a function
• document(..., Key => ...) -- key of a documentation node
• document(..., Outputs => ...) -- outputs for a function
• document(..., SeeAlso => ...) -- crossreferences in documentation
• document(..., Subnodes => ...) -- a menu of documentation nodes
• documentation keys
• DocumentTag -- the class of all document tags
• drop(BasicList,List)
• drop(BasicList,ZZ)
• DT -- hypertext DT element
• dual -- dual module or map
• dual(ChainComplex) -- dual
• dual(ChainComplexMap) -- dual of a chain complex
• dual(CoherentSheaf) -- dual coherent sheaf
• dual(Matrix) -- dual of a map
• dual(Module) -- dual module
• dual(MonomialIdeal) -- the Alexander dual of a monomial ideal
• dual(MonomialIdeal,List) -- the Alexander dual
• dual(MonomialIdeal,RingElement) -- the Alexander dual
• eagonNorthcott(Matrix) -- Eagon-Northcott complex of a matrix of linear forms
• echoOff -- turn off echoing
• echoOn -- turn on echoing
• edit -- edit source code
• eigenvalues -- find eigenvalues of a matrix over RR or CC
• eigenvalues(..., Hermitian => ...) -- Hermitian=>true means assume the matrix is symmetric or Hermitian
• eigenvectors -- find eigenvectors of a matrix over RR or CC
• eigenvectors(..., Hermitian => ...) -- Hermitian=>true means assume the matrix is symmetric or Hermitian
• elements -- list of elements
• EliminationOrder -- use the natural elmination order in a pushForward1 computation
• else -- condition testing
• EM -- hypertext EM item
• emacs
  • running Macaulay 2 in emacs
  • editing Macaulay 2 code with emacs
• encapDirectory -- encapsulated installation directory
• Encapsulate
• End -- module of endomorphisms
• end -- stop loading a file
• endl -- end an output line
• endPackage(String) -- end a new package
• Engine -- specify whether a ring is handled by the engine
• engineDebugLevel -- current engine debugging level
• EngineRing -- the class of rings handled by the engine
• entries -- lists the entries of a matrix
• entries(Vector) -- lists the entries of a vector
• equality and containment of modules
• equality versus strict equality
• Equation -- the class of all equation expressions
• erase -- remove a global symbol
• errorCode -- the pseudocode that produced an error
• errorDepth -- set the error printing depth
• euler -- Euler characteristic
• euler(CoherentSheaf) -- Euler characteristic of coherent sheaf
• euler(Ideal) -- Euler characteristic
• euler(Module) -- Euler characteristic
• euler(ProjectiveHilbertPolynomial) -- constant term of the Hilbert polynomial
• euler(ProjectiveVariety) -- topological Euler characteristic of a (smooth) projective variety
• euler(Ring) -- Euler characteristic
• eulers -- list the sectional Euler characteristics
• eulers(CoherentSheaf) -- list the sectional Euler characteristics
• eulers(Ideal) -- list the sectional Euler characteristics
• eulers(Ring) -- list the sectional Euler characteristics
• even -- tell whether an integer is even
• EXAMPLE -- hypertext EXAMPLE item
• ExampleItem -- a type of hypertext for holding example inputs awaiting outputs
• examples -- list the examples in documentation
• Exclude
• exp -- exponential function
• exponents -- list the exponents in a polynomial
• Expression -- the class of all expressions
• expression -- convert to an expression
• Ext -- compute an Ext module
• Ext(Module,Module) -- total Ext module
• Ext^ZZ(CoherentSheaf,CoherentSheaf) -- global Ext
• Ext^ZZ(CoherentSheaf,SumOfTwists) -- global Ext
• Ext^ZZ(Matrix,Module) -- map between Ext modules
• Ext^ZZ(Module,Matrix) -- map between Ext modules
• Ext^ZZ(Module,Module) -- Ext module
• extend -- extend a module map to a chain map, if possible
• extend(ChainComplex,ChainComplex,Matrix) -- extend a module map to a chain map, if possible
• exteriorPower -- exterior power
• exteriorPower(..., Strategy => ...) -- choose between Bareiss and Cofactor algorithms
• exteriorPower(ZZ,CoherentSheaf) -- exterior power
• exteriorPower(ZZ,Matrix) -- exterior power of a matrix
• exteriorPower(ZZ,Module) -- exterior power of a module
• extracting elements
• extracting parts of a subquotient module
• factor -- factor a ring element or a ZZ-module
• factor(Module) -- factor a ZZ-module
• factor(RingElement) -- factor a ring element
• false
• Fano -- Fano scheme
• Fano(ZZ,Ideal) -- Fano scheme
• Fano(ZZ,Ideal,Ring) -- Fano scheme
• File -- the class of all files
• File << Thing -- print to a file
• fileDictionaries -- local dictionaries for loaded files
• fileExitHooks -- a list of hooks (functions) to execute when the current file has been loaded
• fileLength -- the length of a file
• fileMode -- set or get file mode
• fileMode(File) -- get file mode
• fileMode(String) -- get file mode
• fileMode(ZZ,File) -- set file mode
• fileMode(ZZ,String) -- set file mode
• FilePosition -- the class of all file positions
• finding your files under cygwin
• FindOne -- find a primitive element
• findSynonyms(Symbol) -- find synonyms of symbols
• fine control of a Groebner basis computation
• First
• firstkey -- get the first key
• fittingIdeal -- Fitting ideal of a module
• flagLookup -- flag a symbol
• flatten(Matrix) -- puts the columns of a matrix into a single row
• flip(Module,Module) -- matrix of commutativity of tensor product
• floor -- floor function
• flush -- flush output to file
• fold(Function,Thing,VisibleList)
• fold(Function,VisibleList)
• fold(VisibleList,Function)
• fold(VisibleList,Thing,Function)
• FollowLinks
• forceGB -- declare that the columns of a matrix are a Groebner basis
• forceGB(..., ChangeMatrix => ...) -- inform Macaulay2 about the change of basis matrix from GB to generators
• forceGB(..., MinimalMatrix => ...) -- inform Macaulay2 about the minimal generator matrix
• forceGB(..., SyzygyMatrix => ...) -- inform Macaulay2 about the syzygy matrix
• ForestNode -- a type of basic list used to represent a forest, i.e., a list of rooted trees
• Format
• frac -- construct a fraction field
• fraction
• FractionField -- the class of all fraction fields
• frames -- get the frames associated to a closure
• free resolutions
• from -- loop control
• fromDual -- ideal from inverse system
• Function @@ Function -- composition of functions
• function documentation template
• function name documentation template
• Function Thing -- function application
• FunctionApplication -- the class of all function application expressions
• FunctionBody -- the class of function bodies
• functionBody -- get the body of a function
• FunctionClosure -- the class of all function closures
• GaloisField -- the class of all Galois fields
• gb -- compute a Groebner basis
• gb(..., Algorithm => ...) -- set the Groebner basis algorithm
• gb(..., BasisElementLimit => ...)
• gb(..., ChangeMatrix => ...)
• gb(..., CodimensionLimit => ...)
• gb(..., DegreeLimit => ...)
• gb(..., GBDegrees => ...)
• gb(..., HardDegreeLimit => ...)
• gb(..., Hilbert => ...)
• gb(..., PairLimit => ...)
• gb(..., StopBeforeComputation => ...) -- do not actually compute a Groebner basis
• gb(..., StopWithMinimalGenerators => ...)
• gb(..., Strategy => ...) -- set the Groebner basis strategy
• gb(..., SubringLimit => ...)
• gb(..., Syzygies => ...)
• gb(..., SyzygyLimit => ...) -- stop when this number of syzygies is obtained
• gb(..., SyzygyRows => ...)
• GBDegrees
• gbTrace -- provide tracing output during various computations in the engine.
• GC error messages
• gcd -- greatest common divisor
• gcdCoefficients -- gcd with coefficients
• genera -- list of the successive linear sectional arithmetic genera
• genera(CoherentSheaf) -- list of the successive linear sectional arithmetic genera
• genera(Ideal) -- list of the successive linear sectional arithmetic genera
• genera(ProjectiveVariety) -- list of the successive linear sectional arithmetic genera
• genera(Ring) -- list of the successive linear sectional arithmetic genera
• GeneralOrderedMonoid -- the class of all ordered free commutative monoids
• generateAssertions -- generate assert statements from experimental input
• generator -- provide a single generator
• generators -- provide matrix or list of generators
• generators of ideals and modules
• generators(GeneralOrderedMonoid) -- list of generators
• generators(GroebnerBasis) -- the generator matrix of a Groebner basis
• generators(Ideal) -- the generator matrix of an ideal
• generators(Module) -- the generator matrix of a module
• generators(Ring) -- the list of generators of a ring
• genericMatrix -- make a generic matrix of variables
• genericSkewMatrix -- make a generic skew symmetric matrix of variables
• genericSymmetricMatrix -- make a generic symmetric matrix
• genus -- arithmetic genus
• genus(CoherentSheaf) -- arithmetic genus
• genus(ProjectiveVariety) -- arithmetic genus
• genus(Ring) -- arithmetic genus
• get -- get the contents of a file
• getc -- get a byte
• getChangeMatrix -- get the change of basis matrix
• getGlobalSymbol -- create a global symbol in a global dictionary
• getNetFile -- get the sequence of completed lines (nets) from a net file
• getNonUnit -- retrieve a previously discovered non-unit
• getWWW -- get a web page
• GF -- make a finite field
• GF(Ring) -- make a finite field from a ring
• GF(ZZ) -- make a finite field of a given order
• GF(ZZ,ZZ) -- make a finite field of a given prime power order
• global -- get a global symbol
• globalAssignFunction -- the standard method for the global assignment hook
• GlobalAssignHook -- hook for assignment to global variables
• globalAssignment -- install standard global assignment method
• globalAssignmentHooks -- assignment hooks for global symbols
• GlobalDictionary -- the class of all global dictionaries
• globalReleaseFunction -- the standard method for the global variable release hook
• GlobalReleaseHook
• graded modules
• GradedModule -- the class of all graded modules
• gradedModule -- make a graded module
• GradedModule ** ChainComplex -- tensor product
• GradedModule Array -- degree shift
• GradedModuleMap -- the class of all maps between graded modules
• gradedModuleMap -- make a map of graded modules
• Grassmannian(ZZ,ZZ) -- the Grassmannian of linear subspaces of a vector space
• GroebnerBasis -- the class of all Groebner bases
• HardDegreeLimit -- compute only up to this degree
• hash -- hash code of an object
• HashTable # Thing -- get value from hash table
• HashTable #? Thing -- check for value in hash table
• HEAD -- hypertext HEAD item
• HEADER1 -- hypertext HEADER1 item
• HEADER2 -- hypertext HEADER2 item
• HEADER3 -- hypertext HEADER3 item
• HEADER4 -- hypertext HEADER4 item
• HEADER5 -- hypertext HEADER5 item
• HEADER6 -- hypertext HEADER6 item
• HeaderType -- a class of lists with abbreviated constructors
• Headline -- make a headline for a documentation node
• height -- height of a net
• height(File) -- get window height
• help -- help command
• Hermitian
• HH -- general homology and cohomology functor
• hh -- Hodge numbers of a smooth projective variety
• HH ChainComplex -- homology of a chain complex
• HH ChainComplexMap -- homology of a chain complex map
• HH^ZZ ChainComplex -- cohomology of a chain complex
• HH^ZZ ChainComplexMap -- cohomology of a chain complex map
• HH^ZZ CoherentSheaf -- cohomology of a coherent sheaf on a projective variety
• HH^ZZ Module -- local cohomology of a module
• HH^ZZ SheafOfRings -- cohomology of a sheaf of rings on a projective variety
• HH^ZZ SumOfTwists -- coherent sheaf cohomology module
• HH_ZZ ChainComplex -- homology of a chain complex
• HH_ZZ ChainComplexMap -- homology of a chain complex map
• HH_ZZ Sequence
• Hilbert
• hilbertFunction -- compute the Hilbert function
• hilbertFunction(List,Ideal) -- compute the Hilbert function of the quotient of the ambient ring by an ideal
• hilbertFunction(List,Module) -- compute the Hilbert function of a module
• hilbertFunction(List,ProjectiveVariety) -- compute the Hilbert function of a projective variety
• hilbertFunction(List,Ring) -- compute the Hilbert function of a ring
• hilbertPolynomial -- compute the Hilbert polynomial
• hilbertPolynomial(..., Projective => ...) -- choose how to display the Hilbert polynomial
• hilbertPolynomial(CoherentSheaf) -- compute the Hilbert polynomial of the coherent sheaf
• hilbertPolynomial(Ideal) -- compute the Hilbert polynomial of the quotient of the ambient ring by the ideal
• hilbertPolynomial(Module) -- compute the Hilbert polynomial of the module
• hilbertPolynomial(ProjectiveVariety) -- compute the Hilbert polynomial of the projective variety
• hilbertPolynomial(Ring) -- compute the Hilbert polynomial of the ring
• hilbertSeries -- compute the Hilbert series
• hilbertSeries(..., Order => ...) -- display the truncated power series expansion
• hilbertSeries(Ideal) -- compute the Hilbert series of the quotient of the ambient ring by the ideal
• hilbertSeries(Module) -- compute the Hilbert series of the module
• hilbertSeries(ProjectiveHilbertPolynomial) -- compute the Hilbert series of a projective Hilbert polynomial
• hilbertSeries(ProjectiveVariety) -- compute the Hilbert series of a projective variety
• hilbertSeries(Ring) -- compute the Hilbert series of the ring
• hold -- hold something in a holder expression
• Holder -- the class of all holder expressions
• Hom -- module of homomorphisms
• Hom module
• Hom(CoherentSheaf,CoherentSheaf) -- global Hom
• Hom(Matrix,Module) -- induced map on Hom modules
• Hom(Module,ChainComplex)
• Hom(Module,Module) -- module of homomorphisms
• homeDirectory -- the home directory of the user
• Homogeneous
• homogenize -- homogenize with respect to a variable
• homology -- general homology functor
• homology(Matrix,Matrix) -- homology of a pair of maps
• homomorphism -- get the homomorphism from element of Hom
• homomorphisms (maps) between modules -- including elements of modules
• HorizontalSpace
• HR -- hypertext HR element (horizontal rule)
• hr -- horizontal rule
• HREF -- hypertext link
• HTML -- hypertext item
• html -- convert hypertext to html format
• html(TEX) -- conversion of TeX to html
• Hypertext -- the class of mark-up lists used with hypertext
• hypertext -- prepare hypertext for display
• hypertext list format
• HypertextContainer -- the class of mark-up lists that can contain paragraphs
• HypertextParagraph -- the class of mark-up lists that constitute separate paragraphs
• ICfractions -- Compute the fractions integral over a domain.
• ICmap -- natural map from an affine domain into its integral closure.
• id -- identity map
• Ideal -- the class of all ideals
• ideal -- make an ideal
• Ideal * Ideal -- product of ideals
• Ideal + Ideal -- sum of ideals
• Ideal / Ideal -- quotient module
• Ideal ^ ZZ -- power
• ideal(List) -- make an ideal
• ideal(Matrix) -- make an ideal
• ideal(Module) -- converts a module to an ideal
• ideal(MonomialIdeal) -- converts a monomial ideal to an ideal
• ideal(Ring) -- returns the defining ideal
• ideal(RingElement) -- make an ideal
• ideal(Variety) -- returns the defining ideal
• identity -- the identity function
• if -- condition testing
• IgnoreExampleErrors
• ii -- square root of -1
• image -- image of a map
• imaginaryPart -- imaginary part
• IMG -- hypertext IMG item
• ImmutableType -- the class of immutable types
• in -- a keyword used in for-loops
• incomparable -- a result indicating incomparability
• independentSets -- some maximal independent subsets of variables modulo an ideal
• indeterminate -- an indeterminate number
• IndeterminateNumber -- the class of all indeterminate numbers
• index -- numeric index of a ring variable
• indexComponents -- specify keys for components of a direct sum
• IndexedVariable -- the class of all indexed variables
• IndexedVariable _ Ring -- get a ring variable by name
• indices -- indices of a polynomial; also components for a direct sum
• indices(HashTable) -- preferred indices of a direct sum
• indices(RingElement) -- indices of variables occuring in a polynomial
• inducedMap -- compute an induced map
• inducedMap(..., Degree => ...) -- specify the degree of a map
• inducedMap(..., Verify => ...)
• inducedMap(Module,Module) -- compute the map induced by the identity
• inducedMap(Module,Module,Matrix) -- compute the induced map
• inducesWellDefinedMap -- whether a map is well defined
• InfiniteNumber -- the class of all infinite numbers
• infinity -- infinity
• info -- convert hypertext to info format
• infoHelp -- view online doc with info
• information about a map of modules
• Inhomogeneous
• initial help
• installAssignmentMethod -- install methods assignment to the value of an operator
• installMethod -- install methods
• InstallPrefix
• integralClosure(..., Variable => ...) -- Sets the name of the indexed variables introduced in computing the integral closure of a reduced ring.
• integralClosure(Ring) -- compute the integral closure of a ring
• integrate -- numerical integration
• IntermediateMarkUpType -- the class of intermediate mark-up types
• interpreterDepth -- nesting depth of the interpreter
• intersect -- compute an intersection
• inverse -- compute the inverse
• inverse systems
• inverse(Matrix) -- compute the inverse
• InverseMethod -- compute reciprocals
• Invoking the program
• irreducibleCharacteristicSeries -- irreducible characteristic series of an ideal
• irreducibleDecomposition(MonomialIdeal) -- express a monomial ideal as an intersection of irreducible monomial ideals
• isAffineRing -- whether something is an affine ring
• isBorel -- whether an ideal is fixed by upper triangular changes of coordinates
• isCommutative -- whether a ring is commutative
• isConstant -- whether a ring element is constant
• isDirectSum -- whether something is a direct sum
• isField -- whether something is a field
• isFreeModule -- whether something is a free module
• isGlobalSymbol -- whether a global symbol with a given name exists
• isHomogeneous -- whether something is homogeneous (graded)
• isIdeal -- whether something is an ideal
• isInjective -- whether a map is injective
• isInputFile -- whether a file is open for input
• isIsomorphism -- whether a map is an isomorphism
• isListener -- whether a file is open for listening
• isModule -- whether something is a module
• isMonomialIdeal -- whether something is a monomial ideal
• isNormal -- determine whether a reduced ring is normal
• isNormal(Ring) -- determine whether a reduced ring is normal
• isOpen -- whether a file or database is open
• isOutputFile -- whether a file is open for output
• isPolynomialRing -- whether someting is a polynomial ring
• isPrime -- whether a integer, polynomial, or ideal is prime
• isPrimitive -- whether an element is a primitive element of a finite field
• isQuotientModule -- whether something is evidently a quotient of a free module
• isQuotientOf -- whether one thing is a quotient of another
• isQuotientOf(Ring,Ring) -- whether one ring is a quotient of another
• isQuotientOf(Type,Ring) -- whether one ring is a quotient of a ring of a given type
• isQuotientRing -- whether something is a quotient ring
• isReady(File) -- whether a file has data available for reading
• isRing -- whether something is a ring
• isSkewCommutative -- whether a ring has skew commuting variables
• isSquareFree -- whether something is square free monomial ideal
• isSubmodule -- whether a module is evidently a submodule of a free module
• isSubset -- whether one object is a subset of another
• isSubset(Ideal,Ideal) -- whether one object is a subset of another
• isSubset(Module,Module) -- whether one object is a subset of another
• isSubset(Set,Set) -- whether one object is a subset of another
• isSurjective -- whether a map is surjective
• isTable -- whether something is a rectangular list of lists
• isUnit -- whether a ring element is a unit
• isWellDefined -- whether a map is well defined
• ITALIC -- hypertext italic font
• Iterate -- a Strategy option value for saturate
• jacobian -- the Jacobian matrix of partial derivatives
• jacobian(Ideal) -- the Jacobian matrix of the generators of an ideal
• jacobian(Matrix) -- the matrix of partial derivatives of polynomials in a matrix
• jacobian(Ring) -- the Jacobian matrix of the polynomials defining a quotient ring
• kernel -- kernel of a ringmap, matrix, or chain complex
• kernel(..., SubringLimit => ...)
• kernel(ChainComplexMap) -- kernel of a chain complex map
• kernel(Matrix) -- kernel of a matrix
• kernel(RingMap) -- kernel of a ringmap
• kernel, cokernel and image of a map of modules
• keys(HashTable) -- keys used in a hash table
• Keyword -- the class of all keywords
• kill -- kill a process
• koszul
• koszul(Matrix)
• koszul(ZZ,Matrix) -- a differential in a Koszul complex
• LABEL -- hypertext label item
• LATER -- a hypertext element for lazy evaluation
• leadCoefficient -- the leading coefficient
• leadComponent -- the leading component of a vector or matrix
• leadMonomial -- the leading monomial
• leadTerm -- get the greatest term
• leadTerm(Ideal) -- get the ideal of greatest terms
• leadTerm(Matrix) -- get the greatest term of each column
• leadTerm(RingElement) -- get the greatest term
• leadTerm(ZZ,Ideal) -- get the ideal of lead polynomials
• leadTerm(ZZ,Matrix) -- get the matrix of lead polynomials of each column
• leadTerm(ZZ,RingElement) -- get the lead polynomials using part of the monomial order
• Left
• length -- length
• length(ChainComplex) -- length of a chain complex or graded module
• length(Dictionary) -- length of a dictionary
• length(GradedModule) -- length of a graded module
• length(String) -- length of a string
• length(VisibleList) -- length of a visible list
• LengthLimit -- stop when the resolution reaches this length
• LI -- hypertext list item
• lift -- lift to another ring
• liftable -- whether a ring element can be lifted to another ring
• Limit -- specify how many to compute
• Linear -- a Strategy option value for saturate
• lineNumber -- current line number
• LINK -- a hypertext LINK element
• list -- loop control
• List + List -- sum of two vectors
• List - List -- difference of two vectors
• List / Thing -- vector division
• List >> Function -- attaching options to a function
• listForm -- convert to list form
• listLocalSymbols -- compact display of symbols and their values
• listSymbols -- compact display of symbols and their values
• listUserSymbols -- display the user's symbols
• LITERAL -- hypertext literal text
• loadDepth -- the load depth
• LoadDocumentation -- when loading a package, load the documentation, too
• loadedFiles
• loadPackage(..., LoadDocumentation => ...)
• local -- get a local symbol
• localDictionaries -- get local dictionaries
• LocalDictionary -- the class of all local dictionaries
• locate -- locate source code
• log -- logarithm function
• LongPolynomial
• lookup -- look up methods
• lookupCount -- reference count for a symbol
• LowerBound -- the class of lower bound objects
• LU -- LU decomposition
• MakeDocumentation
• makeDocumentTag -- convert a documentation key to a documentation tag
• MakeInfo
• makePackageIndex
• making modules from matrices
• manipulating modules
• Manipulator -- the class of all file manipulators
• map -- make a map
  • map(Module,Module,Function) -- create a matrix by specifying a function which gives each entry
  • map(Module,Module,List) -- create a matrix by giving a sparse or dense list of entries
  • map(Module,Module,RingElement) -- construct the map induced by multiplication by a ring element on the generators
  • map(Module,Module,Matrix) -- create the matrix induced on generators by a given matrix
  • map(Module,ZZ,Function) -- create a matrix from a free module by specifying a function which gives each entry
  • map(Module,Nothing,List) -- create a matrix by giving a doubly nested list of ring elements
  • map(Module,ZZ,List) -- create a matrix by giving a sparse or dense list of entries
  • map(Module,Nothing,Matrix) -- recast a matrix to have a new target, and a free module as source
  • map(Matrix) -- make a matrix with a different degree
  • map(Ring,Ring) -- map which associates variables, rest maps to zero
  • map(Ring,Ring,List) -- make a ring map
  • map(Ring,Ring,Matrix) -- make a ring map
  • map(ChainComplex,ChainComplex,ChainComplexMap)
  • map(ChainComplex,ChainComplex,Function) -- make a map of chain complexes
• map(..., Degree => ...) -- set the degree of a map
• map(..., DegreeMap => ...)
• map(Module) -- identity map
• map(Ring,Matrix) -- make a ring map
• maps between modules
• MarkUpType -- the class of mark-up types used with hypertext
• MarkUpTypeWithOptions -- the class of mark-up types used with hypertext, with option handling
• mathML -- convert to MathML format
• Matrix -- the class of all matrices
• matrix -- make a matrix
• Matrix % GroebnerBasis -- calculate the normal form of ring elements and matrices using a (partially computed) Groebner basis
• Matrix * Matrix -- matrix multiplication
• Matrix ** Matrix -- tensor product of matrices
• Matrix ** Module -- tensor product
• Matrix ** Ring -- tensor product
• Matrix ++ Matrix -- direct sum of maps
• Matrix // Matrix -- factor a map through another
• Matrix ^ Array -- select rows of blocks
• Matrix ^ List -- select rows
• Matrix ^ ZZ -- power
• Matrix _ Array -- select columns of blocks
• Matrix _ List -- select columns
• Matrix | Matrix -- join matrices horizontally
• Matrix || Matrix -- join matrices vertically
• matrix(..., Degree => ...) -- not really an option?
• matrix(..., DegreeMap => ...) -- not really an option
• matrix(List) -- create a matrix from a doubly-nested list of ring elements or matrices
• matrix(Matrix) -- the matrix between generators
• matrix(MutableMatrix) -- make a matrix from a mutable one
• matrix(Ring,List) -- create a matrix from a doubly nested list of ring elements or matrices
• matrix(RingMap) -- the matrix associated to a ring map
• MatrixExpression -- the class of all matrix expressions
• max -- maximum of elements of a list
• max(ChainComplex) -- maximum index in a chain complex
• maxPosition -- position of largest element
• member -- test membership in a list or set
• memoize -- record results of function evaluation for future use
• MENU -- hypertext menu item
• mergePairs -- merge sorted lists of pairs
• META -- a hypertext META element
• MethodFunction -- a type of method function
• MethodFunctionWithOptions -- a type of method function
• methodOptions(Function) -- recover the options used when a method function was created
• methods -- list methods
• methods for normal forms and remainder -- calculate the normal form of ring elements and matrices
• min -- minimum of elements of a list
• min(ChainComplex) -- minimum index in a chain complex
• mingens -- minimal generator matrix
• mingens(GroebnerBasis) -- (partially constructed) minimal generator matrix
• mingens(Module) -- minimal generator matrix
• minimal presentations and generators
• MinimalGenerators
• MinimalMatrix -- set the matrix of minimal generators
• minimalPresentation -- compute a minimal presentation
• minimalPresentation(..., Variable => ...) -- specify the variable for the new isomorphic ring
• minimalPresentation(Ideal) -- compute a minimal presentation of the quotient ring defined by an ideal
• minimalPresentation(Matrix) -- minimally present source and target of a matrix
• minimalPresentation(Module) -- minimal presentation of a module
• minimalPresentation(Ring) -- compute a minimal presentation of a quotient ring
• minimalPrimes -- minimal associated primes of an ideal
• Minimize
• minimizeFilename -- minimize a file name
• minors -- ideal generated by minors
• minors(..., Limit => ...) -- the maximum number of minors to compute
• minors(..., Strategy => ...) -- choose between Bareiss and Cofactor algorithms
• minors(ZZ,Matrix)
• MinorsComputation -- the class of all minors computations
• minPosition -- position of smallest element
• minprimes -- compute the minimal primes
• Minus -- the class of all minus expressions
• minus -- additive inverse
• mod -- reduce modulo an integer
• modifyRing -- make a copy of a ring, with some features changed
• Module -- the class of all modules
• module -- make or get a module
• Module ** Module -- tensor product of modules
• Module ** Ring -- tensor product
• Module + Module -- sum of submodules
• Module ++ Module -- direct sum of modules
• Module / Module -- quotient module
• Module ^ Array -- projection onto summand
• Module ^ List -- projection onto summand
• Module ^ ZZ -- direct sum
• Module ^** ZZ -- tensor power
• Module _ Array -- get inclusion map into direct sum
• Module ~ -- make a coherent sheaf
• Module Array -- make a chain complex from a module
• module(CoherentSheaf) -- get the module defining a coherent sheaf
• module(Ideal) -- turn an ideal into a module
• module(Ring)
• module(SheafOfRings) -- make or get a module
• module(Vector) -- the module of a vector
• ModuleMap -- the class of all maps between modules
• modulo -- find the pre-image of a map (low level version)
• Monoid -- the class of all monoids
• Monoid ** Monoid -- tensor product of monoids
• MonoidElement -- the class of all monoid elements
• monomialCurveIdeal -- make the ideal of a monomial curve
• MonomialIdeal -- the class of all monomial ideals handled by the engine
• monomialIdeal -- make a monomial ideal
• MonomialIdeal - MonomialIdeal -- monomial ideal difference
• monomialIdeal(Ideal) -- monomial ideal of lead terms of a Groebner basis
• monomialIdeal(Matrix) -- monomial ideal of lead terms
• Monomials -- whether to display the number of monomial
• monomials -- matrix of monomials in a ring element or matrix
• monomials(..., Variables => ...) -- specify variables
• monomialSubideal -- find the largest monomial ideal in an ideal
• mutable matrices
• mutableIdentity(Ring,ZZ) -- make a mutable identity matrix
• MutableList -- the class of all mutable lists
• MutableMatrix -- the class of all mutable matrices
• mutableMatrix -- make a mutable matrix
• MutableMatrix _ Sequence = Thing -- assignment to an element of a mutable matrix
• mutableZero(Ring,ZZ,ZZ) -- make a mutable matrix filled with zeroes
• needsPackage(..., LoadDocumentation => ...)
• net -- format for printing, as a net
• Net ^ ZZ -- raise a net or string
• Net | Net -- join strings or nets
• Net || Net -- join nets or strings vertically
• net(String) -- convert a string to a net
• NetFile -- the class of all net files
• netTable(List) -- a table of boxes
• new ChainComplex -- make a new chain complex from scratch
• new HashTable from List -- make a hash table from a list
• newCoordinateSystem -- change variables
• NewFromMethod
• newline -- the new line character sequence
• NewMethod
• newNetFile -- create a new net file
• NewOfFromMethod
• NewOfMethod
• nextkey -- the next key in a database
• NonAssociativeProduct -- the class of all nonassociative product expressions
• NonLinear -- use the algorithm which doesn't assume that the ring map is linear
• NoPrint -- top level method for non-printing results
• not documented yet
• Nothing -- the empty class
• notify -- whether to notify the user when a file is loaded
• notImplemented -- print an 'not implemented' error message
• null -- the unique member of the empty class
• nullaryMethods
• nullhomotopy -- make a null homotopy
• Number -- the class of all numbers
• number -- count how many elements of a list satisfy a condition
• numColumns(MutableMatrix) -- number of columns in a mutable matrix
• numerator -- numerator of a fraction
• numeric -- convert to floating point
• numgens -- the number of generators
• numgens(CoherentSheaf) -- the number of generators of the underlying module
• numgens(GeneralOrderedMonoid) -- number of generators of a monoid
• numgens(Ideal) -- number of generators of an ideal
• numgens(Module) -- number of generators of a module
• numgens(Ring) -- number of generators of a polynomial ring
• numRows(MutableMatrix) -- number of rows in a mutable matrix
• odd -- tell whether an integer is odd
• of -- a keyword
• ofClass -- English phrases for types
• on -- trace a function each time it's run
• OneExpression -- the class all one expressions
• OO -- the structure sheaf
• oo -- the last output value
• ooo -- the next to the last output value
• oooo -- the third to the last output value
• openDatabase -- open a database file
• openDatabaseOut -- open a database file for writing
• openFiles -- list the open files
• openIn -- open an input file
• openInOut -- open an input output file
• openListener -- open a port for listening
• openOut -- open an output file
• Option -- the class of all pairs x => y
• optional argument documentation template
• optional argument name documentation template
• Options
• options -- get options
• options(Function) -- get optional arguments and default values for a function which accepts them
• options(MarkUpType)
• options(Monoid) -- get values used for optional arguments
• options(Package)
• options(Ring) -- get values used for optional arguments
• OptionTable -- the class of hash tables for optional arguments
• OptionTable >> Function -- attaching options to a function
• Order -- specify the order of a Hilbert series required
• order -- a key used internally
• OrderedMonoid -- the class of all ordered monoids
• OutputDictionary -- the dictionary for output values
• override -- override default values for optional arguments
• overview documentation template
• Package -- the class of all packages
• package -- get containing package
• package documentation template
• PackageDictionary -- the dictionary for names of packages
• PackagePrefix
• pad -- pad a string with spaces
• pager -- display with paging
• PairLimit -- stop when this number of pairs is handled
• PairsRemaining -- whether to display the number of S-pairs remaining
• PARA -- hypertext paragraph container
• parsing precedence, in detail
• part -- sum of monomials of a polynomial of a given degree
• Partition -- a type of list representing a partition of a natural number
• Partition _ ZZ -- get element
• partitions -- list the partitions of an integer
• partitions(ZZ) -- list the partitions of an integer
• partitions(ZZ,ZZ) -- list the partitions of an integer
• pdim -- calculate the projective dimension
• pdim(CoherentSheaf) -- calculate the projective dimension
• pdim(Module) -- calculate the projective dimension of a module
• peek -- examine contents of an object
• peek'(ZZ,Thing) -- examine contents of an object
• permanents -- ideal generated by square permanents of a matrix
• permutations -- produce all permutations of a list
• pfaffians -- ideal generated by Pfaffians
• pi -- the number 'pi'
• plus -- addition
• poincare -- assemble degrees into polynomial
• poincare(ChainComplex) -- assemble degrees of a chain complex into a polynomial
• poincare(Ideal) -- assemble degrees of the quotient of the ambient ring by an ideal into a polynomial
• poincare(Module) -- assemble degrees of an module into a polynomial
• poincare(Ring) -- assemble degrees of an ring into a polynomial
• poincareN -- assemble degrees into polynomial
• PolynomialRing -- the class of all ordered monoid rings
• position(VisibleList,VisibleList,Function) -- find first element of a list satisfying a condition
• Power -- the class of all power expressions
• power -- power
• PRE -- preformatted text
• precision
• preface
• preimage -- preimage of an ideal under a ring map
• prepend(Thing,BasicList) -- add an element to the beginning of a list
• presentation -- presentation of a module or ring
• presentation(Module) -- presentation of a module
• presentation(PolynomialRing,QuotientRing) -- presentation of a quotient ring
• pretty -- a pretty printer
• Primary
• PrimaryTag -- for internal use only: a symbol used in storing documentation
• PrimitiveElement -- specify a primitive element
• Print -- top level method for printing results
• print -- print something
• printingPrecision -- current precision for printing real numbers
• printingTimeLimit
• PrintNames -- table of printed forms of objects
• printString -- lowlevel function to print a string, net, or symbol
• printWidth
• Product -- the class of all product expressions
• product
• product(List) -- product of elements
• product(Set) -- product of elements
• product(Tally) -- product of elements
• product(VisibleList,Function) -- product of values of a function
• product(VisibleList,VisibleList,Function) -- product of results of applying a function pairwise
• product(ZZ,Function) -- product of consecutive values of a function
• ProductOrder -- product ordering
• profile -- profile a function
• profileSummary -- display profiling data
• Proj(Ring) -- make a projective variety
• Projective -- whether to produce a projective Hilbert polynomial
• ProjectiveHilbertPolynomial -- the class of all Hilbert polynomials
• projectiveHilbertPolynomial -- Hilbert polynomial of projective space
• ProjectiveHilbertPolynomial ZZ -- value of polynomial
• ProjectiveVariety -- the class of all projective varieties
• promote -- promote to another ring
• promptWidth
• protect -- protect a symbol
• pruningMap
• Pseudocode -- the class of pseudocodes
• pseudocode -- produce the pseudocode for a function
• pseudoRemainder -- compute the pseudo-remainder
• pushForward(..., StopBeforeComputation => ...)
• pushForward(..., StopWithMinimalGenerators => ...)
• pushForward(..., Strategy => ...)
• pushForward(RingMap,Module)
• pushForward1(..., DegreeLimit => ...) -- compute only up to this degree
• pushForward1(..., MonomialOrder => ...) -- specify the elimination order to use in pushForward1
• pushForward1(..., PairLimit => ...) -- stop when this number of pairs is handled
• pushForward1(..., StopBeforeComputation => ...) -- initialize but do not begin the computation
• pushForward1(..., StopWithMinimalGenerators => ...) -- stop when minimal generators have been determined
• pushForward1(..., Strategy => ...) -- specify which algorithm to use in the computation
• pushForward1(..., UseHilbertFunction => ...) -- whether to use knowledge of the Hilbert function
• pushForward1(RingMap,Module) -- the main computational component of pushForward
• PushforwardComputation -- a type of list used internally by pushForward1
• QQ -- the class of all rational numbers
• Quotient
• quotient -- quotient or division
• quotient' -- matrix quotient (opposite)
• quotient(..., MinimalGenerators => ...) -- Decides whether quotient computes and outputs a trimmed set of generators; default is true
• quotient(..., Strategy => ...) -- Possible strategies are: Iterate, Linear, and Quotient
• quotient(Ideal,Ideal) -- ideal or submodule quotient
• quotient(Matrix,GroebnerBasis) -- matrix quotient
• quotientRemainder -- matrix quotient and remainder
• quotientRemainder' -- matrix quotient and remainder (opposite)
• QuotientRing -- the class of all quotient rings
• quotients of modules
• radical -- the radical of an ideal
• random -- get a random element
• random(GaloisField) -- random element of a Galois field
• random(List,Ring) -- a random ring element of a given degree
• random(Module,Module) -- make a random module map
• random(QuotientRing) -- random element of a quotient ring
• random(Ring) -- random element of a ring
• random(RR) -- random real number
• random(ZZ) -- random integer
• random(ZZ,Ring) -- a random ring element of a given degree
• random(ZZ,ZZ) -- random integer in a range
• randomMutableMatrix(ZZ,ZZ,RR,ZZ) -- a random mutable matrix of integers
• rank -- compute the rank
• read -- read from a file
• read(File) -- read from a file
• read(File,ZZ) -- read from a file
• read(Sequence) -- read from a file
• read(String) -- read from a file
• realPart -- real part
• recursionDepth -- the current recursion depth
• recursionLimit -- set the limit on recursion
• reduceHilbert -- reduce a Hilbert series expression
• regularity -- compute the Castelnuovo-Mumford regularity
• relations -- the defining relations
• relativizeFilename -- relativize a file name
• remainder -- matrix remainder
• remainder' -- matrix quotient and remainder (opposite)
• removeHook(HashTable,Thing,Function) -- remove a hook function from an object
• removeLowestDimension -- remove components of lowest dimension
• reorganize -- reorganize a database file
• RerunExamples
• reshape(Module,Module,Matrix) -- reshape a matrix
• Resolution -- the class of all resolution computations
• resolution -- projective resolution
• resolution(..., DegreeLimit => ...) -- compute only up to this degree
• resolution(..., HardDegreeLimit => ...)
• resolution(..., LengthLimit => ...) -- stop when the resolution reaches this length
• resolution(..., PairLimit => ...) -- stop when this number of pairs has been handled
• resolution(..., SortStrategy => ...)
• resolution(..., StopBeforeComputation => ...) -- whether to stop the computation immediately
• resolution(..., Strategy => ...)
• resolution(..., SyzygyLimit => ...) -- stop when this number of syzygies are obtained
• resolution(Ideal) -- compute a projective resolution of (the quotient ring corresponding to) an ideal
• resolution(Matrix) -- given a module map represented by a matrix, produce a comparison map between resolutions of its source and target
• resolution(Module) -- compute a projective resolution of a module
• Resources required
• return -- return from a function
• returnCode
• ReverseDictionary -- table of symbols where various types of objects are stored
• Right
• Ring -- the class of all rings
• ring -- Get the associated ring of an object
• Ring ** Ring -- tensor product
• Ring / Ideal -- make a quotient ring
• Ring ^ List -- make a free module
• Ring ^ ZZ -- make a free module
• Ring _ List -- make a monomial from a list of exponents
• Ring _ String -- get a ring variable by name
• Ring _ ZZ -- get a ring variable by index
• Ring ~ -- make the structure sheaf
• Ring Array -- the standard way to make a polynomial ring
• Ring OrderedMonoid -- make a polynomial ring
• RingElement -- the class of all ring elements handled by the engine
• RingElement / RingElement -- fraction
• RingElement ^ ZZ -- power
• RingElement Array -- substitution of variables
• RingMap -- the class of all ring maps
• RingMap ** Module -- tensor product of a module via a ring map
• RingMap RingElement -- apply a ring map
• rotate(ZZ,VisibleList) -- rotate a list
• round -- round a number to the nearest integer
• row and column operations
• rowAdd -- add a multiple of one row to another
• RowExpression -- the class of all matrix expressions
• rowMult -- multiply a row by a ring element
• rowPermute -- permute some rows
• rowSwap -- interchange rows
• RR -- the class of all real numbers
• RRR -- high-precision real numbers
• rsort(..., DegreeOrder => ...) -- specify Ascending, Descending, or null
• rsort(..., MonomialOrder => ...) -- specify Ascending or Descending monomial order
• runHooks(HashTable,Thing,Thing) -- run the hook functions stored in an object
• same -- whether everything in a list is the same
• saturate -- saturation of ideal or submodule
• saturate(..., DegreeLimit => ...)
• saturate(..., MinimalGenerators => ...) -- whether to compute minimal generators
• saturate(..., Strategy => ...)
• scan -- apply a function to each element
• scan(ZZ,Function) -- apply a function to 0 .. n-1
• scanKeys -- apply a function to each key in a hash table or database
• scanPairs -- apply a function to pairs in a hash table
• scanPairs(HashTable,Function) -- apply a function to pairs in a hash table
• scanValues -- apply a function to each value in a hash table
• schreyerOrder -- create or obtain free modules with Schryer monomial orders
• schreyerOrder(Matrix) -- create a matrix with the same entries whose source free module has a Schreyer monomial order
• schreyerOrder(Module) -- obtain Schreyer order information
• Schubert(ZZ,ZZ,VisibleList) -- find the Pluecker ideal of a Schubert variety
• ScriptedFunctor -- the class of all scripted functors
• searchPath(List,String) -- search a path for a file
• select -- select from a list, hash table, or string
• select(HashTable,Function) -- select pairs from a hash table
• select(ZZ,HashTable,Function) -- select a limited number of pairs from a hash table
• selectInSubring -- select columns in a subring
• SelfInitializingType -- the class of all self initializing types
• separateRegexp -- separate a string into pieces, with separators determined by a regular expression
• separateRegexp(String,String) -- separate a string into pieces, with separators determined by a regular expression
• separateRegexp(String,ZZ,String) -- separate a string into pieces, with separators determined by a regular expression
• Set -- the class of all sets
• set -- make a set
• Set #? Thing -- test set membership
• Set * Set -- intersection of sets
• Set ** Set -- Cartesian product
• Set + Set -- set union
• Set - Set -- set difference
• setPrecision
• setRandomSeed -- set starting point for random number generator
• setRandomSeed(String) -- set starting point for random number generator
• setRandomSeed(ZZ) -- set starting point for random number generator
• setup
• sheaf -- make a coherent sheaf
• sheaf(Module) -- make a coherent sheaf
• sheaf(Ring) -- make the structure sheaf
• sheaf(Variety) -- make a coherent sheaf
• sheaf(Variety,Module) -- make a coherent sheaf
• sheaf(Variety,Ring) -- make a coherent sheaf of rings
• sheafExt^ZZ(CoherentSheaf,CoherentSheaf) -- sheaf Ext of coherent sheaves
• sheafHom(CoherentSheaf,CoherentSheaf) -- sheaf Hom
• SheafOfRings -- the class of sheaves of rings
• SheafOfRings ^ List -- make a graded free coherent sheaf
• shield -- shield evaluation from interrupts
• show -- display various TeX, hypertext, or a URL, in an external application
• showClassStructure -- show relationship between things
• showHtml -- convert hypertext to html and display with a browser
• showStructure -- show relationship between types
• showTex -- convert to TeX and display on screen
• showUserStructure -- show relationship between types defined by user
• sin -- compute the sine
• singularLocus -- singular locus
• sinh -- compute the hyperbolic sine
• size -- the size of an object
• SMALL -- hypertext SMALL item
• smithNormalForm
• solve -- solve a linear equation
• someTerms -- select some terms of a polynomial
• Sort
• sort(..., DegreeOrder => ...) -- specify Ascending, Descending, or null
• sort(..., MonomialOrder => ...) -- specify Ascending or Descending monomial order
• sort(List) -- sort a list
• sort(Matrix) -- sort the columns of a matrix
• sortColumns -- permutation giving sort order
• sortColumns(..., DegreeOrder => ...) -- specify Ascending, Descending, or null
• sortColumns(..., MonomialOrder => ...) -- specify Ascending or Descending monomial order
• SortStrategy -- specify a strategy for sorting S-pairs
• source -- source of a map
• source(ChainComplexMap) -- find the source of a map of chain complexes
• source(GradedModuleMap) -- find the source of a map of graded modules
• source(Matrix) -- find the source module of matrix
• source(RingMap) -- find the source ring for a map of rings
• SourceCode
• SPAN -- hypertext span
• SparseMonomialVectorExpression -- the class of all sparse monomial vector expressions
• SparseVectorExpression -- the class of all sparse vector expressions
• Spec(Ring) -- make an affine variety
• specifying typical values
• splice -- remove subsequences
• sqrt -- square root function
• standardForm -- convert to standard form
• standardPairs -- find the standard pairs of a monomial ideal
• stashValue -- stash values of functions in their arguments
• status -- status of a resolution computation
• stderr -- the standard error output file
• stdio -- the standard input output file
• StopBeforeComputation -- initialize but do not begin the computation
• stopIfError -- whether to stop the program when an error occurs
• StopWithMinimalGenerators -- stop when minimal generators have been determined
• Strategy -- specify a computational strategy
• String # ZZ -- get character from string
• String #? ZZ -- check for character in string
• String ^ Sequence -- vertically stacked copies of a string
• String _ Sequence -- substring
• String _ ZZ -- get element from string
• STRONG -- hypertext STRONG item
• STYLE -- hypertext STYLE element
• SUB -- hypertext subscript
• sublists -- process interspersed sublists of a list
• submatrix
• submatrix(Matrix,VisibleList) -- select columns
• submatrix(Matrix,VisibleList,VisibleList) -- select part of a matrix
• subquotient -- make a subquotient module
• SubringLimit -- stop after finding enough elements of a subring
• Subscript -- the class of all subscript expressions
• subscript -- specify the function in a scripted functor for a subscript
• SUBSECTION -- hypertext SUBSECTION item
• subsets -- produce all the subsets
• subsets(List) -- produce all the subsets
• subsets(List,ZZ) -- produce all the subsets
• subsets(Set) -- produce all the subsets
• subsets(Set,ZZ) -- produce all the subsets
• subsets(ZZ) -- produce all the subsets
• subsets(ZZ,ZZ) -- produce all the subsets
• substituting values for variables
• substring -- extract part of a string
• Sum -- the class of all sum expressions
• sum -- compute the sum
• sum(ChainComplex) -- direct sum of the components of a chain complex
• sum(ChainComplexMap) -- direct sum of the components of a chain map
• sum(List) -- sum the elements of a list
• sum(Set) -- sum of elements
• sum(Tally) -- sum of elements
• sum(VisibleList,Function) -- sum results of applying a function
• sum(VisibleList,VisibleList,Function) -- sum results of applying a function pairwise
• sum(ZZ,Function) -- sum consecutive values of a function
• SumOfTwists -- the class of all sums of twists
• SUP -- hypertext superscript
• super -- get the ambient module
• Superscript -- the class of all superscript expressions
• superscript -- specify the function in a scripted functor for a superscript
• support -- list of variables occuring in a polynomial
• SVD -- singular value decomposition of a rectangular matrix over RR or CC
• SVD(..., DivideConquer => ...) -- Use the lapack divide and conquer SVD algorithm
• Symbol -- the class of all symbols
• symbol -- get a symbol
• Symbol _ Ring -- get a ring variable by name
• Symbol _ Thing = Thing -- assignment to an indexed variable
• symmetricAlgebra(Module) -- the symmetric algebra of a module
• symmetricPower -- symmetric power
• symmetricPower(ZZ,Matrix) -- symmetric power
• synonym -- synonym for members of a class
• SYNOPSIS
• syz -- the syzygy matrix
• syz(..., ChangeMatrix => ...) -- whether to produce the change of basis matrix
• syz(..., CodimensionLimit => ...) -- stop when this codimension is reached
• syz(..., StopBeforeComputation => ...) -- whether to stop the computation immediately
• syz(..., StopWithMinimalGenerators => ...) -- stop when minimal generators have been determined
• syz(..., Strategy => ...) -- specify the strategy used to compute the Groebner basis
• syz(GroebnerBasis) -- retrieve the syzygy matrix
• syz(Matrix) -- compute the syzygy matrix
• Syzygies -- whether to collect syzygies
• SyzygyLimit -- stop when this number of syzygies is obtained
• SyzygyMatrix -- set the syzygy matrix
• SyzygyRows -- the number rows of the syzygy matrix to collect
• syzygyScheme -- construct a syzygy scheme
• TABLE -- hypertext table
• Table -- the class of all table expressions
• take(BasicList,List)
• take(BasicList,ZZ)
• Tally -- the class of all tally results
• tally -- tally the elements of a list or sequence
• Tally ** Tally -- Cartesian product of tallies
• Tally + Tally -- union of tallies
• Tally - Tally -- difference of tallies
• Tally ^** ZZ -- Cartesian power of sets and tallies
• Tally _ Thing -- get a count from a tally
• tally(VisibleList) -- tally the elements of a list, sequence, or array
• tan -- compute the tangent
• tangentSheaf -- tangent sheaf of a projective variety
• tangentSheaf(ProjectiveVariety) -- tangent sheaf of a projective variety
• tanh -- compute the hyperbolic tangent
• target -- target of a map
• target(ChainComplexMap) -- find the target of a map of chain complexes
• target(GradedModuleMap) -- find the target of a map of graded modules
• target(GroebnerBasis) -- find target of a Groebner basis
• target(Matrix) -- find the target module of matrix
• target(RingMap) -- find the target ring for a map of rings
• TD -- hypertext TD element
• tensor -- tensor product
• tensorAssociativity -- associativity isomorphisms for tensor products
• terms -- provide a list of terms of a polynomial
• TEX -- hypertext TEX item
• tex -- convert to TeX format
• texMath -- convert to TeX math format
• the debugger
• then -- condition testing
• Thing -- the class of all things
• Thing // Function -- apply a function
• throw -- throw an exception
• Time -- the class of all timing results
• times -- multiplication
• TITLE -- hypertext title
• TO -- hypertext documentation link
• to -- loop control
• TO2 -- labeled hypertext documentation link
• toDual -- inverse system
• toExternalString -- convert to a readable string
• toField -- declare that a ring is a field
• TOH -- hypertext documentation link followed by a headline
• toList(BasicList) -- list of elements
• toList(Set) -- list of elements
• toLower -- convert to lower case
• topCoefficients -- first variable and its coefficient of a polynomial or matrix
• topComponents -- compute top dimensional component
• topComponents(Ideal) -- compute top dimensional component
• topComponents(Module) -- compute top dimensional component
• Tor -- Tor module
• Tor_ZZ(Module,Module) -- compute a Tor module
• toRRR -- convert to high-precision real
• toString -- convert to a string
• TotalPairs -- whether to display the total number of S-pairs
• toUpper -- convert to upper case
• TR -- hypertext TR element
• trace(Matrix) -- trace of a matrix
• transpose -- transpose a table or a matrix
• transpose(ChainComplexMap) -- transpose a map of chain complexes
• transpose(List) -- transposes a table
• transpose(Matrix) -- transpose a matrix
• TreeNode -- a type of basic list used to represent a rooted tree
• trim -- minimize generators and relations
• trim(Ideal)
• trim(Module)
• trim(QuotientRing)
• trim(Ring)
• true
• truncate -- truncate the module at a specified degree
• truncateOutput
• tryHooks(HashTable,Thing,Thing) -- try the hook functions stored in an object
• TT -- hypertext TT item
• tutorial -- convert documentation from tutorial format
• typicalValues -- types of values returned by functions
• UL -- hypertext UL item
• ultimate -- ultimate value for an iteration
• unbag(Bag)
• uncurry -- uncurry a function
• Undo
• undocumented
• uniform -- test whether elements of a list are of the same class
• uninstallPackage -- uninstall a package
• Unmixed -- provide a hint when computing a radical
• UpdateOnly -- only copies of newer files should replace files
• URL -- a type representing a URL
• Usage -- shows the usage of a function
• use -- install or activate object
• use(Package) -- activate a previously dismissed package
• use(Ring) -- install ring variables and ring operations
• UseHilbertFunction
• UserMode
• userSymbols -- a list of the user's symbols
• using packages
• validate(Hypertext)
• value -- evaluate
• value(IndexedVariable) -- retrieve the value of an indexed variable
• value(Pseudocode) -- execute pseudocode
• value(String) -- evaluate a string
• value(Symbol) -- retrieve the value of a symbol
• values(HashTable) -- values in a hash table
• Variable -- specify a name for a variable
• Variables
• variety -- get the variety
• variety(CoherentSheaf)
• variety(Ideal) -- the closed projective subvariety defined by an ideal
• variety(SheafOfRings) -- get the variety
• vars -- variables
• vars(GeneralOrderedMonoid) -- row matrix of the variables
• vars(List) -- a sequence of variables
• vars(Ring) -- row matrix of the variables
• Vector -- the class of all elements of free modules which are handled by the engine
• vector -- make a vector
• Verbose -- request verbose feedback
• Verify -- verify that a map is well-defined
• VerticalList -- a type of visible self-initializing list that prints vertically
• VerticalSpace
• viewHelp -- view online doc with a web browser
• VisibleList / Function -- apply a function to elements of a list
• w3
• wedgeProduct(ZZ,ZZ,Module) -- the exterior multiplication map
• weightRange -- the pair of lowest and highest weights of the monomials
• what is a subquotient module?
• when -- a keyword
• width -- width of a file or net
• width(File) -- get window width
• width(Net) -- width of a net
• Wrap -- a key for methods for wrapping printed output
• wrap
• WrapperType -- a class of lists with abbreviated constructors
• xdegree (old) -- the degree
• xor -- logical exclusive-or
• youngest -- the youngest member of a sequence
• zero -- whether something is zero
• ZeroExpression -- the class of all zero expressions
• ZZ -- the class of all integers
• ZZ & ZZ -- logical and
• ZZ : Thing -- repeat an item
• ZZ << ZZ -- shift bits leftward
• ZZ >> ZZ -- shift bits rightward
• ZZ | ZZ -- logical or