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
      • ! -- 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 ⧢
      • 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
      • fittingIdeal -- Fitting ideal of a module
    • Pfaffians
    • 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
    • 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.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