master index

master index

[top]

!

#

%

&

*

+

,

-

.

/

:

;

<

=

>

?

@

Acknowledgements

AssociativeExpression

BasicList #? ZZ

BasisElementLimit

BinaryOperation

BinaryPowerMethod

Canonical Embeddings of Plane Curves and Gonality

ChainComplex ** ChainComplex

ChainComplex ** ChainComplexMap

ChainComplex ** GradedModule

ChainComplex ++ ChainComplex

ChainComplex [...]

ChainComplex _ ZZ

ChainComplexMap

ChainComplexMap ** ChainComplex

ChainComplexMap ** ChainComplexMap

ChainComplexMap _ ZZ

CodimensionLimit

CoherentSheaf ** CoherentSheaf

CoherentSheaf ++ CoherentSheaf

CoherentSheaf / CoherentSheaf

CoherentSheaf ZZ

CompleteIntersection

ConversionFormat

ConvertFixedRepeat

ConvertToExpression

Copyright and license

Daniel R. Grayson

Database # String

Database #? String

Developer's Corner

Elementary uses of Groebner bases

EliminationOrder

EmptyMarkUpType

Factorization and characteristic sets library

Factory library

Function \ VisibleList

Function \ {...}

FunctionApplication

GC garbage collector

GeneralOrderedGroup

GeneralOrderedMonoid

Getting started

GlobalAssignHook

GlobalReleaseHook

GradedModule ** ChainComplex

GradedModule ** GradedModule

GradedModule ++ GradedModule

GradedModule [...]

GradedModule _ ZZ

GradedModuleMap

HH ChainComplex

HH^ZZ ChainComplex

HH^ZZ ChainComplexMap

HH^ZZ CoherentSheaf

HH_Matrix Matrix

HH_ZZ ChainComplex

HH_ZZ ChainComplexMap

HardDegreeLimit

HashTable # Thing

HashTable #? Thing

Hom(ChainComplex,Module)

How to get this program

IndeterminateNumber

IndexedVariable

IndexedVariableTable

Invoking the program

Language and Programming Overview

Mathematical Overview

Mathematical Vignettes

Matrix % Matrix

Matrix % RingElement

Matrix ** Matrix

Matrix ** Module

Matrix ++ Matrix

Matrix // Matrix

Matrix // RingElement

Matrix | Matrix

Matrix || Matrix

MatrixExpression

Michael E. Stillman

MinimalGenerators

MinorsComputation

Miscellaneous Topics

Module ** Module

Module + Module

Module ++ Module

Module / Module

Module : Module

Module == Module

Monoid ** Monoid

MutableHashTable

NewOfFromMethod

NonAssociativeProduct

Nothing << Thing

OptionTable ==> Function

PfaffiansComputation

PrimitiveElement

ProjectiveHilbertPolynomial

ProjectiveHilbertPolynomial ZZ

ProjectiveVariety

PushforwardComputation

Reading the Documentation

Reference Manual

Resources required

Ring OrderedMonoid

RingElement _ RingElement

SchurRing _ {...}

ScriptedFunctor

SelfInitializingType

SimplePowerMethod

SingleArgumentDispatch

SkewCommutative

SparseMonomialVectorExpression

SparseVectorExpression

StopBeforeComputation

StopWithMinimalGenerators

String << Thing

String | String

UseHilbertFunction

VariableBaseName

VisibleList / Function

\

^

_

accumulate(Function,Thing,VisibleList)

accumulate(Function,VisibleList)

accumulate(VisibleList,Function)

accumulate(VisibleList,Thing,Function)

addStartFunction

algebraic varieties

apply(BasicList,BasicList,Function)

apply(BasicList,Function)

apply(HashTable,Function)

apply(ZZ,Function)

assigning values

associative algebras

bases of parts of modules

briefDocumentation

chainComplex (...)

chainComplex GradedModule

chainComplex Matrix

codim CoherentSheaf

coefficientRing

coherent sheaves

communicating with programs

compactMatrixForm

complete ChainComplex

component example

components ChainComplex

computing Groebner bases

computing resolutions

computing syzygies

conditional execution

connectionCount

contract(Matrix,Matrix)

cotangentSheaf ProjectiveVariety

cotangentSheaf(ZZ,ProjectiveVariety)

creating and writing files

currentDirectory

degrees CoherentSheaf

diff ProjectiveHilbertPolynomial

diff RingElement

diff and contract

diff(Matrix,Matrix)

diff(ProjectiveHilbertPolynomial,ZZ)

displaying matrices

divideByVariable

drop(BasicList,ZZ)

drop(BasicList,{...})

dual ChainComplex

editing Macaulay 2 code with emacs

engine communication protocol

executing other programs

exterior algebras

exteriorPower(ZZ,CoherentSheaf)

extracting information from chain complexes

flip(Module,Module)

fold(Function,Thing,VisibleList)

fold(Function,VisibleList)

fold(VisibleList,Function)

fold(VisibleList,Thing,Function)

forceGB(..., ChangeMatrix => ...)

formatDocumentTag

fraction fields

free resolutions of modules

gb(..., ChangeMatrix => ...)

gb(..., CodimensionLimit => ...)

gb(..., DegreeLimit => ...)

gb(..., PairLimit => ...)

gb(..., StopBeforeComputation => ...)

gb(..., StopWithMinimalGenerators => ...)

gb(..., Strategy => ...)

