Macaulay2 » Documentation
Packages » Macaulay2Doc :: Table of Contents
next | previous | forward | backward | up | index | toc

# Macaulay2Doc : Table of Contents

- Macaulay2Doc -- Macaulay2 documentation
  - setting up Macaulay2
    - finding the Macaulay2 files
    - teaching your shell how to find M2
      - setup
    - teaching M2 how to find its shared libraries
    - invoking the Macaulay2 program
    - using Macaulay2 with Emacs
      - setting up the Macaulay2 Emacs interface
        - teaching Emacs how to find M2-init.el
        - teaching Emacs how to find M2
        - setupEmacs
      - running Macaulay2 in Emacs
      - using Macaulay2 with Emacs after it has been set up
      - editing Macaulay2 code with Emacs
    - using Macaulay2 with TeXmacs
    - using Macaulay2 in a terminal
  - a first Macaulay2 session
  - reading the documentation
    - about -- search the documentation
    - apropos -- symbols matching a pattern
    - headlines -- display a table of documentation headlines
    - help -- view documentation nodes
    - viewHelp -- view online documentation in a web browser
    - infoHelp -- view documentation in Info format
    - ? Symbol -- view brief documentation of a symbol
    - examples -- list the examples in documentation
    - initial help -- Welcome to Macaulay2
  - getting help or reporting bugs
  - The Macaulay2 language
    - variables
      - valid names
      - assigning values
      - local variables in a file
      - viewing the symbols defined so far
      - subscripted variables
      - numbered variables
      - augmented assignment
    - comments -- comment
    - numeric types
    - strings and nets -- an overview of strings and nets in Macaulay2
      - regular expressions -- syntax for regular expressions
        - match -- regular expression matching
        - regex -- evaluate a regular expression search
        - separate -- split a string into substrings using a regular expression
        - select(String,String,String) -- select and reformat substrings matching a regular expression
        - replace(String,String,String) -- replace substrings matching a regular expression
        - regexQuote -- escape special characters in regular expressions
      - concatenate -- join strings
      - format -- format a string or real number
      - lines -- split a string into lines
      - characters -- get characters from a string
      - demark -- insert a string between elements of a list of strings
      - ascii -- ASCII character conversion
      - utf8 -- encode and decode unicode utf-8-encoded strings
      - utf8substring -- extract part of a utf8 string
      - toLower -- convert to lower case
      - toUpper -- convert to upper case
      - urlEncode -- URL encoding
      - substring -- extract part of a string
      - value(String) -- evaluate a string
      - String _ ZZ -- get element from string
      - String _ Sequence -- substring
      - String .. String -- a sequence of consecutive strings
      - String ..< String -- a sequence of consecutive strings, not including the endpoint
      - String ^ Sequence -- vertically stacked copies of a string
      - horizontalJoin -- join nets or strings horizontally
      - pad -- pad a string or net with spaces
      - wrap
      - centerString -- center a string or net
      - columnate -- arrange strings in columns
      - stack -- join nets or string vertically
      - unstack -- list the rows of a net
      - String -- the class of all strings
        - net(String) -- convert a string to a net
        - toString -- convert to a string
        - toExternalString -- convert to a readable string
        - /// -- delineate a string with slashes
        - " -- delineate a string with quotation marks
      - Net -- the class of all nets and strings
        - width -- width of an object
        - width(Net) -- width of a net
        - height(Net) -- height of a net
        - depth(Net) -- depth of a net
        - length(String) -- length of a string
        - Net ^ ZZ -- raise a net or string
        - Net || Net -- join nets or strings vertically
        - Net | Net -- join strings or nets
      - newline -- the new line character sequence
    - lists and sequences -- a detailed overview of lists and sequences in Macaulay2
      - BasicList -- the class of all basic lists
        - FilePosition -- the class of all file positions
        - Command -- the class of all commands
        - URL -- a type representing a URL
        - RingElement -- the class of all ring elements handled by the engine
          - isUnit -- whether a ring element is a unit
          - leadTerm(RingElement) -- get the greatest term
          - leadTerm(ZZ,RingElement) -- get the lead polynomials using part of the monomial order
          - quotientRemainder(RingElement,RingElement) -- quotient and remainder
          - degree(RingElement)
          - degree(RingElement,RingElement) -- degree with respect to a variable
          - factor(RingElement) -- factor a ring element
          - indices(RingElement) -- indices of variables occurring in a polynomial
          - RingElement ^ ZZ -- power
          - RingElement / RingElement -- fraction
          - RingElement .. RingElement -- a sequence of consecutive generators of a polynomial ring
          - RingElement ..< RingElement -- a sequence of consecutive generators of a polynomial ring
        - Option -- the class of all key-value pairs K => V
          - options -- get options
        - Vector -- the class of all elements of modules that are handled by the engine
          - vector -- make a vector
          - entries(Vector) -- get the entries of a vector
          - Vector ** Vector -- tensor product
          - Vector || Vector -- join vectors
        - Expression -- the class of all expressions
          - value(Expression) -- evaluate
          - hold -- hold something in a holder expression
          - Table -- the class of all table expressions
          - Holder -- the class of all holder expressions
            - Describe -- the class of the output of describe
            - OneExpression -- the class all one expressions
            - Parenthesize
            - ZeroExpression -- the class of all zero expressions
          - Adjacent -- the class of all adjacent expression pairs
          - MapExpression -- the class of map expressions
          - FunctionApplication -- the class of all function application expressions
          - AssociativeExpression -- the class of associative expressions
            - Sum -- the class of all sum expressions
            - DirectSum -- the class of all direct sum expressions
            - Product -- the class of all product expressions
            - TensorProduct -- the class of all tensor product expressions
            - Equation -- the class of all equation expressions
          - MatrixExpression -- the class of all matrix expressions
          - VectorExpression -- the class of all vector expressions
          - RowExpression -- the class of all matrix expressions
          - SparseVectorExpression -- the class of all sparse vector expressions
          - SparseMonomialVectorExpression -- the class of all sparse monomial vector expressions
          - BinaryOperation -- the class of all binary operation expressions
          - Divide -- the class of all divide expressions
          - Minus -- the class of all minus expressions
          - Power -- the class of all power expressions
          - Subscript -- the class of all subscript expressions
          - Superscript -- the class of all superscript expressions
        - Manipulator -- the class of all file manipulators
        - IndexedVariable -- the class of all indexed variables
          - value(IndexedVariable) -- retrieve the value of an indexed variable
          - IndexedVariable .. IndexedVariable -- sequences of consecutive indexed variables
          - IndexedVariable ..< IndexedVariable -- sequences of consecutive indexed variables
          - baseName -- the base name of a generator
      - VisibleList -- the class of all visible lists
        - List -- the class of all lists -- {...}
          - VerticalList -- a type of visible self-initializing list that prints vertically
            - NumberedVerticalList -- a type of visible self-initializing list that prints vertically
        - Sequence -- the class of all sequences -- (...)
        - Array -- the class of all arrays -- [...]
        - AngleBarList -- the class of lists delimited by <| ... |>
      - MutableList -- the class of all mutable lists
        - Bag -- the class of all bags
          - unbag
      - length(VisibleList) -- length of a visible list
      - # List -- length or cardinality of a list, hash table, dictionary, set, or string
      - isEmpty -- whether an object is empty
      - List # ZZ -- get value from list, hash table, database, dictionary, or string
      - VisibleList _ ZZ -- get element from list
      - VisibleList _ List -- get some entries of a list
      - drop -- drop some elements from a list or sequence
      - take -- take some elements from a list or sequence
      - first -- first element of a list
      - last -- last element of a list
      - ZZ .. ZZ -- sequences of consecutive integers
      - ZZ ..< ZZ -- sequences of consecutive integers
      - ZZ : Thing -- repeat an item
      - VisibleList / Function -- apply a function to elements of a list
      - VisibleList // Function -- apply a function
      - scan -- apply a function to each element in a list or sequence
      - apply -- apply a function to each element
        - apply(ZZ,Function) -- apply a function to {0,..., n-1}
        - apply(BasicList,Function) -- apply a function to each element of a list
        - apply(BasicList,BasicList,Function) -- apply a function to pairs of elements, one from each list
        - apply(Thing,Function) -- apply a function to an object with an iterator
      - fold -- apply a binary operator repeatedly
      - accumulate -- apply a binary operator repeatedly
      - ultimate -- ultimate value for an iteration
      - Iterator -- class for iterators
        - iterator -- get an iterator
        - next -- get the next object from an iterator
        - StopIteration -- stop iteration
      - all -- whether all elements satisfy a specified condition
        - all(BasicList,Function) -- whether all elements of a list satisfy a specified condition
        - all(BasicList,BasicList,Function) -- whether all corresponding elements of a pair of lists satisfy a condition
      - any -- whether any elements satisfy a specified condition
        - any(BasicList,Function) -- whether any elements of a list satisfy a specified condition
        - any(BasicList,BasicList,Function) -- whether any corresponding elements of a pair of lists satisfy a condition
      - same -- whether everything in a list is the same
      - uniform -- whether all elements of a list are the same class
      - select -- select from a list, hash table, or string
        - select(BasicList,Type) -- select elements of a given type in a list
        - select(BasicList,Function) -- select elements from a list
        - select(Thing,Function) -- select elements from an object with an iterator
        - select(ZZ,BasicList,Function) -- select a limited number of elements from a list
        - select(ZZ,Function) -- select integers
      - isMember -- test membership in a list or set
      - isSubset -- whether one object is a subset of another
      - position -- the first element of a list satisfying a condition
      - positions -- which elements of a list satisfy a condition
      - min -- get the minimum element in a list or sequence
      - minPosition -- position of the smallest element
      - max -- get the maximum element in a list or sequence
      - maxPosition -- position of the largest element
      - number -- count how many elements of a list satisfy a condition
      - partition -- partition a set or list by values of a function
      - sublists -- process interspersed subsequences of a visible list
      - table -- make a table from a binary function
      - isTable -- whether something is a list of lists of equal length
      - subtable -- extract a subtable from a table
      - applyTable -- apply a function to each element of a table
      - List ** List -- Cartesian product of two lists
      - List .. List -- rectangular sequences of consecutive lists and sequences
      - List ..< List -- rectangular sequences of consecutive lists and sequences
      - pack -- pack elements of a list or string into several shorter lists or strings
      - netList -- a table of boxes
      - sort -- sort a list or columns of a matrix
        - sort(List) -- sort a list
        - sort(Matrix) -- sort the columns of a matrix
          - sort(...,MonomialOrder=>...) -- specify Ascending or Descending monomial order
          - sort(...,DegreeOrder=>...) -- specify Ascending, Descending, or null
          - Ascending -- specify ascending order
          - Descending -- specify descending order
        - sortColumns -- permutation giving sort order
          - sortColumns(...,MonomialOrder=>...) -- specify Ascending or Descending monomial order
          - sortColumns(...,DegreeOrder=>...) -- specify Ascending, Descending, or null
      - rsort -- sort a list or matrix in reverse order
        - rsort(...,MonomialOrder=>...) -- specify Ascending or Descending monomial order
        - rsort(...,DegreeOrder=>...) -- specify Ascending, Descending, or null
      - isSorted -- whether a list is sorted
      - List + List -- sum of two vectors
      - List - List -- difference of two vectors
      - List | List -- join lists, sequences or arrays
      - join -- join lists, sequences, and iterable objects
      - append -- add an element to the end of a list
      - prepend -- add an element to the beginning of a list
      - rotate -- rotate a list
      - insert -- copy a list, inserting an element
      - replace -- replacement in strings and lists
        - replace(ZZ,Thing,BasicList) -- copy a list, replacing an element
      - between -- insert something between elements of a list
      - delete -- delete some elements of a list
      - sum -- compute the sum
        - sum(List) -- sum the elements of a list
        - sum(ZZ,Function) -- sum consecutive values of a function
        - sum(VisibleList,Function) -- sum results of applying a function
        - sum(VisibleList,VisibleList,Function) -- sum results of applying a function pairwise
      - product
        - product(List) -- product of elements
        - product(ZZ,Function) -- product of consecutive values of a function
        - product(VisibleList,Function) -- product of values of a function
        - product(VisibleList,VisibleList,Function) -- product of results of applying a function pairwise
      - toList -- create a list
      - toSequence -- convert to sequence
      - flatten -- flatten a nested list or a matrix
      - splice -- remove subsequences from a sequence or list
      - deepSplice -- remove all levels of subsequences from a sequence or list
      - mingle -- mingle elements of several lists
      - mergePairs -- merge sorted lists of pairs
      - reverse -- reverse a list, sequence, or string
      - sequence -- make a sequence
      - unsequence -- extract the single element from a sequence of length 1
      - switch -- copy a list, switching two elements
      - tally -- tally the elements of a list, sequence, array, or string
      - commonest -- the most common elements of a list or tally
      - unique -- eliminate duplicates from a list
      - runLengthEncode -- run length encoding
      - uniquePermutations -- produce all unique permutations of a list
      - permutations -- produce all permutations of a list
      - subsets -- produce the subsets of a set or list
    - hash tables
      - HashTable -- the class of all hash tables
        - VirtualTally
          - Tally -- the class of all tally results
            - Tally + Tally -- union of tallies
            - Tally - Tally -- difference of tallies
          - BettiTally -- the class of all Betti tallies
            - MultigradedBettiTally -- the class of all multigraded Betti tallies
          - VirtualTally ** VirtualTally -- Cartesian product of tallies
          - VirtualTally ^** ZZ -- Cartesian power of sets and tallies
          - VirtualTally + VirtualTally -- union of tallies
          - VirtualTally - VirtualTally
          - - VirtualTally -- negation of a virtual tally
          - VirtualTally _ Thing -- get a count from a tally
          - product(VirtualTally) -- product of elements
          - sum(VirtualTally) -- sum of elements
        - OptionTable -- the class of hash tables for optional arguments
          - OptionTable >> Function -- attaching options to a function
          - OptionTable ++ OptionTable
      - MutableHashTable -- the class of all mutable hash tables
        - CacheTable -- hash tables for caching
        - IndexedVariableTable
        - Descent
      - hashing
      - hash -- hash code of an object
      - youngest -- the youngest member of a sequence
      - hashTable -- make a hash table
      - new HashTable from List -- make a hash table from a list
      - isMutable -- whether something may be modified
      - keys -- keys used in a hash table, dictionary, or database
      - values -- values in a hash table
      - pairs -- list the pairs in a hash table, dictionary, or basic list
      - copy -- copy an object
      - remove -- remove an entry from a mutable hash table, list, or database
      - merge -- merge two hash tables
      - combine -- combine hash tables
      - override -- override default values for optional arguments
      - mapping over hash tables -- apply a function to each element of a hash table
        - applyKeys -- apply a function to each key in a hash table
        - applyValues -- apply a function to each value in a hash table
        - applyPairs -- apply a function to each pair in a hash table
        - scanKeys -- apply a function to each key in a hash table or database
        - scanValues -- apply a function to each value in a hash table or database
        - scanPairs -- apply a function to the pairs in a hash table
        - selectKeys -- select a part of a hash table by keys
        - selectValues -- select part of a hash table by values
        - selectPairs -- select a part of a hash table by pairs
        - any(HashTable,Function) -- whether all key/value pairs in a hash table satisfy a specified condition
        - all(HashTable,Function) -- whether all key/value pairs in a hash table satisfy a specified condition
    - 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
        - incomparable -- a result indicating incomparability
      - and -- conjunction
      - or -- disjunction
      - xor -- exclusive disjunction
      - not -- negation
      - SPACE -- blank operator; often used for function application, making polynomial rings
      - -> -- make a function
        - options(Function) -- get the optional arguments and default values of a function or method
      - @@ -- 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 existence of value in a list, hash table, database, or string
      - @@? -- a binary operator
      - ! -- 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
        - ZZ & ZZ -- logical and
      - ++ -- 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
        - ZZ ~ -- logical not
      - (*) -- a unary postfix operator, used for indicating a graded object
      - : -- a binary operator, uses include repetition; ideal quotients
      - .. -- a binary operator, used for sequences of consecutive items
      - ..< -- a binary operator, used for sequences of consecutive items, not including the endpoint
      - << -- a binary operator, used for bit shifting or file output
        - left shift
        - List << List -- component-wise comparison of lists
      - >> -- a binary operator, used for bit shifting or attaching optional inputs to functions
        - right shift
      - | -- a binary operator, often used for horizontal concatenation
        - ZZ | ZZ -- logical or
      - || -- a binary operator, often used for vertical concatenation
      - @ -- a binary operator
      - ^^ -- logical exclusive-or
      - ?? -- null coalescing operator
      - |- -- a binary operator
      - <==> -- a binary operator
      - ===> -- a binary operator
      - ==> -- a binary operator
      - <=== -- a unary and binary operator
      - <== -- a unary and binary operator
      - ^< -- a binary operator, used for truncation
      - ^<= -- a binary operator, used for truncation
      - ^> -- a binary operator, used for truncation
      - ^>= -- a binary operator, used for truncation
      - _< -- a binary operator, used for truncation
      - _<= -- a binary operator, used for truncation
      - _> -- a binary operator, used for truncation
      - _>= -- a binary operator, used for truncation
      - _~ -- a unary postfix operator
      - ^~ -- a unary postfix operator, used for sheafification
      - ^! -- a unary postfix operator, used for the upper shriek functor
      - ^* -- a unary postfix operator, used for indicating pullback maps
      - _! -- a unary postfix operator, used for the lower shriek functor
      - _* -- a unary postfix operator, used for indicating pushforward maps
      - |_ -- a binary operator, used for restriction to a subset
      - => -- construct an option
      - , -- the comma, used for separating entries in a list or sequence
      - ; -- expression separator
      - %= -- augmented assignment for %
      - &= -- augmented assignment for &
      - **= -- augmented assignment for **
      - *= -- augmented assignment for *
      - ++= -- augmented assignment for ++
      - += -- augmented assignment for +
      - -= -- augmented assignment for -
      - ..<= -- augmented assignment for ..<
      - ..= -- augmented assignment for ..
      - //= -- augmented assignment for //
      - /= -- augmented assignment for /
      - <<= -- augmented assignment for <<
      - <==>= -- augmented assignment for <==>
      - ===>= -- augmented assignment for ===>
      - ==>= -- augmented assignment for ==>
      - >>= -- augmented assignment for >>
      - ??= -- augmented assignment for ??
      - @= -- augmented assignment for @
      - @@= -- augmented assignment for @@
      - @@?= -- augmented assignment for @@?
      - \= -- augmented assignment for \
      - \\= -- augmented assignment for \\
      - ^**= -- augmented assignment for ^**
      - ^= -- augmented assignment for ^
      - ^^= -- augmented assignment for ^^
      - _= -- augmented assignment for _
      - |-= -- augmented assignment for |-
      - |= -- augmented assignment for |
      - |_= -- augmented assignment for |_
      - ||= -- augmented assignment for ||
      - ·= -- augmented assignment for ·
      - ⊠= -- augmented assignment for ⊠
      - ⧢= -- augmented assignment for ⧢
      - precedence of operators
      - operatorAttributes -- a hash table with information about Macaulay2 operators
    - parsing precedence, in detail
      - seeParsing -- display parsing precedence table for Macaulay2 operators
    - conditional execution -- if-then-else statements
      - if -- condition testing
    - control flow statements
      - for -- for loops
      - while -- while loops
      - list -- loop control
      - do -- loop control
      - break -- break from a loop
      - continue -- continue with the next iteration of a loop
      - return -- return from a function
    - error handling -- signalling and trapping errors
      - error -- deliver error message
      - try -- catch an error
      - throw -- throw and catch exceptions
    - using functions
    - using functions with optional inputs
    - making functions
    - local variables in a function
    - making functions with a variable number of arguments
    - making functions with multiple return values
    - making new functions with optional arguments
      - symbols used as the name or value of an optional argument
        - Syzygies -- an optional argument
        - AdditionalPaths -- an optional argument
        - Algorithm -- an optional argument
        - Alignment -- an optional argument
        - Authors -- an optional argument
        - AuxiliaryFiles -- an optional argument
        - BaseRow -- an optional argument
        - BasisElementLimit -- an optional argument
        - Binary -- an optional argument
        - Body -- an optional argument
        - Boxes -- an optional argument
        - CacheExampleOutput -- an optional argument
        - Certification -- an optional argument
        - ChangeMatrix -- an optional argument
        - CheckDocumentation -- an optional argument
        - Citation -- an optional argument
        - ClosestFit -- an optional argument
        - CodimensionLimit -- an optional argument
        - CoefficientRing -- an optional argument
        - Configuration -- an optional argument
        - Constants -- an optional argument
        - Date -- an optional argument
        - DebuggingMode -- an optional argument
        - Degree -- an optional argument
        - DegreeGroup -- an optional argument
        - DegreeLift -- an optional argument
        - DegreeLimit -- an optional argument
        - DegreeMap -- an optional argument
        - DegreeOrder -- an optional argument
        - DegreeRank -- an optional argument
        - Degrees -- an optional argument
        - Dense -- an optional argument
        - Density -- an optional argument
        - DivideConquer -- an optional argument
        - Exclude -- an optional argument
        - FileName -- an optional argument
        - First -- an optional argument
        - FollowLinks -- an optional argument
        - GBDegrees -- an optional argument
        - Generic -- an optional argument
        - HardDegreeLimit -- an optional argument
        - Heft -- an optional argument
        - Height -- an optional argument
        - Hermitian -- an optional argument
        - Hilbert -- an optional argument
        - HorizontalSpace -- an optional argument
        - IgnoreExampleErrors -- an optional argument
        - InfoDirSection -- an optional argument
        - InstallPrefix -- an optional argument
        - Inverses -- an optional argument
        - Invertible -- an optional argument
        - Jacobian -- an optional argument
        - Join -- an optional argument
        - KeepFiles -- an optional argument
        - KeepZeroes -- an optional argument
        - Keywords -- an optional argument
        - LengthLimit -- an optional argument
        - Limit -- an optional argument
        - LoadDocumentation -- an optional argument
        - Local -- an optional argument
        - MakeDocumentation -- an optional argument
        - MakeHTML -- an optional argument
        - MakeInfo -- an optional argument
        - MakePDF -- an optional argument
        - MaximalRank -- an optional argument
        - MaxReductionCount -- an optional argument
        - MinimalMatrix -- an optional argument
        - Minimize -- an optional argument
        - MinimumVersion -- an optional argument
        - Monomials -- an optional argument
        - MonomialSize -- an optional argument
        - OptionalComponentsPresent -- an optional argument
        - Options -- an optional argument
        - Order -- an optional argument
        - PackageExports -- an optional argument
        - PackageImports -- an optional argument
        - PairLimit -- an optional argument
        - PairsRemaining -- an optional argument
        - Precision -- an optional argument
        - Prefix -- an optional argument
        - PrimitiveElement -- an optional argument
        - Projective -- an optional argument
        - RaiseError -- an optional argument
        - Range -- an optional argument
        - Reduce -- an optional argument
        - Reload -- an optional argument
        - RemakeAllDocumentation -- an optional argument
        - RerunExamples -- an optional argument
        - Result -- an optional argument
        - Reverse -- an optional argument
        - RunDirectory -- an optional argument
        - RunExamples -- an optional argument
        - SeparateExec -- an optional argument
        - SizeLimit -- an optional argument
        - SkewCommutative -- an optional argument
        - SourceRing -- an optional argument
        - StopBeforeComputation -- an optional argument
        - StopWithMinimalGenerators -- an optional argument
        - Strategy -- an optional argument
        - Strict -- an optional argument
        - SubringLimit -- an optional argument
        - SyzygyLimit -- an optional argument
        - SyzygyMatrix -- an optional argument
        - SyzygyRows -- an optional argument
        - Threads -- an optional argument
        - TotalPairs -- an optional argument
        - Tries -- an optional argument
        - Truncate -- an optional argument
        - Undo -- an optional argument
        - Unique -- an optional argument
        - UpdateOnly -- an optional argument
        - UpperTriangular -- an optional argument
        - UseCachedExampleOutput -- an optional argument
        - UseHilbertFunction -- an optional argument
        - UserMode -- an optional argument
        - Variable -- an optional argument
        - VariableBaseName -- an optional argument
        - Variables -- an optional argument
        - Verbose -- an optional argument
        - Verify -- an optional argument
        - Version -- an optional argument
        - VerticalSpace -- an optional argument
        - Bayer -- value of an optional argument
        - Binomial -- value of an optional argument
        - Center -- value of an optional argument
        - Decompose -- value of an optional argument
        - Default -- value of an optional argument
        - FastNonminimal -- value of an optional argument
        - FindOne -- value of an optional argument
        - Flexible -- value of an optional argument
        - Inhomogeneous -- value of an optional argument
        - Intersection -- value of an optional argument
        - Iterate -- value of an optional argument
        - Left -- value of an optional argument
        - Linear -- value of an optional argument
        - Maintainer -- value of an optional argument
        - MinimalGenerators -- whether to compute minimal generators and return a trimmed set of generators
        - Monomial -- value of an optional argument
        - Postfix -- value of an optional argument
        - Prune -- value of an optional argument
        - Quotient -- value of an optional argument
        - Right -- value of an optional argument
        - Test -- value of an optional argument
        - Torsion -- value of an optional argument
    - caching computation results
      - cache -- a key under which to store cache tables
      - memoize -- record results of function evaluation for future use
      - status -- get the status of a computation
    - using hooks
      - hooks -- list hooks attached to a key
      - addHook -- add a hook function to an object for later processing
      - runHooks -- run the hook functions stored in an object
    - what a class is
      - class -- class of an object
      - synonym -- synonym for members of a class
      - parent -- parent type of an object
      - instance -- whether something has a certain type
      - instances
      - ancestor(Type,Type) -- whether one type is an ancestor of another
      - ancestors -- the ancestors of something
    - installing methods
      - installing assignment methods -- install methods assignment to the value of an operator
      - installing augmented assignment methods
      - installMethod -- install methods
      - binary methods
      - nullaryMethods
    - inheritance
      - lookup -- look up methods
    - making new classes
      - new -- new objects and new types
        - of -- a keyword
        - newClass -- set the class and parent of an object
        - NewMethod
        - NewOfMethod
        - NewFromMethod
        - NewOfFromMethod
      - printing and formatting for new classes
        - expression -- convert to an expression
        - describe -- real description
    - making a new method function
      - method -- make a new method function
        - specifying typical values
          - typicalValues -- types of values returned by functions
        - MethodFunction -- a type of method function
        - MethodFunctionSingle -- a type of method function
        - MethodFunctionBinary -- a type of method function
        - MethodFunctionWithOptions -- a type of method function
    - debugging
      - the debugger
        - step -- step by single lines in the debugger
      - debug -- assistant for debugging packages, dictionaries, etc
        - debug(LocalDictionary) -- open a local or global dictionary to the user
        - debug(String) -- open the local dictionary of a loaded file
      - assert -- check whether something is true, raise an error if not
      - generateAssertions -- generate assert statements from experimental input
      - benchmark -- accurate timing of execution
      - code -- display source code
      - current -- the pseudocode that produced an error
      - currentPosition -- the current position in the current source file
      - lineNumber -- current line number
      - currentRowNumber -- current row number of the current input file
      - currentColumnNumber -- current column number of the current input file
      - currentFileName -- the current source file
      - currentFileDirectory -- the directory containing the current input file
      - pseudocode -- produce the pseudocode for a function
      - disassemble -- disassemble a pseudocode or function
      - frames -- get the frames associated to a closure
      - functionBody -- get the body of a function
        - FunctionBody -- the class of function bodies
        - CompiledFunctionBody -- the class of all compiled function bodies
      - dictionary -- determine the dictionary to which a symbol belongs
      - dictionaryPath
      - localDictionaries -- get local dictionaries
      - fileDictionaries -- local dictionaries for loaded files
      - edit -- edit source code
      - backtrace -- whether a backtrace is displayed following an error message
      - stopIfError -- whether to stop the program when an error occurs
      - handleInterrupts
      - debuggingMode -- whether to enter the debugger when an error occurs
      - debugError -- a function to debug
      - errorDepth -- set the error printing depth
      - debugLevel -- current debugging level
      - engineDebugLevel -- current engine debugging level
      - loadDepth -- the load depth
      - interpreterDepth -- nesting depth of the interpreter
      - recursionDepth -- the current recursion depth
      - recursionLimit -- set the limit on recursion
      - flagLookup -- flag a symbol
      - listLocalSymbols -- display of local symbols and their values
      - listUserSymbols -- display the user's symbols
      - commandInterpreter -- the top level command interpreter
      - locate -- locate source code
      - methods -- list methods
      - on -- trace a function each time it's run
      - peek -- examine contents of an object
      - peek' -- examine contents of an object
      - profile -- profile a computation
      - shield -- shield evaluation from interrupts
      - showStructure -- display parent structure
      - showClassStructure -- display class structure
      - showUserStructure -- show parent structure for those types defined by user
      - userSymbols -- a list of the user's symbols
      - listSymbols -- compact display of symbols and their values
      - lookupCount -- reference count for a symbol
      - serialNumber -- serial number of a dictionary, task, symbol, mutable hash table, or mutable list
    - packages -- Macaulay2 packages
      - Package -- the class of all packages
      - loadedPackages -- the list of loaded packages
      - package -- get containing package
      - loadPackage -- load a package
      - readPackage -- read the package preamble
      - needsPackage -- load a package if not already loaded
      - installPackage -- load and install a package and its documentation
      - installedPackages
      - uninstallPackage -- uninstall a package and remove its documentation
      - uninstallAllPackages
      - importFrom -- import symbols to the current private dictionary
      - tests -- locate a package's tests
      - use -- install or activate object
      - use(Package) -- activate a previously dismissed package
      - check -- perform tests of a package
      - debug(Package) -- open the private dictionary of a package
      - dismiss -- dismiss a package
      - options(Package)
      - makePackageIndex -- create an index of installed packages
      - PackageDictionary -- the dictionary for names of packages
    - creating a package
      - an example of a package
      - currentPackage -- the current package
      - newPackage -- the preamble of a package
      - export -- export symbols from a package
      - exportFrom -- export symbols from a package's private dictionary
      - exportMutable -- export mutable symbols from a package
      - beginDocumentation -- start documentation section of a package
      - TEST -- add a test for a package
      - endPackage -- end a new package
    - writing documentation
      - hypertext list format
      - handling hypertext
        - hypertext -- prepare hypertext for display
        - html -- convert to HTML format
        - mathML -- convert to MathML format
        - tex -- convert to $\TeX$ format
        - texMath -- convert to TeX math format
        - info -- convert hypertext to info format
        - net -- format for printing, as a net
      - document -- create a documentation node
        - package documentation template
        - function documentation template
        - optional argument documentation template
        - overview documentation template
        - Key -- key of a documentation node
        - Headline -- headline of a documentation node
        - BaseFunction -- the basename of a function in a documentation node
        - Usage -- ways to use a function in a documentation node
        - Inputs -- inputs for a function in a documentation node
        - Outputs -- outputs for a function in a documentation node
        - Consequences -- side-effects of a function in a documentation node
        - Acknowledgement -- acknowledgements listed in a documentation node
        - Contributors -- non-author contributors listed in a documentation node
        - References -- references listed in a documentation node
        - Caveat -- warnings or limitations listed in a documentation node
        - SeeAlso -- cross-references to other documentation nodes
        - Subnodes -- a menu of documentation nodes
        - SourceCode -- sources displayed in a documentation node
        - ExampleFiles -- data files corresponding to a documentation node
      - tutorial -- convert documentation from tutorial format
      - undocumented -- declare that something need not be documented
      - ofClass -- English phrases for types
      - EXAMPLE -- construct a hypertext item from a Macaulay2 input string
      - SYNOPSIS -- a standardized synopsis for use in documentation nodes
      - documentation keys
        - DocumentTag -- the class of all document tags
    - parallel programming with threads and tasks
      - parallelApply -- apply a function to each element in parallel
      - createTask -- create a task
      - addCancelTask(Task,Task) -- specify that the completion of one task triggers the cancellation of another
      - addDependencyTask(Task,Task) -- schedule a task, but ensure that it will not run until another task finishes
      - addStartTask(Task,Task) -- schedule a task upon completion of another
      - schedule -- schedule a task for execution
      - isReady(Task) -- whether a task is finished
      - taskResult(Task) -- retrieve the value returned by a task
      - cancelTask(Task) -- stop a task
      - isCanceled(Task) -- whether a task has been canceled
      - setIOExclusive -- exclusive I/O for the current thread
      - setIOSynchronized -- synchronized I/O for threads
      - setIOUnSynchronized -- unsynchronized I/O for threads
      - getIOThreadMode -- get I/O thread mode
      - threadLocal -- create a symbol whose value in one thread is not shared with others
      - allowableThreads -- the current maximum number of simultaneously running tasks
      - maxAllowableThreads -- the maximum possible number of simultaneously running tasks
      - Task -- the class of all tasks
    - system facilities
      - printing to the screen
        - print -- print something
        - printerr -- print something to stderr
        - pretty -- a pretty printer
        - printWidth
        - truncateOutput
      - printing to a file -- print to a file
        - printString -- lowlevel function to print a string, net, or symbol
        - stdio -- the standard input output file
        - stderr -- the standard error output file
      - 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
        - isRegularFile -- whether a file is a regular file
        - isDirectory -- whether a file is a directory
        - baseFilename -- the base part of a filename or path
        - temporaryFileName -- make a temporary file name
        - fileMode -- set or get file mode
          - fileMode(File) -- get file mode
          - fileMode(ZZ,File) -- set file mode
          - fileMode(String) -- get file mode
          - fileMode(ZZ,String) -- set file mode
        - fileExists -- whether a file exists
        - fileReadable
        - fileWritable
        - fileExecutable
        - fileTime -- get or set file modified time
        - copyFile(String,String)
        - moveFile(String,String)
        - removeFile -- remove a file
        - findFiles -- find files recursively
        - symlinkFile -- make a symbolic link to a file
        - linkFile(String,String) -- make a new link to a file
        - readlink -- get the resolved value a symbolic link
        - realpath -- convert a filename to one passing through no symbolic links
        - currentDirectory -- current working directory
        - readDirectory -- read the contents of a directory
        - makeDirectory(String) -- make a directory
        - mkdir
        - changeDirectory -- change the current working directory
        - copyDirectory(String,String)
        - removeDirectory -- remove a directory
        - symlinkDirectory(String,String) -- make symbolic links for all files in a directory tree
      - communicating with programs
        - run -- run an external command
        - findProgram -- load external program
          - Program -- external program object
          - programPaths -- user-defined external program paths
        - runProgram -- run an external program
          - ProgramRun -- result of running an external program
            - status(ProgramRun) -- get the return status of a program run
        - Program << Thing -- run program with input redirection
      - using sockets
        - openListener(String) -- open a port for listening
        - openIn(String) -- open an input file
        - openInOut -- open an input output file
        - openOut(String) -- open an output file
        - openOutAppend(String) -- open an output file for appending
        - endl -- end an output line
        - flush -- flush output to file
        - close -- close a file
        - closeIn -- close an input file
        - closeOut -- close an output file
        - get -- get the contents of a file
        - getc -- get a byte
        - read -- read from a file
          - read(Sequence) -- read from a file
          - read(String) -- read from a file
          - read(File) -- read from a file
          - read(File,ZZ) -- read from a file
        - scanLines -- apply a function to each line of a file
        - fileLength -- the length of a file
        - height(File) -- get window height
        - width(File) -- get window width
        - atEndOfFile(File) -- test for end of file
        - echoOn -- turn on echoing
        - echoOff -- turn off echoing
        - isOpen -- whether a file or database is open
        - isReady(File) -- whether a file has data available for reading
        - isOutputFile(File) -- whether a file is open for output
        - isInputFile(File) -- whether a file is open for input
        - isListener(File) -- whether a file is open for listening
        - openFiles -- list the open files
        - connectionCount -- the number of connections
      - notify -- whether to notify the user when a file is loaded
      - autoload -- arrange for a function to be loaded automatically
      - initialization file
      - input -- read Macaulay2 commands and echo
      - load -- read Macaulay2 commands
      - needs -- read Macaulay2 commands if necessary
      - end -- stop loading a file
      - loadedFiles
      - fileExitHooks -- a list of hooks (functions) to execute when the current file has been loaded
      - path -- list of directories to look in
      - rootURI
      - rootPath
      - homeDirectory -- the home directory of the user
      - minimizeFilename -- minimize a file name
      - relativizeFilename -- relativize a file name
      - toAbsolutePath -- the absolute path version of a file name
      - searchPath(List,String) -- search a path for a file
      - clearEcho -- turn off echoing
      - setEcho -- turn on echoing
      - top level loop
        - value -- evaluate
        - capture -- evaluate Macaulay2 code and capture the output
        - oo -- the last output value
        - ooo -- the next to the last output value
        - oooo -- the third to the last output value
        - OutputDictionary -- the dictionary for output values
        - clearAll -- forget everything
        - clearOutput -- forget output values
        - topLevelMode -- the current top level mode
          - Standard -- the standard top level printing method
          - WebApp -- the web app top level printing method
          - TeXmacs -- the TeXmacs top level printing method
          - Print -- top level method for printing results
            - Wrap -- a key for methods for wrapping printed output
          - NoPrint -- top level method for non-printing results
          - AfterEval -- top level method applied after evaluation
          - BeforePrint -- top level method applied before printing results
          - AfterPrint -- top level method applied after printing
          - AfterNoPrint -- top level method applied after not printing
      - restart -- restart Macaulay2
      - addEndFunction -- add an ending function
      - Time -- the class of all timing results
      - time -- time a computation
      - timing -- time a computation
      - elapsedTime -- time a computation including time elapsed
      - elapsedTiming -- time a computation using time elapsed
      - cpuTime -- seconds of cpu time used since Macaulay2 began
      - currentTime -- get the current time
      - sleep -- sleep for a while
      - nanosleep -- sleep for a given number of nanoseconds
      - alarm -- set an alarm
      - exec -- execute another program
      - exit -- exit the program
      - fork -- fork the process
      - show -- display various objects in an external viewer
      - pager -- display with paging
      - getenv -- get value of environment variable
      - getWWW -- get a web page
      - splitWWW -- separate an http response into header and body
      - httpHeaders(String) -- prepend http headers to a string
      - processID -- the process identifier
      - groupID -- the process group identifier
      - setGroupID -- set the process group identifier
      - kill -- kill a process
      - kill(ZZ) -- kill a process
      - quit -- quit the program
      - wait -- wait for child process
      - limitFiles
      - limitProcesses
      - commandLine -- the command line arguments
      - scriptCommandLine -- the command line arguments to be used when running a script
      - environment -- the environment variables
      - version -- information about this version of the program
      - Database -- the class of all database files
      - firstkey -- get the first key
      - nextkey -- the next key in a database
      - openDatabase -- open a database file
      - openDatabaseOut -- open a database file for writing
      - reorganize -- reorganize a database file
      - GCstats -- information about the status of the garbage collector
      - collectGarbage -- collect the garbage in memory
      - registerFinalizer -- register a string that will be displayed when an object is garbage collected
    - Core -- the core of Macaulay2
      - how Macaulay2 finds its files
        - currentLayout -- relative locations of Macaulay2 files
        - prefixPath -- absolute locations of Macaulay2 files
        - prefixDirectory -- the prefix directory
        - applicationDirectory -- the path to the user's application directory
        - applicationDirectorySuffix -- suffix that determines the user's application directory
    - the engine of Macaulay2
      - parallelism in engine computations -- parallelism in engine computations
    - the interpreter of Macaulay2
    - Thing -- the class of all things
      - NetFile -- the class of all net files
        - newNetFile -- create a new net file
        - getNetFile -- get the sequence of completed lines (nets) from a net file
      - Boolean -- the class of boolean values
        - true
        - false
      - Dictionary -- the class of all dictionaries
        - GlobalDictionary -- the class of all global dictionaries
        - LocalDictionary -- the class of all local dictionaries
        - length(Dictionary) -- length of a dictionary
      - Nothing -- the empty class
        - null -- the unique member of the empty class
      - Number -- the class of all numbers
        - isANumber -- whether a number is not not-a-number
        - InfiniteNumber -- the class of all infinite numbers
          - isFinite -- whether a number is finite
          - isInfinite -- whether a number is infinite
          - infinity -- infinity
        - IndeterminateNumber -- the class of all indeterminate numbers
          - indeterminate -- an indeterminate number
        - InexactNumber
          - precision
          - numeric -- convert to floating point
          - round -- round a number
          - size2 -- number of binary digits to the left of the point
          - clean -- set to zero elements that are approximately zero
          - norm
          - minExponent
          - maxExponent
        - InexactNumber'
          - RR_* -- the parent class of all rings of real numbers
          - CC_* -- the parent class of all rings of complex numbers
          - RingFamily _* -- the common parent for rings in a family
      - File -- the class of all files
      - AtomicInt -- the class of atomic integers
        - new AtomicInt from ZZ -- initialize an atomic integer
        - new ZZ from AtomicInt -- load an atomic integer
        - store -- store the value of an atomic integer
        - exchange -- exchange the value of an atomic integer
        - compareExchange -- compare and possibly exchange the value of an atomic integer
        - AtomicInt += ZZ -- atomic fetch and add
        - AtomicInt -= ZZ -- atomic fetch and subtract
        - AtomicInt &= ZZ -- atomic fetch and bitwise and
        - AtomicInt |= ZZ -- atomic fetch and bitwise or
        - AtomicInt ^^= ZZ -- atomic fetch and bitwise xor
      - Symbol -- the class of all symbols
        - Keyword -- the class of all keywords
        - symbolBody -- symbol bodies
        - symbol -- get a symbol
        - global -- get a global symbol
        - local -- get a local symbol
        - getSymbol -- make a global user symbol from a string
        - getGlobalSymbol -- create a global symbol in a global dictionary
        - isGlobalSymbol -- whether a global symbol with a given name exists
        - erase -- remove a global symbol
        - protect -- protect a symbol
        - value(Symbol) -- retrieve the value of a symbol
        - findSynonyms(Symbol) -- find synonyms of symbols
        - globalAssign -- global assignment, in function form
        - 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
        - globalReleaseFunction -- the standard method for the global variable release hook
        - GlobalReleaseHook
        - Symbol _ Thing = Thing -- assignment to an indexed variable
        - Symbol .. Symbol -- sequences of consecutive symbols
        - Symbol ..< Symbol -- sequences of consecutive symbols
        - Symbol _ Thing -- index variable
      - Pseudocode -- the class of pseudocodes
        - value(Pseudocode) -- execute pseudocode
    - Type -- the class of all mutable types
      - Monoid -- the class of all monoids
        - OrderedMonoid -- the class of all ordered monoids
        - GeneralOrderedMonoid -- the class of all ordered free commutative monoids
        - MonoidElement -- the class of all monoid elements
        - generators(Monoid) -- list of generators
        - numgens(Monoid) -- number of generators of a monoid
        - tensor(Monoid,Monoid) -- tensor product of monoids
        - vars(Monoid) -- list of variables in a monoid
      - Ring -- the class of all rings
        - EngineRing -- the class of rings handled by the engine
          - Engine -- specify whether a ring is handled by the engine
          - InexactField -- the class of inexact fields
            - RealField -- the class of all real fields
            - ComplexField -- the class of all complex fields
          - GaloisField -- the class of all Galois fields
            - GF -- make a finite field
            - order -- a key used internally
            - ambient(GaloisField) -- corresponding quotient ring
          - FractionField -- the class of all fraction fields
          - PolynomialRing -- the class of all ordered monoid rings
            - hilbertSeries(PolynomialRing) -- compute the Hilbert series of a ring
          - QuotientRing -- the class of all quotient rings
            - codim(QuotientRing) -- compute the codimension
            - presentation(PolynomialRing,QuotientRing) -- presentation of a quotient ring
        - ring -- get the associated ring of an object
        - isRing -- whether something is a ring
        - ambient(Ring) -- ambient polynomial ring
        - baseRing -- produce the ring from which a ring was formed
          - baseRings -- store the list of base rings of a ring
        - degree(Ring)
        - degreeLength -- the length of the degree vector
        - degreeGroup -- the degree group of a ring or monoid
        - degrees -- degrees of generators
        - degrees(Ring) -- degrees of generators
        - degreesRing -- the ring or monoid of degrees
          - degreesRing(List) -- the ring or monoid of degrees
        - numgens(Ring) -- number of generators of a polynomial ring
        - dim(Ring) -- compute the Krull dimension
        - vars(Ring) -- row matrix of the variables
        - generators(Ring) -- the list of generators of a ring
        - hilbertPolynomial(Ring) -- compute the Hilbert polynomial of the ring
        - jacobian(Ring) -- the Jacobian matrix of the polynomials defining a quotient ring
        - minimalPresentation(Ring) -- compute a minimal presentation of a quotient ring
        - selectVariables -- make a subring of a polynomial ring generated by selected variables
        - flattenRing -- write a ring as a (quotient of a) polynomial ring
          - flattenRing(...,CoefficientRing=>...) -- specify the coefficient ring of the flattened ring
          - flattenRing(...,Result=>...) -- specify which output(s) to return
        - generators -- provide matrix or list of generators
      - RingFamily
        - InexactFieldFamily -- the class of all families of inexact fields
        - default -- default member of a family
          - defaultPrecision -- default precision of numbers
      - SelfInitializingType -- the class of all self initializing types
      - WrapperType -- a class of lists with abbreviated constructors
      - HeaderType -- a class of lists with abbreviated constructors
    - ImmutableType -- the class of all immutable types
    - Function -- the class of all functions
      - FunctionClosure -- the class of all function closures
        - uncurry -- uncurry a function
      - CompiledFunction -- the class of all compiled functions
      - CompiledFunctionClosure -- the class of all compiled function closures
      - Function Thing -- function application
      - Function @@ Function -- composition of functions
      - Function _ Thing -- attach the first argument to a function of two or more arguments
      - methodOptions(Function) -- recover the options used when a method function was created
      - identity -- the identity function
      - notImplemented -- print an 'not implemented' error message
  - packages provided with Macaulay2
  - rings
    - basic rings of numbers
      - ZZ -- the class of all integers
        - zero -- whether something is zero
        - even -- tell whether an integer is even
        - odd -- tell whether an integer is odd
        - isPrime -- whether a integer or polynomial is prime
        - isPseudoprime(ZZ) -- whether an integer is probably prime
        - nextPrime -- compute the smallest prime greater than or equal to a given number
        - changeBase -- change integer base
      - QQ -- the class of all rational numbers
      - RR -- the class of all real numbers
        - toRR -- convert to high-precision real number
        - isReal -- whether a number is real
      - RRi -- the class of all real intervals
        - toRRi -- construct an interval
        - interval -- construct an interval
        - diameter -- diameter of an interval
        - left -- left endpoint of an interval
        - right -- right endpoint of an interval
        - midpoint -- midpoint of an interval
        - numericInterval -- convert a constant to an interval
        - intersect(RRi) -- intersection of input intervals
        - isMember(QQ,RRi) -- membership test in an interval
        - isEmpty(RRi) -- empty test for an interval
        - isSubset(RRi,RRi) -- subset test for intervals
        - span -- construct smallest interval
        - span(List) -- construct smallest interval
        - span(Sequence) -- construct smallest interval
      - CC -- the class of all complex numbers
        - toCC -- convert to high-precision complex number
        - conjugate -- complex conjugate
        - realPart -- real part
        - imaginaryPart -- imaginary part
    - integers modulo a prime
      - char -- get the characteristic of the ring or field
      - getPrimeWithRootOfUnity -- find a prime p with a primitive n-th root of unity r in ZZ/p
    - finite fields
      - isFinitePrimeField -- whether a ring is a finite prime field
    - polynomial rings
      - isPolynomialRing -- whether something is a polynomial ring
      - Ring Array -- the standard way to make a polynomial ring
      - Ring Monoid -- make a polynomial ring
      - coefficientRing -- get the coefficient ring
      - vars -- variables
      - vars(List) -- a sequence of variables
      - get a ring variable by index -- get a ring variable by index
      - get a ring variable by name -- get a ring variable by name
        - Symbol _ Ring -- get a ring variable by name
        - IndexedVariable _ Ring -- get a ring variable by name
      - get a monomial by exponent vector -- make a monomial from a list of exponents
      - graded and multigraded polynomial rings
        - heft vectors
          - heft -- heft vector of ring or monoid
          - findHeft -- find a heft vector for a list of degrees
      - monomial orderings
        - examples of specifying alternate monomial orders
        - division in polynomial rings with monomials less than 1
        - monomial orders for free modules
          - Schreyer orders -- induced monomial order on a free module
            - schreyerOrder -- create or obtain free modules with Schreyer 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
        - packing monomials for efficiency
        - monoid -- make or retrieve a monoid
          - monoid(Ring) -- make or retrieve a monoid
          - FlatMonoid
          - options(Monoid) -- get values used for optional arguments
          - monoid(...,Variables=>...) -- specify the names of the indeterminates
          - monoid(...,Local=>...) -- specify local or global monomial order
          - monoid(...,Inverses=>...) -- allow negative exponents in monomials
          - monoid(...,Weights=>...) -- specify weights of the variables
          - monoid(...,Degrees=>...) -- specify the degrees of the variables
          - monoid(...,DegreeLift=>...) -- specify maps between degree groups
          - monoid(...,Heft=>...) -- specify a heft vector
          - monoid(...,Join=>...) -- specify how to handle degrees in the coefficient ring
          - monoid(...,MonomialOrder=>...) -- specify the monomial ordering
          - monoid(...,MonomialSize=>...) -- specify the bit-length of monomial exponents in the ring
          - monoid(...,SkewCommutative=>...) -- specify skew commuting variables in the ring
          - monoid(...,WeylAlgebra=>...) -- specify differential operators in the ring
        - GRevLex -- graded reverse lexicographical monomial ordering
        - Lex -- lexicographical monomial ordering
        - GLex -- graded lexicographic ordering
        - Weights -- assigning weights to the variables
        - Eliminate -- elimination order
        - GroupLex -- invert some variables with lexicographical ordering
        - GroupRevLex -- invert some variables with reverse lexicographical ordering
        - ProductOrder -- product ordering
        - definition of product (block) orders
        - RevLex -- reverse lexicographic ordering
        - NCLex -- non-commutative lexicographical order
        - MonomialOrder -- monomial ordering
        - obtaining the monomial order of a ring
    - quotient rings
      - Ring / Ideal -- make a quotient ring
      - isQuotientRing -- whether something is a quotient ring
      - 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
    - manipulating polynomials
      - degree
      - homogenize -- homogenize with respect to a variable
      - weightRange -- the pair of lowest and highest weights of the monomials
      - monomials -- matrix of monomials in a ring element or matrix
        - monomials(...,Variables=>...) -- specify variables
      - coefficient -- coefficient of a monomial
      - coefficients -- get the monomials and coefficients of a polynomial or matrix
      - content -- the content of a polynomial
      - exponents -- the exponents of a polynomial
      - index -- numeric index of a ring variable
      - indices -- indices of a polynomial; also components for a direct sum
      - part -- select terms of a polynomial by degree(s) or weight(s)
      - parts -- display terms of a polynomial degree by degree
      - someTerms -- select some terms of a polynomial
      - terms -- provide a list of terms of a polynomial
      - topCoefficients -- first variable and its coefficient of a polynomial or matrix
      - leadCoefficient -- the coefficient of the leading term
      - leadMonomial -- the leading monomial of a ring element
      - leadTerm -- get the greatest term
      - size -- the size of an object
      - standardForm -- convert to standard form
      - listForm -- convert to list form
    - factoring polynomials
      - roots(RingElement) -- compute the roots of a polynomial
    - substitution and maps between rings
      - substitute -- substituting values for variables
        - RingElement Sequence -- evaluation of polynomials
      - substituting values for variables
      - working with multiple rings
        - use(Ring) -- install ring variables and ring operations
        - lift -- lift to another ring
          - liftable -- whether lifting to another ring is possible
          - setupLift -- set up lift from one ring to another
        - promote -- promote to another ring
          - setupPromote -- set up promote from one ring to another
        - newRing -- make a copy of a ring, with some features changed
        - commonRing -- find smallest containing ring
      - RingMap -- the class of all ring maps
        - RingMap RingElement -- apply a ring map
        - kernel(RingMap) -- kernel of a ringmap
          - kernel(...,SubringLimit=>...) -- stop after finding enough elements of a subring
        - source(RingMap) -- find the source ring for a map of rings
        - target(RingMap) -- find the target ring for a map of rings
        - RingMap ^ ZZ -- power
        - newCoordinateSystem -- change variables
      - basic construction, source and target of a ring map
      - evaluation and composition of ring maps
      - kernel and coimage of a ring map
      - 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
    - fraction fields
      - frac -- construct a fraction field
      - fraction
      - numerator -- numerator of a fraction
      - denominator -- denominator of a fraction
    - finite field extensions
      - isField -- whether something is a field
      - toField(Ring) -- declare that a ring is a field
      - getNonUnit -- retrieve a previously discovered non-unit
      - isPrimitive -- whether an element is a primitive element of a finite field
    - exterior algebras
      - isSkewCommutative -- whether a ring has skew commuting variables
      - antipode -- antipode for skew commuting polynomial rings
    - symmetric algebras
    - tensor products of rings
    - Weyl algebras
    - local rings
      - Ring List -- make a local polynomial ring
    - Schur rings
    - associative algebras
  - ideals
    - Ideal -- the class of all ideals
      - MonomialIdeal -- the class of all monomial ideals handled by the engine
        - monomialIdeal -- make a monomial ideal
          - monomialIdeal(Matrix) -- monomial ideal of lead monomials
          - monomialIdeal(Ideal) -- monomial ideal of lead monomials of a Gröbner basis
        - monomialSubideal -- find the largest monomial ideal in an ideal
        - independentSets -- some size-maximal independent subsets of variables modulo an ideal
        - standardPairs -- find the standard pairs of a monomial ideal
        - polarize -- compute the polarization of a monomial ideal
        - codim(MonomialIdeal) -- compute the codimension
        - MonomialIdeal - MonomialIdeal -- monomial ideal difference
        - dual(MonomialIdeal,List) -- the Alexander dual
        - dual(MonomialIdeal,RingElement) -- the Alexander dual
        - dual(MonomialIdeal) -- the Alexander dual of a monomial ideal
          - dual(MonomialIdeal,Strategy=>...)
        - lcm(MonomialIdeal) -- least common multiple of all minimal generators
      - isMonomialIdeal -- whether something is a monomial ideal
      - isSquareFree -- whether something is square free monomial ideal
      - Ideal * Ideal -- product of ideals
      - Ideal + Ideal -- sum of ideals
      - Ideal ^ ZZ -- power of an ideal
      - Ideal ^ Array -- bracket power of an ideal
      - leadTerm(Ideal) -- get the ideal of greatest terms
      - leadTerm(ZZ,Ideal) -- get the ideal of lead polynomials
      - codim(Ideal) -- compute the codimension
      - degree(Ideal)
      - dim(Ideal) -- compute the Krull dimension
      - generator -- provide a single generator
      - generators(Ideal) -- the generator matrix of an ideal
      - hilbertPolynomial(Ideal) -- compute the Hilbert polynomial of the quotient of the ambient ring by the ideal
      - hilbertSeries(Ideal) -- compute the Hilbert series of the quotient of the ambient ring by the ideal
      - intersect(Ideal,Ideal) -- compute an intersection of a sequence of ideals or modules
      - isSubset(Ideal,Ideal) -- whether one object is a subset of another
      - jacobian(Ideal) -- the Jacobian matrix of the generators of an ideal
      - isMember(RingElement,Ideal) -- test membership in an ideal
      - minimalPresentation(Ideal) -- compute a minimal presentation of the quotient ring defined by an ideal
      - numgens(Ideal) -- number of generators of an ideal
      - support(Ideal) -- list of variables occurring in the generators of an ideal
      - Ideal / Function -- apply a function to generators of an ideal
      - Ideal / Ideal -- quotient module
      - irreducibleCharacteristicSeries -- irreducible characteristic series of an ideal
      - decompose
    - ideal -- make an ideal
      - ideal(List) -- make an ideal
      - ideal(Matrix) -- make an ideal
      - ideal(Module) -- convert a module to an ideal
      - ideal(MonomialIdeal) -- convert a monomial ideal to an ideal
      - ideal(Ring) -- get the defining ideal
      - ideal(RingElement) -- make an ideal
    - isIdeal -- whether something is an ideal
    - creating an ideal
    - ideals to and from matrices
    - ideals to and from modules
      - comodule -- submodule to quotient module
    - sums, products, and powers of ideals
    - equality and containment
    - extracting generators of an ideal
      - generators of rings, ideals, and modules
    - dimension, codimension, and degree
    - intersection of ideals
  - matrices
    - Matrix -- the class of all matrices
      - isWellDefined -- whether a map is well defined
      - entries -- get the entries of a matrix
      - eigenvalues -- find eigenvalues of a matrix
        - eigenvalues(...,Hermitian=>...) -- whether to assume the matrix is symmetric or Hermitian
      - eigenvectors -- find eigenvectors of a matrix over real or complex numbers
        - eigenvectors(...,Hermitian=>...) -- whether to assume the matrix is symmetric or Hermitian
      - transpose -- transpose a matrix or table
      - dual -- dual module or map
      - support -- list of variables occurring in a polynomial or matrix
      - leadTerm(Matrix) -- get the greatest term of each column
      - leadTerm(ZZ,Matrix) -- get the matrix of lead polynomials of each column
      - leadComponent -- the leading component(s) of a vector or matrix
      - borel(Matrix) -- make a Borel fixed submodule
      - dual(Matrix) -- dual of a map
      - modulo -- find the pre-image (pullback) of image of a map (low level version)
      - complement -- find the minimal generators for cokernel of a matrix (low level form)
      - Matrix ** RingElement
      - ambient(Matrix) -- get the map between the ambient free modules
      - contract(Matrix,Matrix) -- contract a matrix by a matrix
      - cover(Matrix) -- get the map between the covering free modules
      - degrees(Matrix) -- degrees of target and source
      - diagonalMatrix -- make a diagonal matrix
        - diagonalMatrix(Matrix) -- make a diagonal matrix from entries of a matrix
        - diagonalMatrix(Ring,ZZ,ZZ,List) -- make a diagonal matrix from a list
      - Matrix ++ Matrix -- direct sum of maps
      - markedGB(Matrix,Matrix) -- make a marked Gröbner basis
      - homology(Matrix,Matrix) -- homology of a pair of maps
      - inverse(Matrix) -- compute the inverse
        - InverseMethod -- compute reciprocals
      - jacobian(Matrix) -- the matrix of partial derivatives of polynomials in a matrix
      - koszul(Matrix) -- the Koszul complex
      - koszul(ZZ,Matrix) -- a differential in a Koszul complex
      - map(Ring,Matrix) -- make a ring map
      - minimalPresentation(Matrix) -- minimally present source and target of a matrix
      - pivots(Matrix) -- list of pivot locations of a matrix
      - smithNormalForm(Matrix) -- smith normal form for a matrix over a PID
      - source(Matrix) -- find the source module of matrix
      - syz(Matrix) -- compute the syzygy matrix
      - target(Matrix) -- find the target module of matrix
      - compress -- extract nonzero columns from a matrix
      - tensor(RingMap,Matrix) -- tensor product via a ring map
      - tensor(Matrix,Matrix) -- tensor product
      - Matrix ** Ring -- tensor product
      - Matrix ^ ZZ -- power
      - Matrix | Matrix -- join matrices horizontally
      - Matrix || Matrix -- join matrices vertically
      - Matrix / Number -- scalar division
      - quotient(Matrix,Matrix) -- factor a map through another with the same target
      - Matrix % GroebnerBasis -- compute the normal form of a ring element or matrix using a Gröbner basis
      - Matrix * Matrix -- matrix multiplication
      - Matrix _ Sequence -- get entry of matrix
      - selectInSubring -- select columns in a subring
      - solve -- solve linear equation(s)
      - divideByVariable -- divide all columns by a (power of a) variable
    - matrix -- make a matrix
      - matrix(List) -- create a matrix from a doubly-nested list of ring elements or matrices
      - matrix(Ring,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(RingElement) -- make a matrix from a ring element
      - matrix(Vector) -- make a matrix
      - matrix(RingMap) -- the matrix associated to a ring map
    - inputting a matrix
    - projections, inclusions, and permutations
    - random and generic matrices
      - genericMatrix -- make a generic matrix of variables
      - genericSymmetricMatrix -- make a generic symmetric matrix
      - genericSkewMatrix -- make a generic skew symmetric matrix of variables
    - mutable matrices
      - MutableMatrix -- the class of all mutable matrices
      - mutableMatrix -- make a mutable matrix
      - mutableMatrix(Ring,ZZ,ZZ) -- make a mutable matrix filled with zeroes
      - mutableIdentity(Ring,ZZ) -- make a mutable identity matrix
      - MutableMatrix _ Sequence = Thing -- assignment to an element of a mutable matrix
      - row and column operations
        - numRows(Matrix) -- number of rows in a matrix or mutable matrix
        - rowAdd -- add a multiple of one row to another
        - rowSwap -- interchange rows
        - rowPermute -- permute some rows
        - rowMult -- multiply a row by a ring element
        - numColumns(Matrix) -- number of columns in a matrix or mutable matrix
        - columnAdd -- add a multiple of one column to another
        - columnSwap -- interchange columns
        - columnPermute -- permute some columns
        - columnMult -- multiply a column by a ring element
      - fillMatrix -- fill a mutable matrix with random numbers
      - randomMutableMatrix(ZZ,ZZ,RR,ZZ) -- a random mutable matrix of integers
      - nullSpace -- find the null space of a mutable matrix
      - reducedRowEchelonForm -- compute the reduced row echelon form of a matrix or mutable matrix over a field
      - rowRankProfile -- find the row rank profile of a mutable matrix
      - columnRankProfile -- find the column rank profile of a mutable matrix
    - extracting information about a matrix
    - basic arithmetic of matrices
    - concatenating matrices
    - submatrices
      - submatrix' -- exclude rows and/or columns of a matrix
      - submatrixByDegrees -- submatrix consisting of rows and columns in an interval or box of degrees
      - submatrix(Matrix,VisibleList) -- select columns
      - submatrix -- select part of a matrix
      - Matrix _ List -- select columns
      - Matrix ^ List -- select rows
      - Matrix _ Array -- component of map corresponding to summand of source
      - Matrix ^ Array -- component of map corresponding to summand of target
    - diff and contract
      - 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'(Matrix,Matrix) -- differentiate a matrix by a matrix, the dual notion
      - contract -- contract one matrix by another
      - contract'(Matrix,Matrix) -- contract a matrix by a matrix, the dual notion
      - jacobian -- the Jacobian matrix of partial derivatives
      - reshape -- reshape a matrix
    - LUdecomposition -- compute the LU decomposition of a matrix
    - QRDecomposition -- compute a QR decomposition of a real matrix
    - SVD -- singular value decomposition of a matrix
      - SVD(...,DivideConquer=>...) -- whether to use the LAPACK divide and conquer SVD algorithm
    - rank of a matrix
    - determinants and minors
      - trace(Matrix) -- trace of a matrix
      - minors(ZZ,Matrix) -- ideal generated by minors
        - minors(...,Strategy=>...) -- choose between Bareiss, Cofactor and Dynamic algorithms
      - determinant -- determinant of a matrix
        - determinant(...,Strategy=>...) -- choose between Bareiss, Cofactor and Dynamic algorithms
        - Bareiss
        - Cofactor
        - Dynamic
      - permanents -- ideal generated by square permanents of a matrix
      - pfaffians -- ideal generated by Pfaffians
      - pfaffian -- Pfaffian of a skew-symmetric matrix
      - fittingIdeal -- Fitting ideal of a module
    - exterior power of a matrix
      - exteriorPower -- exterior power
        - exteriorPower(...,Strategy=>...) -- choose between Bareiss, Cofactor and Dynamic algorithms
      - exteriorPower(ZZ,Matrix) -- exterior power of a matrix
    - format and display of matrices in Macaulay2
      - blockMatrixForm -- global flag for block printing
      - compactMatrixForm -- global flag for compact printing
      - printingAccuracy -- current accuracy for printing numbers
      - printingLeadLimit -- maximum number of leading zeroes to use when printing real numbers
      - printingPrecision -- current precision for printing numbers
      - printingSeparator -- string used to separate mantissa from exponent when printing real numbers
      - printingTimeLimit
      - printingTrailLimit -- maximum number of additional trailing digits to use when printing real numbers
    - importing and exporting matrices
  - modules
    - Module -- the class of all modules
      - symmetricAlgebra -- the symmetric algebra of a module
      - symmetricPower -- symmetric power
      - exteriorPower(ZZ,Module) -- exterior power of a module
      - formation -- recover the methods used to make a module
      - Module + Module -- sum of submodules
      - dual(Module) -- dual module
      - Module Array -- make a chain complex from a module
      - ambient -- ambient free module of a subquotient, or ambient ring
      - ambient(Module) -- ambient free module
      - super -- get the ambient module
      - cover -- 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
      - length(Module) -- compute the length of a module
      - dim(Module) -- compute the Krull dimension
      - Module ++ Module -- direct sum of modules
      - factor(Module) -- factor a ZZ-module
      - hilbertPolynomial(Module) -- compute the Hilbert polynomial of the module
      - inducedMap -- compute an induced map
        - inducedMap(Module,Module) -- compute the map induced by the identity
        - inducedMap(Module,Module,Matrix) -- compute the induced map
        - inducedMap(...,Degree=>...) -- specify the degree of a map
        - inducedMap(...,Verify=>...) -- verify that a map is well-defined
        - inducesWellDefinedMap -- whether a map is well defined
      - isSubset(Module,Module) -- whether one object is a subset of another
      - map(Module) -- identity map
      - mingens(Module) -- minimal generator matrix
      - minimalPresentation(Module) -- minimal presentation of a module
      - numgens(Module) -- number of generators of a module
      - pdim(Module) -- compute the projective dimension of a module
      - presentation(Module) -- presentation of a module
      - pushForward(RingMap,Module) -- compute the pushforward of a module along a ring map
      - isSubquotient(Module,Module) -- check whether a module is a subquotient of another
      - tensor(Module,Module) -- tensor product of modules
      - Module ** Ring -- tensor product
      - tensor(Matrix,Module) -- tensor product
        - flip -- isomorphism map of commutativity of tensor product
        - tensorAssociativity -- associativity isomorphisms for tensor products
      - Module ^** ZZ -- tensor power
      - wedgeProduct(ZZ,ZZ,Module) -- the exterior multiplication map
      - Module ^ ZZ -- direct sum
      - Module ^ Array -- projection onto summand
      - Module ^ List -- projection onto summand
      - Module / Module -- quotient module
      - Module _ List -- map from free module to some generators
      - ZZ _ Module -- get the zero vector in a module
      - Module _ Array -- inclusion from summand
      - truncate
    - module -- make or get a module
      - module(Ring) -- make or get a module
      - module(Vector) -- the module of a vector
    - isModule -- whether something is a module
    - free modules
      - Ring ^ ZZ -- make a free module
      - Ring ^ List -- make a free module
      - isFreeModule -- whether something is a free module
    - matrices to and from modules -- including kernel, cokernel and image
      - kernel(Matrix) -- kernel of a matrix
      - cokernel(Matrix) -- cokernel of a map of modules
      - image(Matrix) -- image of a map
      - generators(Module) -- the generator matrix of a module
      - relations -- the defining relations
    - making modules from matrices
    - submodules and quotients
      - isSubmodule -- whether a module is evidently a submodule of a free module
      - isQuotientModule -- whether something is evidently a quotient of a free module
    - subquotient modules -- the way Macaulay2 represents modules
      - subquotient -- make a subquotient module
    - manipulating modules
    - computing syzygies
    - extracting elements
    - minimal presentations and generators
    - equality and containment of modules
    - module homomorphisms
    - maps between modules
    - information about a map of modules
    - constructing maps between modules
    - right modules or left modules?
    - gradedModule -- make a graded module
    - Hilbert functions and free resolutions -- including degree and betti numbers
      - isHomogeneous -- whether something is homogeneous (graded)
      - codim(Module) -- codimension of the support of a module
      - degree(Module) -- get the degree of a module
      - hilbertSeries(Module) -- compute the Hilbert series of the module
      - poincare -- assemble degrees of a ring, module, or ideal into a polynomial
      - poincareN -- assemble degrees into polynomial
      - reduceHilbert -- reduce a Hilbert series expression
      - betti -- display or modify a Betti diagram
        - multigraded -- convert a Betti tally into a multigraded Betti tally
        - betti(BettiTally) -- view and set the weight vector of a Betti diagram
        - minimalBetti -- minimal betti numbers of (the minimal free resolution of) a homogeneous ideal or module
    - basis -- basis or generating set of all or part of a ring, ideal or module
    - exterior power of a module
  - map -- make a map
    - source -- source of a map
    - target -- target of a map
    - map(Module,Module,Function) -- create a matrix by specifying a function that 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 that 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(...,Degree=>...) -- specify the degree of a map
    - map(Module,Module,RingMap,Matrix) -- homomorphism of modules over different rings
    - map(Ring,Ring) -- make a ring map, using the names of the variables
    - map(Ring,Ring,List) -- make a ring map
    - map(Ring,Ring,Matrix) -- make a ring map
    - Hom -- module of homomorphisms
      - adjoint -- the tensor-Hom adjunction maps
      - compose -- composition as a pairing on Hom-modules
      - homomorphism -- get the homomorphism from element of Hom
      - homomorphism' -- get the element of Hom from a homomorphism
      - Hom(Module,Matrix) -- induced map on Hom
    - End -- module of endomorphisms
  - A first course in commutative algebra
    - Elementary uses of Groebner bases I. Math 634 Fall 2005
    - 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
  - Tutorial: Modules in Macaulay2
  - Tutorial: Elementary uses of Gröbner bases
  - Tutorial: Canonical Embeddings of Plane Curves and Gonality
  - Tutorial: Fano varieties
  - Tutorial: Divisors
  - elementary arithmetic
    - mod -- reduce modulo an integer
    - plus -- addition
    - minus -- additive inverse
    - difference -- difference
    - times -- multiplication
    - power -- power
    - powermod -- powers of integers mod N
    - sqrt(ZZ,ZZ) -- modular square root
    - lcm -- least common multiple
    - gcd -- greatest common divisor
    - gcdCoefficients -- greatest common divisor with coefficients
    - factor -- factor a ring element or a ZZ-module
  - commutative algebra
    - Gröbner bases
      - what is a Groebner basis?
      - Groebner basis examples and applications
        - simple Groebner basis computations over various rings
      - fine control of a Groebner basis computation
      - computing Groebner bases
        - gb -- compute a Gröbner basis
          - GroebnerBasis -- the class of all Gröbner bases
            - returnCode
            - generators(GroebnerBasis) -- the generator matrix of a Gröbner basis
            - mingens(GroebnerBasis) -- (partially constructed) minimal generator matrix
            - syz(GroebnerBasis) -- retrieve the syzygy matrix
            - target(GroebnerBasis) -- find target of a Gröbner basis
            - getChangeMatrix -- get the change of basis matrix
          - GroebnerBasisOptions
          - Gröbner basis algorithms
          - gbSnapshot -- the Gröbner basis matrix as so far computed
          - gbRemove -- remove Gröbner basis
          - gbTrace -- current engine computation tracing level
          - LongPolynomial -- a Strategy option value
        - groebnerBasis -- Gröbner basis, as a matrix
        - forceGB -- declare that the columns of a matrix are a Gröbner basis
          - forceGB(...,ChangeMatrix=>...) -- specify the change of basis matrix from a Gröbner basis to the generators of a module
          - forceGB(...,MinimalMatrix=>...) -- specify the minimal generator matrix
          - forceGB(...,SyzygyMatrix=>...) -- specify the syzygy matrix
    - normal forms
      - methods for normal forms and remainder -- normal form of ring elements and matrices
    - elimination of variables
    - hilbertFunction -- the Hilbert function
    - hilbertSeries -- compute the Hilbert series
      - hilbertSeries(...,Order=>...) -- display the truncated power series expansion
      - hilbertSeries(...,Reduce=>...) -- reduce the Hilbert series
    - hilbertPolynomial -- compute the Hilbert polynomial
      - hilbertPolynomial(...,Projective=>...) -- choose how to display the Hilbert polynomial
      - ProjectiveHilbertPolynomial -- the class of all Hilbert polynomials
        - ProjectiveHilbertPolynomial ZZ -- value of polynomial
        - degree(ProjectiveHilbertPolynomial)
        - dim(ProjectiveHilbertPolynomial) -- the degree of the Hilbert polynomial
        - euler(ProjectiveHilbertPolynomial) -- constant term of the Hilbert polynomial
        - hilbertSeries(ProjectiveHilbertPolynomial) -- compute the Hilbert series of a projective Hilbert polynomial
      - projectiveHilbertPolynomial -- Hilbert polynomial of projective space
    - syz -- the syzygy matrix
    - koszul -- Koszul complex or specific matrix in the Koszul complex
    - eagonNorthcott -- Eagon-Northcott complex of a matrix of linear forms
    - regularity -- compute the Castelnuovo-Mumford regularity
    - presentation -- presentation of a module or ring
    - quotient -- quotient or division
    - quotient' -- factor a map through another with the same source
    - quotientRemainder -- matrix quotient and remainder
    - quotientRemainder' -- matrix quotient and remainder (opposite)
    - remainder -- matrix remainder
    - remainder' -- matrix remainder (opposite)
    - pseudoRemainder -- compute the pseudo-remainder
    - rank -- compute the rank
    - dim -- compute the Krull dimension
    - codim -- compute the codimension
      - codim(Ideal,Generic=>...)
    - pdim -- compute the projective dimension
    - depth -- depth of an object
    - height -- height of an object
    - length -- length of an object
    - complete
    - trim -- minimize generators and relations
    - prune -- prune, e.g., compute a minimal presentation
      - pruningMap
    - numgens -- the number of generators
    - mingens -- minimal generator matrix
      - Complement -- a Strategy option value
    - minimize
    - minimalPresentation -- compute a minimal presentation
    - tensor -- tensor product
    - directSum -- direct sum of modules or maps
      - isDirectSum -- whether something is a direct sum
      - components -- list the components of a direct sum
        - indexComponents -- specify keys for components of a direct sum
    - directProduct -- direct product
    - monomialCurveIdeal -- make the ideal of a monomial curve
    - isBorel -- whether an ideal is fixed by upper triangular changes of coordinates
    - isCommutative -- whether a ring is commutative
    - isAffineRing -- whether something is an affine ring
  - homological algebra
    - kernel -- kernel of a map
    - cokernel -- cokernel of a map
    - image -- image of a map
    - coimage -- coimage of a map
    - preimage -- preimage of a map
    - pullback -- compute the pullback morphism
    - pushout -- compute the pushout morphism
    - extend -- extend an object
    - isExact
    - isInjective -- whether a map is injective
    - isSurjective -- whether a map is surjective
    - isIsomorphism -- whether a map is an isomorphism
    - inverse -- compute the inverse
    - ScriptedFunctor -- the class of all scripted functors
      - subscript -- specify the function in a scripted functor for a subscript
      - superscript -- specify the function in a scripted functor for a superscript
      - argument -- specify the function in a scripted functor for an argument
    - id -- identity map
    - HH -- general homology and cohomology functor
      - homology -- general homology functor
      - cohomology -- general cohomology functor
        - HH^ZZ Module -- local cohomology of a module
    - Tor -- Tor module
      - Tor_ZZ(Module,Module) -- compute a Tor module
    - Ext -- compute an Ext module
      - Ext(Module,Module) -- total Ext module
      - Ext^ZZ(Module,Module) -- Ext module
      - Ext^ZZ(Module,Matrix) -- map between Ext modules
      - Ext^ZZ(Matrix,Module) -- map between Ext modules
  - algebraic geometry
    - singularLocus -- singular locus
    - Grassmannian -- compute the ideal of the Grassmannian of linear subspaces of a vector space
    - Schubert -- compute the Plücker ideal of a Schubert variety
    - Fano -- compute the ideal of a Fano scheme in the Grassmannian
    - isNormal
    - isSmooth
    - isVeryAmple
    - randomKRationalPoint -- pick a random K rational point on the scheme X defined by I
    - chi
    - euler
    - eulers
    - genus
    - genera
  - combinatorics
    - binomial -- binomial coefficient
    - compositions -- list the compositions of an integer
    - inversePermutation -- inverse permutation
    - partitions -- list the partitions of an integer
      - Partition -- a type of list representing a partition of a natural number
      - Partition _ ZZ -- get element
      - conjugate(Partition) -- conjugate a partition
    - random -- get a random object
      - random(ZZ,ZZ) -- get a random integer or real number
      - random(QQ) -- get a random rational number
      - random(Type) -- get a random object of a type
      - random(List) -- shuffle a list randomly
      - random(ZZ,Ideal) -- get a random homogeneous element from a graded ideal
      - random(ZZ,Ring) -- get a random homogeneous element from a graded ring
      - random(List,Module) -- get a random vector in the module
      - random(Module,Module) -- get a random map of module
      - setRandomSeed -- set starting point for random number generator
      - randomSubset
    - Set -- the class of all sets
      - set -- make a set
      - elements -- list of elements
      - union -- compute the union
      - intersect -- compute an intersection
      - Set #? Thing -- test set membership
      - Set - Set -- set difference
      - union(Set,Set) -- set union
      - intersect(Set,Set) -- set intersection
      - Set ** Set -- Cartesian product
      - sum(Set) -- sum of elements
      - product(Set) -- product of elements
      - select(Set,Function) -- select a part of a set
      - isSubset(Set,Set) -- whether one object is a subset of another
    - rays -- 1-dimensional cones of a fan or polyhedral object
    - cone -- mapping cone or polyhedral cone
    - normalCone
    - multidegree -- multidegree
  - analytic functions
    - Constant
      - isConstant -- whether a ring element is constant
      - ii -- the square root of -1
      - pi
      - EulerConstant -- the Euler-Mascheroni constant
      - CatalanConstant -- Catalan's constant
    - integrate -- numerical integration
    - abs -- absolute value function
    - sign -- sign (signum) function
    - floor -- floor function
    - floor(Number) -- floor function
    - ceiling -- ceiling function
    - ceiling(Number) -- ceiling function
    - truncate(Number) -- round a number toward zero
    - sqrt -- square root function
    - log -- logarithm function
    - log1p -- logarithm of 1+x
    - exp -- exponential function
    - exp(RingElement)
    - expm1 -- exponential minus 1
    - erf -- error function
    - erfc -- complementary error function
    - inverseErf -- inverse error function
    - eint -- exponential integral
    - Beta -- Beta function
    - regularizedBeta -- regularized beta function
    - inverseRegularizedBeta -- inverse of the regularized beta function
    - Gamma -- Gamma function
    - lngamma -- logarithm of the Gamma function
    - Digamma -- Digamma function
    - regularizedGamma -- upper regularized gamma function
    - inverseRegularizedGamma -- inverse of the upper regularized gamma function
    - zeta -- Riemann zeta function
    - BesselJ -- Bessel function of the first kind
    - BesselY -- Bessel function of the second kind
    - agm -- arithmetic-geometric mean
    - sin -- compute the sine
    - asin -- arcsine
    - sinh -- compute the hyperbolic sine
    - asinh -- inverse hyperbolic sine
    - cos -- compute the cosine
    - acos -- arccosine
    - cosh -- compute the hyperbolic cosine
    - acosh -- inverse hyperbolic cosine
    - csc -- cosecant
    - csch -- hyperbolic cosecant
    - sec -- secant
    - sech -- hyperbolic secant
    - tan -- compute the tangent
    - atan -- compute the arctangent of a number
    - atan2 -- compute an angle of a certain triangle
    - tanh -- compute the hyperbolic tangent
    - atanh -- compute the hyperbolic arctangent of a number
    - cot -- cotangent
    - acot -- compute the inverse cotangent
    - coth -- hyperbolic cotangent
    - acoth -- compute the hyperbolic arctangent of a number
  - changes to Macaulay2, by version
    - changes, 1.25.11
    - changes, 1.25.05
    - changes, 1.24.11
    - changes, 1.24.05
    - changes, 1.23
    - changes, 1.22
    - changes, 1.21
    - changes, 1.20
    - changes, 1.19.1
    - changes, 1.19
    - changes, 1.18
    - changes, 1.17
    - changes, 1.16
    - changes, 1.15
    - changes, 1.14
    - changes, 1.13
    - changes, 1.12
    - changes, 1.11
    - changes, 1.10
    - changes, 1.9.2
    - changes, 1.9.1
    - changes, 1.9
    - changes, 1.8.2
    - changes, 1.8.1
    - changes, 1.8
    - changes, 1.7
    - changes, 1.6
    - changes, 1.5
    - changes, 1.4
    - changes, 1.3.1
    - changes, 1.3
    - changes, 1.2
    - changes, 1.0 and 1.1
    - list of obsolete functions
  - replacements for commands and scripts from Macaulay
  - Acknowledgements
  - Copyright and license
    - COPYING-GPL-2 -- GNU General Public License, version 2
    - COPYING-GPL-3 -- GNU General Public License, version 3
    - Singular-Factory
    - frobby
    - GNU MP
    - MPFR
    - MPFI
    - GC garbage collector
    - LAPACK
    - BLAS
    - NTL library
    - FLINT
    - givaro
    - fflas-ffpack
    - MPSolve -- a library for finding roots of univariate polynomials
    - Boost -- a collection of C++ source libraries
    - 4ti2
    - gfan
    - normaliz
    - csdp
    - nauty
    - cdd+
    - lrslib
    - msolve -- a library for solving multivariate polynomial systems
    - topcom
    - cohomCalg
  - The authors of Macaulay2
    - Daniel R. Grayson
    - Michael E. Stillman
    - David Eisenbud
  - The authors of Macaulay2 packages