gb(..., SyzygyLimit => ...)

gcdCoefficients

generatorExpressions

generatorSymbols

generators GroebnerBasis

genericSkewMatrix

genericSymmetricMatrix

getChangeMatrix

getting input from the user

globalAssignFunction

globalReleaseFunction

gradedModuleMap

high level gb engine commands

hilbertFunction

hilbertPolynomial

indexComponents

inducedMap(..., Degree => ...)

inducedMap(..., Verify => ...)

inducesWellDefinedMap

inheritance from parents

initialization file

installing methods

irreducibleCharacteristicSeries

isPolynomialRing

isQuotientModule

isSubset(Set,Set)

kernel(..., SubringLimit => ...)

leadCoefficient

length ChainComplex

length GradedModule

listUserSymbols

local variables in a file

local variables in a function

low level gb engine commands

making a new method function

making chain complexes by hand

making functions

making functions with a variable number of arguments

making generic matrices

making matrices

making modules from matrices

making new functions with optional arguments

making new types

making random matrices

manipulating chain complexes

manipulating matrices

manipulating modules

manipulating polynomials

map(ChainComplex,ChainComplex,Function)

map(GradedModule,GradedModule,Function)

map(Module,Matrix)

map(Module,Module)

map(Module,Module,Function)

map(Module,Module,Matrix)

map(Module,Module,RingElement)

map(Module,Module,ZZ)

map(Module,Module,{...})

map(Module,Nothing,{...})

map(Module,RingElement)

map(Module,ZZ,Function)

map(Module,ZZ,{...})

map(Ring,Ring,{...})

mapping over hash tables

mapping over lists

maps between chain complexes

maps between modules

maps between rings

matrix(Ring,{...})

max ChainComplex

method functions with a variable number of arguments

method functions with optional arguments

method(..., Associative => ...)

method(..., TypicalValue => ...)

min ChainComplex

mingens GroebnerBasis

module CoherentSheaf

monomialIdeal Matrix

monomialIdeal MonomialIdeal

monomialIdeal(ZZ,Matrix)

multi-graded polynomial rings

n

new ChainComplex

new HashTable from {...}

newCoordinateSystem

not documented yet

numbered variables

obsolete functions and symbols

openDatabaseOut

options Function

poincareComputation

polynomial rings

polynomial rings with other monomial orderings

printing and formatting for new types

printing to the screen

product(ZZ,Function)

product({...},Function)

product({...},{...},Function)

projectiveHilbertPolynomial

pseudoRemainder

pushForward(..., StopBeforeComputation => ...)

pushForward(..., StopWithMinimalGenerators => ...)

pushForward(..., Strategy => ...)

pushForward1(..., DegreeLimit => ...)

pushForward1(..., MonomialOrder => ...)

pushForward1(..., PairLimit => ...)

pushForward1(..., StopBeforeComputation => ...)

pushForward1(..., StopWithMinimalGenerators => ...)

pushForward1(..., Strategy => ...)

pushForward1(..., UseHilbertFunction => ...)

quotient(..., MinimalGenerators => ...)

quotient(..., Strategy => ...)

random(Module,Module)

random(ZZ,Ring)

random({...},Ring)

rank CoherentSheaf

removeLowestDimension

replacements for commands and scripts from Macaulay

resolution Ideal

resolution Matrix

resolution Module

resolution(..., DegreeLimit => ...)

resolution(..., HardDegreeLimit => ...)

resolution(..., LengthLimit => ...)

resolution(..., PairLimit => ...)

resolution(..., SortStrategy => ...)

resolution(..., StopBeforeComputation => ...)

resolution(..., Strategy => ...)

resolution(..., SyzygyLimit => ...)

ring CoherentSheaf

runEndFunctions

runStartFunctions

running Macaulay 2 in emacs

saturate(..., DegreeLimit => ...)

saturate(..., MinimalGenerators => ...)

saturate(..., Strategy => ...)

scan(BasicList,Function)

scan(ZZ,Function)

scanPairs(HashTable,Function)

select(BasicList,Function)

select(HashTable,Function)

select(ZZ,BasicList,Function)

select(ZZ,HashTable,Function)

selectInSubring

setrecursionlimit

sheaf(Module,Variety)

showUserStructure

sortColumns(..., DegreeOrder => ...)

sortColumns(..., MonomialOrder => ...)

specifying typical values

stats GroebnerBasis

subscripted variables

subsets(Set,ZZ)

sum ChainComplex

sum ChainComplexMap

sum(ZZ,Function)

sum({...},Function)

sum({...},{...},Function)

symbol Resolution

symmetric algebras

symmetricAlgebra

syz GroebnerBasis

syz(..., ChangeMatrix => ...)

syz(..., CodimensionLimit => ...)

syz(..., StopBeforeComputation => ...)

syz(..., StopWithMinimalGenerators => ...)

syz(..., Strategy => ...)

tensor products of rings

tensorAssociativity

toExternalString

toList BasicList

toList HashTable

topCoefficients

transmitting a matrix

transmitting a monomial

transmitting a polynomial

transmitting a positive integer

transmitting a sequence

transmitting a vector

transmitting an integer

transmitting an integer mod n

two dimensional formatting

using functions

using functions with optional arguments

variety CoherentSheaf

viewing the symbols defined so far

what a class is

{...} / Function

{...} ==> Function

|

~

[top]