-
Notifications
You must be signed in to change notification settings - Fork 1
Q and A Monday
Daniel R. Grayson edited this page Sep 17, 2019
·
4 revisions
Feel free to ask a question!
Q1. Objects over multiple rings (Yeongrak Kim)
If we define a ring as a local variable inside a method, M2 generates a new base ring at each time. Hence, it is impossible to take further operations on results, unless we define a global variable outside the method.
S=QQ[x,y,z];
M1=random(S^3, S^{3:-1});
M2=random(S^3,S^{3:-1});
M1+M2
-- quotient out the last variable
test=method()
test(Matrix):= M->(
n:=numgens ring M;
R:=(coefficientRing S)[t_0..t_(n-2)];
phi:=map(R,S,matrix{{t_0..t_(n-2), 0}});
phi M
)
-- does not work since their rings are different
test(M1)+test(M2)
ring test M1 === ring test M2
-- The following makes sense, but use global T and psi
T=(coefficientRing S)[u,v]
psi=map(T,S,{T_0,T_1,0})
psi(M1)+psi(M2)
What is a better option to implement a method with different base rings as inputs, however, we need to play with several outputs sometimes?
ANSWER: Use "memoize", as shown here, to minimize the number of rings returned:
i2 : help memoize
o2 = memoize -- record results of function evaluation for future use
***************************************************************
Description
===========
memoize f -- produces, from a function f, a new function that behaves the same as f, but remembers
previous answers to be provided the next time the same arguments are presented.
+---------------------------------------------------------+
|i1 : fib = n -> if n <= 1 then 1 else fib(n-1) + fib(n-2)|
| |
|o1 = fib |
| |
|o1 : FunctionClosure |
+---------------------------------------------------------+
|i2 : time fib 28 |
| -- used 0.362113 seconds |
| |
|o2 = 514229 |
+---------------------------------------------------------+
|i3 : fib = memoize fib |
| |
|o3 = fib |
| |
|o3 : FunctionClosure |
+---------------------------------------------------------+
|i4 : time fib 28 |
| -- used 0.00003202 seconds |
| |
|o4 = 514229 |
+---------------------------------------------------------+
|i5 : time fib 28 |
| -- used 1.579e-6 seconds |
| |
|o5 = 514229 |
+---------------------------------------------------------+
The function memoize operates by constructing a "MutableHashTable" in which the argument sequences are
used as keys for accessing the return value of the function.
An optional second argument to memoize provides a list of initial values, each of the form x => v, where v
is the value to be provided for the argument x.
Warning: when the value returned by f is "null", it will always be recomputed, even if the same arguments
are presented.
Warning: the new function created by memoize will save references to all arguments and values it
encounters, and this will often prevent those arguments and values from being garbage-collected as soon as
they might have been. If the arguments are implemented as mutable hash tables (modules, matrices and
rings are implemented this way) then a viable strategy is to stash computed results in the arguments
themselves. See also CacheTable.
Ways to use memoize :
=====================
* memoize(Function)
* memoize(Function,List)
o2 : DIV
i3 : f = (k,n) -> k[t_0..t_(n-2)]
o3 = f
o3 : FunctionClosure
i4 : f (QQ,3)
o4 = QQ[t , t ]
0 1
o4 : PolynomialRing
i5 : f (QQ,3)
o5 = QQ[t , t ]
0 1
o5 : PolynomialRing
i6 : o4_0
o6 = t
0
o6 : QQ[t , t ]
0 1
i7 : o5_0
o7 = t
0
o7 : QQ[t , t ]
0 1
i8 : o4_0 + o5_0
stdio:8:6:(3): error: expected pair to have a method for '+'
i9 : g = memoize f
o9 = g
o9 : FunctionClosure
i10 : g (QQ,3)
o10 = QQ[t , t ]
0 1
o10 : PolynomialRing
i11 : g (QQ,3)
o11 = QQ[t , t ]
0 1
o11 : PolynomialRing
i12 : oo === ooo
o12 = true
i14 : o10_0 + o11_0
o14 = 2t
0
o14 : QQ[t , t ]
0 1
i15 : o4 === o5
o15 = false
Q2. (Markus)
Occasionally, some messages refer to files in /Users/dan. Is this intended? For example:
i1 : code assert
stdio:1:1:(3): error: couldn't find file /Users/dan/src/M2/M2.git/M2/Macaulay2/d/startup.m2.in
ANSWER: No, it was not intended. Perhaps it can be fixed, so during the session, I showed how to create an "issue" on github. Here it is: https://github.com/Macaulay2/M2/issues/1005
Q3.
This question concerned how to use y and y_0 simultaneously as variables in rings. The answer was that it is not really possible, since, in order to access y_0, y has to have as its value a table that includes an entry for getting the value of y_0. The discussion led to this code:
i18 : QQ[y]
o18 = QQ[y]
o18 : PolynomialRing
i19 : QQ[y_0]
stdio:19:5:(3): error: no method for binary operator _ applied to objects:
-- y (of class QQ[y])
-- _ 0 (of class ZZ)
i20 : y
o20 = y
o20 : QQ[y]
i21 : QQ[symbol y_0]
warning: clearing value of symbol y to allow access to subscripted variables based on it
: debug with expression debug 9371 or with command line option --debug 9371
o21 = QQ[y ]
0
o21 : PolynomialRing
i22 : y
o22 = y
o22 : IndexedVariableTable
i23 : peek oo
o23 = IndexedVariableTable{0 => y }
0
symbol$ => y
i24 : tt
o24 = tt
o24 : Symbol
i25 : tt = symbol tt
o25 = tt
o25 : Symbol
i26 : local u
o26 = u
o26 : Symbol
i27 : u
i28 : mutable y
o28 = true
i30 : loadPackage "Foo"
--warning: symbol "sin" in Core.Dictionary is shadowed by a symbol in Foo.Dictionary
-- use the synonym Core$sin
o30 = Foo
o30 : Package
i31 : FOO
o31 = FOO
o31 : PolynomialRing
i32 : vars FOO
o32 = | y_0 y_1 |
1 2
o32 : Matrix FOO <--- FOO
i33 : y_0
o33 = y
0
o33 : QQ[y ]
0
i34 : FOO_0
o34 = y
0
o34 : FOO
i35 : vars FOO
o35 = | y_0 y_1 |
1 2
o35 : Matrix FOO <--- FOO
i36 : y_0 * oo
stdio:36:5:(3): error: no method found for applying promote to:
argument 1 : y (of class QQ[y ])
0 0
argument 2 : FOO
i37 : degreesRing o21
o37 = ZZ[T]
o37 : PolynomialRing
i38 : T
o38 = T
o38 : Symbol
i39 : use degreesRing o21
o39 = ZZ[T]
o39 : PolynomialRing
i40 : T
o40 = T
o40 : ZZ[T]
i41 : help Variable
o41 = Variable -- specify a name for a variable
*****************************************
Description
===========
Variable => x -- an option used with "GF", to specify a symbol to be used as a name for the generator of
the Galois field.
Functions with optional argument named Variable :
=================================================
* GF(..., Variable => ...), see "GF" -- make a finite field
* Grassmannian(..., Variable => ...), see "Grassmannian(ZZ,ZZ)" -- the Grassmannian of linear subspaces
of a vector space
* "idealizer(..., Variable => ...)" -- Sets the name of the indexed variables introduced in computing
the endomorphism ring Hom(J,J).
* "integralClosure(..., Variable => ...)" -- set the base letter for the indexed variables introduced
while computing the integral closure
* "integralClosures(..., Variable => ...)"
* intersectInP(..., Variable => ...), see "intersectInP(..., BasisElementLimit => ...)" -- Option for
intersectInP
* multiplicity(..., Variable => ...), see "intersectInP(..., BasisElementLimit => ...)" -- Option for
intersectInP
* "makeS2(..., Variable => ...)" -- Sets the name of the indexed variables introduced in computing the
S2-ification.
* "ringFromFractions(..., Variable => ...)"
* Schubert(..., Variable => ...), see "Schubert(ZZ,ZZ,VisibleList)" -- find the Pluecker ideal of a
Schubert variety
* distinguished(..., Variable => ...), see "symmetricKernel(..., Variable => ...)" -- Choose name for
variables in the created ring
* isReduction(..., Variable => ...), see "symmetricKernel(..., Variable => ...)" -- Choose name for
variables in the created ring
* jacobianDual(..., Variable => ...), see "symmetricKernel(..., Variable => ...)" -- Choose name for
variables in the created ring
* normalCone(..., Variable => ...), see "symmetricKernel(..., Variable => ...)" -- Choose name for
variables in the created ring
* reesAlgebra(..., Variable => ...), see "symmetricKernel(..., Variable => ...)" -- Choose name for
variables in the created ring
* reesIdeal(..., Variable => ...), see "symmetricKernel(..., Variable => ...)" -- Choose name for
variables in the created ring
* specialFiber(..., Variable => ...), see "symmetricKernel(..., Variable => ...)" -- Choose name for
variables in the created ring
* specialFiberIdeal(..., Variable => ...), see "symmetricKernel(..., Variable => ...)" -- Choose name
for variables in the created ring
* "symmetricKernel(..., Variable => ...)" -- Choose name for variables in the created ring
For the programmer
==================
The object "Variable" is a symbol.
o41 : DIV
i42 : help reesIdeal
o42 = reesIdeal -- Compute the defining ideal of the Rees Algebra
***********************************************************
Synopsis
========
* Usage: reesIdeal MreesIdeal(M,f)
* Inputs:
* M, a module, or an ideal of a quotient polynomial ring $R$
* f, a ring element, any non-zerodivisor in ideal or the first Fitting ideal of the module.
Optional
* Optional inputs:
* BasisElementLimit => ...,
* DegreeLimit => ..., -- Bound the degrees considered in the saturation step. Defaults to infinity
* Jacobian => ...,
* MinimalGenerators => ..., -- Whether the saturation step returns minimal generators
* PairLimit => ..., -- Bound the number of s-pairs considered in the saturation step
* Strategy => ..., -- Choose a strategy for the saturation step
* Variable => ...,
* Outputs:
* an ideal, defining the Rees algebra of M
Description
===========
This routine gives the user a choice between two methods for finding the defining ideal of the Rees
algebra of an ideal or module $M$ over a ring $R$: The command {\tt reesIdeal(M)} computes a versal
embedding $g: M\to G$ and a surjection $f: F\to M$ and returns the result of symmetricKernel(gf).
When M is an ideal (the usual case) or in characteristic 0, the same ideal can be computed by an
alternate method that is often faster. If the user knows a non-zerodivisor $a\in{} R$ such that
$M[a^{-1}$ is a free module (for example, when M is an ideal, any non-zerodivisor $a \in{} M$ then it is
often much faster to compute {\tt reesIdeal(M,a)} which computes the saturation of the defining ideal of
the symmetric algebra of M with respect to a. This gives the correct answer even under the slightly
weaker hypothesis that $M[a^{-1}]$ is {\em of linear type}. (See also "isLinearType".)
+-----------------------------------------------------------------------------+
|i1 : kk = ZZ/101; |
+-----------------------------------------------------------------------------+
|i2 : S=kk[x_0..x_4]; |
+-----------------------------------------------------------------------------+
|i3 : i= trim monomialCurveIdeal(S,{2,3,5,6}) |
| |
| 2 3 2 2 2 2 |
|o3 = ideal (x x - x x , x - x x , x x - x x , x - x x , x x - x x , x x |
| 2 3 1 4 2 0 4 1 2 0 3 3 2 4 1 3 0 4 1 3|
| ------------------------------------------------------------------------|
| 3 2 |
| - x x x , x - x x ) |
| 0 2 4 1 0 4 |
| |
|o3 : Ideal of S |
+-----------------------------------------------------------------------------+
|i4 : time V1 = reesIdeal i; |
| -- used 0.0268453 seconds |
| |
|o4 : Ideal of S[w , w , w , w , w , w , w ] |
| 0 1 2 3 4 5 6 |
+-----------------------------------------------------------------------------+
|i5 : time V2 = reesIdeal(i,i_0); |
| -- used 0.0937453 seconds |
| |
|o5 : Ideal of S[w , w , w , w , w , w , w ] |
| 0 1 2 3 4 5 6 |
+-----------------------------------------------------------------------------+
The following example shows how we handle degrees
+---------------------------------------------------+
|i6 : S=kk[a,b,c] |
| |
|o6 = S |
| |
|o6 : PolynomialRing |
+---------------------------------------------------+
|i7 : m=matrix{{a,0},{b,a},{0,b}} |
| |
|o7 = | a 0 | |
| | b a | |
| | 0 b | |
| |
| 3 2 |
|o7 : Matrix S <--- S |
+---------------------------------------------------+
|i8 : i=minors(2,m) |
| |
| 2 2 |
|o8 = ideal (a , a*b, b ) |
| |
|o8 : Ideal of S |
+---------------------------------------------------+
|i9 : time I1 = reesIdeal i; |
| -- used 0.0133745 seconds |
| |
|o9 : Ideal of S[w , w , w ] |
| 0 1 2 |
+---------------------------------------------------+
|i10 : time I2 = reesIdeal(i,i_0); |
| -- used 0.003947 seconds |
| |
|o10 : Ideal of S[w , w , w ] |
| 0 1 2 |
+---------------------------------------------------+
|i11 : transpose gens I1 |
| |
|o11 = {-1, -3} | aw_1-bw_2 | |
| {-1, -3} | aw_0-bw_1 | |
| {-2, -4} | w_1^2-w_0w_2 | |
| |
| 3 1|
|o11 : Matrix (S[w , w , w ]) <--- (S[w , w , w ]) |
| 0 1 2 0 1 2 |
+---------------------------------------------------+
|i12 : transpose gens I2 |
| |
|o12 = {-1, -3} | aw_1-bw_2 | |
| {-1, -3} | aw_0-bw_1 | |
| {-2, -4} | w_1^2-w_0w_2 | |
| |
| 3 1|
|o12 : Matrix (S[w , w , w ]) <--- (S[w , w , w ]) |
| 0 1 2 0 1 2 |
+---------------------------------------------------+
{\bf Investigating plane curve singularities:}
Proj of the Rees algebra of I \subset{} R is the blowup of I in spec R. Thus the Rees algebra is a basic
construction in resolution of singularities. Here we work out a simple case:
+-----------------------------------------------------------------------------------------------------------------------------+
|i13 : R = ZZ/32003[x,y] |
| |
|o13 = R |
| |
|o13 : PolynomialRing |
+-----------------------------------------------------------------------------------------------------------------------------+
|i14 : I = ideal(x,y) |
| |
|o14 = ideal (x, y) |
| |
|o14 : Ideal of R |
+-----------------------------------------------------------------------------------------------------------------------------+
|i15 : cusp = ideal(x^2-y^3) |
| |
| 3 2 |
|o15 = ideal(- y + x ) |
| |
|o15 : Ideal of R |
+-----------------------------------------------------------------------------------------------------------------------------+
|i16 : RI = reesIdeal(I) |
| |
|o16 = ideal(x*w - y*w ) |
| 0 1 |
| |
|o16 : Ideal of R[w , w ] |
| 0 1 |
+-----------------------------------------------------------------------------------------------------------------------------+
|i17 : S = ring RI |
| |
|o17 = S |
| |
|o17 : PolynomialRing |
+-----------------------------------------------------------------------------------------------------------------------------+
|i18 : totalTransform = substitute(cusp, S) + RI |
| |
| 3 2 |
|o18 = ideal (- y + x , x*w - y*w ) |
| 0 1 |
| |
|o18 : Ideal of S |
+-----------------------------------------------------------------------------------------------------------------------------+
|i19 : D = decompose totalTransform -- the components are the strict transform of the cuspidal curve and the exceptional curve|
| |
| 3 2 2 2 2 |
|o19 = {ideal (x*w - y*w , y - x , y w - x*w , y*w - w ), ideal (y, x)} |
| 0 1 0 1 0 1 |
| |
|o19 : List |
+-----------------------------------------------------------------------------------------------------------------------------+
|i20 : totalTransform = first flattenRing totalTransform |
| |
| 3 2 |
|o20 = ideal (- y + x , w x - w y) |
| 0 1 |
| |
| ZZ |
|o20 : Ideal of -----[w , w , x, y] |
| 32003 0 1 |
+-----------------------------------------------------------------------------------------------------------------------------+
|i21 : L = primaryDecomposition totalTransform |
| |
| 3 2 2 2 2 2 2 |
|o21 = {ideal (w x - w y, y - x , w y - w x, w y - w ), ideal (y , x*y, x , |
| 0 1 0 1 0 1 |
| ----------------------------------------------------------------------- |
| w x - w y)} |
| 0 1 |
| |
|o21 : List |
+-----------------------------------------------------------------------------------------------------------------------------+
|i22 : apply(L, i -> (degree i)/(degree radical i)) |
| |
|o22 = {1, 2} |
| |
|o22 : List |
+-----------------------------------------------------------------------------------------------------------------------------+
The total transform of the cusp contains the exceptional divisor with multiplicity two. The strict
transform of the cusp is a smooth curve but is tangent to the exceptional divisor
+-------------------------------------------+
|i23 : use ring L_0 |
| |
| ZZ |
|o23 = -----[w , w , x, y] |
| 32003 0 1 |
| |
|o23 : PolynomialRing |
+-------------------------------------------+
|i24 : singular = ideal(singularLocus(L_0));|
| |
| ZZ |
|o24 : Ideal of -----[w , w , x, y] |
| 32003 0 1 |
+-------------------------------------------+
|i25 : SL = saturate(singular, ideal(x,y)); |
| |
| ZZ |
|o25 : Ideal of -----[w , w , x, y] |
| 32003 0 1 |
+-------------------------------------------+
|i26 : saturate(SL, ideal(w_0,w_1)) |
| |
|o26 = ideal 1 |
| |
| ZZ |
|o26 : Ideal of -----[w , w , x, y] |
| 32003 0 1 |
+-------------------------------------------+
This shows that the strict transform is smooth.
See also
========
* "symmetricKernel" -- Compute the Rees ring of the image of a matrix
* "reesAlgebra" -- Compute the defining ideal of the Rees Algebra
Ways to use reesIdeal :
=======================
* reesIdeal(Ideal)
* reesIdeal(Ideal,RingElement)
* reesIdeal(Module)
* reesIdeal(Module,RingElement)
o42 : DIV
i43 : "asd"_0
o43 = a
i44 : class oo
o44 = String
o44 : Type
i45 : QQ["asdf"]
o45 = QQ[asdf]
o45 : PolynomialRing
i46 : asdf
o46 = asdf
o46 : QQ[asdf]
i47 : s_"asdf"
o47 = s
asdf
o47 : IndexedVariable
i48 : QQ[s_"asdf"]
o48 = QQ[s ]
asdf
o48 : PolynomialRing
i49 : "asdf"_"asdf"
stdio:49:7:(3): error: no method for binary operator _ applied to objects:
-- "asdf" (of class String)
-- _ "asdf" (of class String)
i50 : "a" .. "z"
o50 = (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t, u, v, w, x, y, z)
o50 : Sequence
i51 : QQ[s_"a" .. s_"z"]
o51 = QQ[s , s , s , s , s , s , s , s , s , s , s , s , s , s , s , s , s , s , s , s , s , s , s , s , s , s ]
a b c d e f g h i j k l m n o p q r s t u v w x y z
o51 : PolynomialRing
i52 : QQ[s_"aa" .. s_"dd"]
o52 = QQ[s , s , s , s , s , s , s , s , s , s , s , s , s , s , s , s ]
aa ab ac ad ba bb bc bd ca cb cc cd da db dc dd
o52 : PolynomialRing
Q4. This question involved the sort order for keys in tables being printed, as here:
i54 : -7 .. 7
o54 = (-7, -6, -5, -4, -3, -2, -1, 0, 1, 2, 3, 4, 5, 6, 7)
o54 : Sequence
i56 : toList oo
o56 = {-7, -6, -5, -4, -3, -2, -1, 0, 1, 2, 3, 4, 5, 6, 7}
o56 : List
i57 : tally oo
o57 = Tally{-1 => 1}
-2 => 1
-3 => 1
-4 => 1
-5 => 1
-6 => 1
-7 => 1
0 => 1
1 => 1
2 => 1
3 => 1
4 => 1
5 => 1
6 => 1
7 => 1
o57 : Tally
Notice that the keys in the tally displayed above appear in string-sorting order, not in numerical order. This led to the creation of another issue: https://github.com/Macaulay2/M2/issues/1004
Q5. Please describe describe.
The idea of describe is twofold: to bypass the printing just of the symbol name to which the object has been assigned; and to show more information to the user in mathematician-readable form. (The function peek shows everything inside an object, and is of interest mainly to programmers.) Read about describe at https://faculty.math.illinois.edu/Macaulay2/doc/Macaulay2-1.14/share/doc/Macaulay2/Macaulay2Doc/html/_describe.html .
i64 : viewHelp describe
i65 : R = QQ[x]
o65 = R
o65 : PolynomialRing
i66 : R
o66 = R
o66 : PolynomialRing
i67 : describe R
o67 = QQ[x, Degrees => {1}, Heft => {1}, MonomialOrder => {MonomialSize => 32}, DegreeRank => 1]
{GRevLex => {1} }
{Position => Up }
i68 : methods describe
o68 = {0 => (describe, AffineVariety) }
{1 => (describe, CoherentSheaf) }
{2 => (describe, FractionField) }
{3 => (describe, GaloisField) }
{4 => (describe, GeneralOrderedMonoid)}
{5 => (describe, LocalRing) }
{6 => (describe, Matrix) }
{7 => (describe, Module) }
{8 => (describe, PolynomialRing) }
{9 => (describe, ProjectiveVariety) }
{10 => (describe, QuotientRing) }
{11 => (describe, RingMap) }
{12 => (describe, Thing) }
o68 : NumberedVerticalList
Q6. Please talk about about.
The purpose of this function is to search the documentation for entries that match a "regular expression". Read about regular expressions at https://faculty.math.illinois.edu/Macaulay2/doc/Macaulay2-1.14/share/doc/Macaulay2/Macaulay2Doc/html/_regular_spexpressions.html . Read about about at file:///Applications/Macaulay2-1.14/share/doc/Macaulay2/Macaulay2Doc/html/_about.html .
i69 : viewHelp about
i70 : about "resolution"
o70 = {0 => ChainComplexExtras::resolution(ChainComplex) }
{1 => ChainComplexExtras::resolutionOfChainComplex }
{2 => ChainComplexExtras::resolutionOfChainComplex(..., LengthLimit => ...)}
{3 => ChainComplexExtras::resolutionOfChainComplex(ChainComplex) }
{4 => Dmodules::Dresolution }
{5 => Dmodules::Dresolution(..., LengthLimit => ...) }
{6 => Dmodules::Dresolution(..., Strategy => ...) }
{7 => Dmodules::Dresolution(Ideal) }
{8 => Dmodules::Dresolution(Ideal,List) }
{9 => Dmodules::Dresolution(Module) }
{10 => Dmodules::Dresolution(Module,List) }
{11 => Macaulay2Doc::computing resolutions }
{12 => Macaulay2Doc::free resolutions of modules }
{13 => Macaulay2Doc::Hilbert functions and free resolutions }
{14 => Macaulay2Doc::resolution }
{15 => Macaulay2Doc::resolution(..., DegreeLimit => ...) }
{16 => Macaulay2Doc::resolution(..., FastNonminimal => ...) }
{17 => Macaulay2Doc::resolution(..., HardDegreeLimit => ...) }
{18 => Macaulay2Doc::resolution(..., LengthLimit => ...) }
{19 => Macaulay2Doc::resolution(..., PairLimit => ...) }
{20 => Macaulay2Doc::resolution(..., SortStrategy => ...) }
{21 => Macaulay2Doc::resolution(..., StopBeforeComputation => ...) }
{22 => Macaulay2Doc::resolution(..., Strategy => ...) }
{23 => Macaulay2Doc::resolution(..., SyzygyLimit => ...) }
{24 => Macaulay2Doc::resolution(Ideal) }
{25 => Macaulay2Doc::resolution(Matrix) }
{26 => Macaulay2Doc::resolution(Module) }
{27 => Macaulay2Doc::resolution(MonomialIdeal) }
{28 => NCAlgebra::resolution(NCMatrix) }
{29 => Posets::resolutionPoset }
{30 => Posets::resolutionPoset(ChainComplex) }
{31 => Posets::resolutionPoset(Ideal) }
{32 => Posets::resolutionPoset(MonomialIdeal) }
o70 : NumberedVerticalList
i71 : about ("resolution", Body => true)
o71 = {0 => BeginningMacaulay2::BeginningMacaulay2 }
{1 => BGG::BGG }
{2 => BGG::directImageComplex(ChainComplex) }
{3 => BGG::directImageComplex(Matrix) }
{4 => BGG::pureResolution }
{5 => BGG::tateResolution }
{6 => BoijSoederberg::BoijSoederberg }
{7 => BoijSoederberg::facetEquation(List,ZZ,ZZ,ZZ) }
{8 => BoijSoederberg::makePureBetti(List) }
{9 => BoijSoederberg::pureAll }
{10 => BoijSoederberg::pureBetti(List) }
{11 => BoijSoederberg::pureCharFree }
{12 => BoijSoederberg::pureTwoInvariant }
{13 => BoijSoederberg::pureWeyman }
{14 => BoijSoederberg::randomSocleModule(List,ZZ) }
{15 => Bruns::bruns }
{16 => ChainComplexExtras::cartanEilenbergResolution }
{17 => ChainComplexExtras::isExact(..., LengthLimit => ...) }
{18 => ChainComplexExtras::isQuasiIsomorphism(..., LengthLimit => ...) }
{19 => ChainComplexExtras::resolution(ChainComplex) }
{20 => ChainComplexExtras::resolutionOfChainComplex }
{21 => ChainComplexExtras::resolutionOfChainComplex(..., LengthLimit => ...) }
{22 => ChainComplexExtras::resolutionOfChainComplex(ChainComplex) }
{23 => ChainComplexExtras::taylor }
{24 => ChainComplexExtras::taylorResolution }
{25 => ChainComplexOperations::ChainComplexOperations }
{26 => CompleteIntersectionResolutions::CompleteIntersectionResolutions }
{27 => CompleteIntersectionResolutions::complexity }
{28 => CompleteIntersectionResolutions::EisenbudShamash }
{29 => CompleteIntersectionResolutions::expo }
{30 => CompleteIntersectionResolutions::exteriorExtModule }
{31 => CompleteIntersectionResolutions::exteriorTorModule }
{32 => CompleteIntersectionResolutions::ExtModuleData }
{33 => CompleteIntersectionResolutions::extVsCohomology }
{34 => CompleteIntersectionResolutions::finiteBettiNumbers }
{35 => CompleteIntersectionResolutions::highSyzygy }
{36 => CompleteIntersectionResolutions::infiniteBettiNumbers }
{37 => CompleteIntersectionResolutions::koszulExtension }
{38 => CompleteIntersectionResolutions::layeredResolution }
{39 => CompleteIntersectionResolutions::makeFiniteResolution }
{40 => CompleteIntersectionResolutions::makeFiniteResolutionCodim2 }
{41 => CompleteIntersectionResolutions::matrixFactorization }
{42 => CompleteIntersectionResolutions::moduleAsExt }
{43 => CompleteIntersectionResolutions::Shamash }
{44 => CompleteIntersectionResolutions::TateResolution }
{45 => Complexes::betti(Complex) }
{46 => Complexes::cone(ComplexMap) }
{47 => Complexes::HH Complex }
{48 => Complexes::isExact }
{49 => Complexes::isFree(Complex) }
{50 => Complexes::isWellDefined(Complex) }
{51 => Complexes::length(Complex) }
{52 => CorrespondenceScrolls::multiHilbertPolynomial }
{53 => DGAlgebras::Basic operations on DG Algebras }
{54 => DGAlgebras::toComplex(DGAlgebra,ZZ) }
{55 => Dmodules::Ddual }
{56 => Dmodules::deRham(..., Strategy => ...) }
{57 => Dmodules::deRhamAll(..., Strategy => ...) }
{58 => Dmodules::DExt(..., Strategy => ...) }
{59 => Dmodules::DHom(..., Strategy => ...) }
{60 => Dmodules::Dintegration(..., Strategy => ...) }
{61 => Dmodules::DintegrationIdeal(..., Strategy => ...) }
{62 => Dmodules::Dmodules }
{63 => Dmodules::Dres }
{64 => Dmodules::Dres(..., LengthLimit => ...) }
{65 => Dmodules::Dres(..., Strategy => ...) }
{66 => Dmodules::Dresolution }
{67 => Dmodules::Dresolution(..., LengthLimit => ...) }
{68 => Dmodules::Dresolution(..., Strategy => ...) }
{69 => Dmodules::Dresolution(Ideal) }
{70 => Dmodules::Dresolution(Ideal,List) }
{71 => Dmodules::Dresolution(Module) }
{72 => Dmodules::Dresolution(Module,List) }
{73 => Dmodules::Drestriction }
{74 => Dmodules::PolyExt(..., Strategy => ...) }
{75 => Dmodules::RatExt }
{76 => Dmodules::RatExt(..., Strategy => ...) }
{77 => Dmodules::Schreyer }
{78 => Dmodules::Vhomogenize }
{79 => EdgeIdeals::isChordal }
{80 => EdgeIdeals::isSCM }
{81 => EdgeIdeals::smallestCycleSize }
{82 => EliminationMatrices::byResolution }
{83 => EliminationMatrices::ciResidual }
{84 => EliminationMatrices::EliminationMatrices }
{85 => EliminationMatrices::eliminationMatrix }
{86 => EliminationMatrices::eliminationMatrix(List,Matrix,Matrix) }
{87 => EliminationMatrices::regularityVar }
{88 => FiniteFittingIdeals::co1Fitting }
{89 => FiniteFittingIdeals::nextDegree }
{90 => FourierMotzkin::Applications to multigraded polynomial rings }
{91 => HigherCIOperators::ciOperatorResolution }
{92 => HigherCIOperators::HigherCIOperators }
{93 => HigherCIOperators::higherCIOperators }
{94 => HigherCIOperators::makeALDifferential }
{95 => HighestWeights::Example 1 }
{96 => HighestWeights::Example 2 }
{97 => HighestWeights::Example 3 }
{98 => HighestWeights::Example 4 }
{99 => HighestWeights::Example 5 }
{100 => HighestWeights::Example 6 }
{101 => HighestWeights::Example 7 }
{102 => HighestWeights::HighestWeights }
{103 => HighestWeights::highestWeightsDecomposition(ChainComplex,ZZ,List) }
{104 => HighestWeights::propagateWeights }
{105 => HighestWeights::propagateWeights(Matrix,List) }
{106 => HyperplaneArrangements::EPY }
{107 => InvolutiveBases::Involutive }
{108 => InvolutiveBases::InvolutiveBases }
{109 => InvolutiveBases::janetBasis }
{110 => InvolutiveBases::janetResolution }
{111 => InvolutiveBases::multVar }
{112 => InvolutiveBases::multVars }
{113 => K3Carpets::allGradings }
{114 => K3Carpets::analyzeStrand }
{115 => K3Carpets::canonicalHomotopies }
{116 => K3Carpets::carpetBettiTable }
{117 => K3Carpets::carpetBettiTables }
{118 => K3Carpets::carpetDet }
{119 => K3Carpets::computeBound }
{120 => K3Carpets::degenerateK3BettiTables }
{121 => K3Carpets::gorensteinDouble }
{122 => K3Carpets::K3Carpets }
{123 => K3Carpets::relativeResolution }
{124 => K3Carpets::relativeResolutionTwists }
{125 => K3Carpets::resonanceDet }
{126 => K3Carpets::schreyerName }
{127 => KustinMiller::Cyclic Polytopes }
{128 => KustinMiller::isExactRes }
{129 => KustinMiller::Jerry }
{130 => KustinMiller::KustinMiller }
{131 => KustinMiller::kustinMillerComplex }
{132 => KustinMiller::resBE }
{133 => KustinMiller::Stellar Subdivisions }
{134 => KustinMiller::Tom }
{135 => LexIdeals::cancelAll }
{136 => LexIdeals::LPP }
{137 => LexIdeals::multBounds }
{138 => LexIdeals::multLowerBound }
{139 => LexIdeals::multUpperBound }
{140 => LexIdeals::multUpperHF }
{141 => LocalRings::LocalRings }
{142 => Macaulay2Doc::a first Macaulay2 session }
{143 => Macaulay2Doc::betti }
{144 => Macaulay2Doc::betti(..., Minimize => ...) }
{145 => Macaulay2Doc::betti(BettiTally) }
{146 => Macaulay2Doc::betti(GradedModule) }
{147 => Macaulay2Doc::betti(GroebnerBasis) }
{148 => Macaulay2Doc::betti(Ideal) }
{149 => Macaulay2Doc::betti(Matrix) }
{150 => Macaulay2Doc::betti(Module) }
{151 => Macaulay2Doc::chain complexes }
{152 => Macaulay2Doc::ChainComplex }
{153 => Macaulay2Doc::ChainComplex ++ ChainComplex }
{154 => Macaulay2Doc::ChainComplex _ ZZ }
{155 => Macaulay2Doc::ChainComplexMap _ ZZ }
{156 => Macaulay2Doc::changes, 1.0 and 1.1 }
{157 => Macaulay2Doc::changes, 1.6 }
{158 => Macaulay2Doc::changes, 1.7 }
{159 => Macaulay2Doc::changes, 1.8 }
{160 => Macaulay2Doc::changes, 1.9 }
{161 => Macaulay2Doc::changes, 1.9.1 }
{162 => Macaulay2Doc::changes, 1.10 }
{163 => Macaulay2Doc::changes, 1.11 }
{164 => Macaulay2Doc::changes, 1.12 }
{165 => Macaulay2Doc::changes, 1.13 }
{166 => Macaulay2Doc::complete }
{167 => Macaulay2Doc::complete(ChainComplex) }
{168 => Macaulay2Doc::computing resolutions }
{169 => Macaulay2Doc::cone(ChainComplexMap) }
{170 => Macaulay2Doc::David Eisenbud }
{171 => Macaulay2Doc::dd }
{172 => Macaulay2Doc::document }
{173 => Macaulay2Doc::document(..., Inputs => ...) }
{174 => Macaulay2Doc::document(..., Key => ...) }
{175 => Macaulay2Doc::document(..., Outputs => ...) }
{176 => Macaulay2Doc::documentation keys }
{177 => Macaulay2Doc::eagonNorthcott(Matrix) }
{178 => Macaulay2Doc::Elementary uses of Groebner bases I. Math 634 Fall 2005 }
{179 => Macaulay2Doc::engine }
{180 => Macaulay2Doc::Ext^ZZ(CoherentSheaf,CoherentSheaf) }
{181 => Macaulay2Doc::Ext^ZZ(CoherentSheaf,SumOfTwists) }
{182 => Macaulay2Doc::Ext^ZZ(Matrix,Module) }
{183 => Macaulay2Doc::Ext^ZZ(Module,Matrix) }
{184 => Macaulay2Doc::Ext^ZZ(Module,Module) }
{185 => Macaulay2Doc::extend(ChainComplex,ChainComplex,Matrix) }
{186 => Macaulay2Doc::extracting information from chain complexes }
{187 => Macaulay2Doc::factor }
{188 => Macaulay2Doc::FastNonminimal }
{189 => Macaulay2Doc::findSynonyms(Symbol) }
{190 => Macaulay2Doc::frac }
{191 => Macaulay2Doc::free resolutions of modules }
{192 => Macaulay2Doc::gbTrace }
{193 => Macaulay2Doc::getNonUnit }
{194 => Macaulay2Doc::graded and multigraded polynomial rings }
{195 => Macaulay2Doc::heft }
{196 => Macaulay2Doc::HH^ZZ CoherentSheaf }
{197 => Macaulay2Doc::Hilbert functions and free resolutions }
{198 => Macaulay2Doc::Hom(Module,ChainComplex) }
{199 => Macaulay2Doc::Ideal }
{200 => Macaulay2Doc::ideals }
{201 => Macaulay2Doc::ideals to and from modules }
{202 => Macaulay2Doc::LengthLimit }
{203 => Macaulay2Doc::lift }
{204 => Macaulay2Doc::maps between chain complexes }
{205 => Macaulay2Doc::methods }
{206 => Macaulay2Doc::minimalBetti(Ideal) }
{207 => Macaulay2Doc::Module }
{208 => Macaulay2Doc::modules }
{209 => Macaulay2Doc::modules in Macaulay2 }
{210 => Macaulay2Doc::nullhomotopy }
{211 => Macaulay2Doc::packages provided with Macaulay2 }
{212 => Macaulay2Doc::path }
{213 => Macaulay2Doc::pdim }
{214 => Macaulay2Doc::peek'(ZZ,Thing) }
{215 => Macaulay2Doc::pseudocode }
{216 => Macaulay2Doc::regularity }
{217 => Macaulay2Doc::replacements for commands and scripts from Macaulay }
{218 => Macaulay2Doc::Resolution }
{219 => Macaulay2Doc::resolution }
{220 => Macaulay2Doc::resolution(..., DegreeLimit => ...) }
{221 => Macaulay2Doc::resolution(..., FastNonminimal => ...) }
{222 => Macaulay2Doc::resolution(..., HardDegreeLimit => ...) }
{223 => Macaulay2Doc::resolution(..., LengthLimit => ...) }
{224 => Macaulay2Doc::resolution(..., PairLimit => ...) }
{225 => Macaulay2Doc::resolution(..., SortStrategy => ...) }
{226 => Macaulay2Doc::resolution(..., StopBeforeComputation => ...) }
{227 => Macaulay2Doc::resolution(..., Strategy => ...) }
{228 => Macaulay2Doc::resolution(..., SyzygyLimit => ...) }
{229 => Macaulay2Doc::resolution(Ideal) }
{230 => Macaulay2Doc::resolution(Matrix) }
{231 => Macaulay2Doc::resolution(Module) }
{232 => Macaulay2Doc::resolution(MonomialIdeal) }
{233 => Macaulay2Doc::RingMap RingElement }
{234 => Macaulay2Doc::running Macaulay2 in emacs }
{235 => Macaulay2Doc::Schreyer orders }
{236 => Macaulay2Doc::Singular Book 2.4.12 }
{237 => Macaulay2Doc::Singular Book 2.4.15 }
{238 => Macaulay2Doc::Singular Book 2.5.18 }
{239 => Macaulay2Doc::source(ChainComplexMap) }
{240 => Macaulay2Doc::status }
{241 => Macaulay2Doc::syzygyScheme }
{242 => Macaulay2Doc::target(ChainComplexMap) }
{243 => Macaulay2Doc::Tutorial: Canonical Embeddings of Plane Curves and Gonality}
{244 => Macaulay2Doc::Tutorial: Elementary uses of Groebner bases }
{245 => Macaulay2Doc::Tutorial: Fano varieties }
{246 => Macaulay2Doc::two dimensional formatting }
{247 => Macaulay2Doc::Usage }
{248 => Macaulay2Doc::using Macaulay2 with emacs after it has been set up }
{249 => MCMApproximations::approximation }
{250 => MCMApproximations::MCMApproximations }
{251 => MCMApproximations::syzygyModule }
{252 => MultiplierIdealsDim2::MultiplierIdealsDim2 }
{253 => MultiplierIdealsDim2::RelativeCanonicalDivisor }
{254 => NCAlgebra::Basic operations on noncommutative algebras }
{255 => NCAlgebra::betti(NCChainComplex) }
{256 => NCAlgebra::NCChainComplex }
{257 => NCAlgebra::NCMatrix // NCMatrix }
{258 => NCAlgebra::resolution(NCMatrix) }
{259 => NCAlgebra::rightKernel }
{260 => NCAlgebra::Using the Bergman interface }
{261 => NonminimalComplexes::SVDBetti }
{262 => NormalToricVarieties::makeSmooth(NormalToricVariety) }
{263 => NormalToricVarieties::Making normal toric varieties }
{264 => NormalToricVarieties::Resolution of singularities }
{265 => PieriMaps::pieri }
{266 => PieriMaps::PieriMaps }
{267 => PieriMaps::pureFree }
{268 => Points::expectedBetti }
{269 => Points::minMaxResolution }
{270 => Points::Points }
{271 => Posets::Example: Constructing common posets }
{272 => Posets::Example: Hibi ideals }
{273 => Posets::Example: LCM-lattices }
{274 => Posets::lcmLattice }
{275 => Posets::resolutionPoset }
{276 => Posets::resolutionPoset(ChainComplex) }
{277 => Posets::resolutionPoset(Ideal) }
{278 => Posets::resolutionPoset(MonomialIdeal) }
{279 => PrimaryDecomposition::primaryDecomposition(..., Strategy => ...) }
{280 => PruneComplex::PruneComplex }
{281 => PruneComplex::pruneComplex }
{282 => PruneComplex::toChainComplex }
{283 => RandomMonomialIdeals::bettiStats }
{284 => RandomSpaceCurves::knownUnirationalComponentOfSpaceCurves }
{285 => RandomSpaceCurves::spaceCurve }
{286 => ReesAlgebra::PlaneCurveSingularities }
{287 => ReesAlgebra::ReesAlgebra }
{288 => ReesAlgebra::reesIdeal }
{289 => Regularity::Regularity }
{290 => RelativeCanonicalResolution::eagonNorthcottType }
{291 => RelativeCanonicalResolution::iteratedMC }
{292 => RelativeCanonicalResolution::liftMatrixToENT }
{293 => RelativeCanonicalResolution::RelativeCanonicalResolution }
{294 => RelativeCanonicalResolution::resCurveOnScroll }
{295 => RelativeCanonicalResolution::rkSyzModules }
{296 => SchurRings::schurResolution }
{297 => SchurRings::schurResolution(..., DegreeLimit => ...) }
{298 => SchurRings::schurResolution(..., SyzygyLimit => ...) }
{299 => SchurRings::SchurRings }
{300 => SimplicialComplexes::lyubeznikComplex }
{301 => SimplicialComplexes::superficialComplex }
{302 => SLnEquivariantMatrices::SLnEquivariantMatrices }
{303 => SpectralSequences::basis(List,SpectralSequencePage) }
{304 => SpectralSequences::hilbertPolynomial(SpectralSequencePage) }
{305 => SpectralSequences::minimalPresentation(SpectralSequence) }
{306 => SpectralSequences::minimalPresentation(SpectralSequencePage) }
{307 => SpectralSequences::Page }
{308 => SpectralSequences::PageMap }
{309 => SpectralSequences::pruningMaps }
{310 => SpectralSequences::pruningMaps(SpectralSequencePage) }
{311 => SpectralSequences::Spectral sequences and hypercohomology calculations }
{312 => SpectralSequences::SpectralSequence ^ ZZ }
{313 => SpectralSequences::SpectralSequence _ ZZ }
{314 => SpectralSequences::spectralSequencePage(FilteredComplex,ZZ) }
{315 => SpectralSequences::SpectralSequencePageMap ^ List }
{316 => SpectralSequences::SpectralSequencePageMap _ List }
{317 => TateOnProducts::beilinson }
{318 => TateOnProducts::beilinsonWindow }
{319 => TateOnProducts::coarseMultigradedRegularity }
{320 => TateOnProducts::cohomologyHashTable }
{321 => TateOnProducts::cohomologyMatrix }
{322 => TateOnProducts::composedFunctions }
{323 => TateOnProducts::cornerComplex }
{324 => TateOnProducts::eulerPolynomialTable }
{325 => TateOnProducts::firstQuadrantComplex }
{326 => TateOnProducts::lastQuadrantComplex }
{327 => TateOnProducts::strand }
{328 => TateOnProducts::tateExtension }
{329 => TateOnProducts::TateOnProducts }
{330 => TateOnProducts::tateResolution }
{331 => TensorComplexes::flattenedESTensor }
{332 => TensorComplexes::pureResES }
{333 => TensorComplexes::pureResES1 }
{334 => TensorComplexes::pureResTC }
{335 => TensorComplexes::pureResTC1 }
{336 => TensorComplexes::tensorComplex1 }
{337 => TensorComplexes::TensorComplexes }
{338 => TestIdeals::isCohenMacaulay }
{339 => Text::html(TEX) }
{340 => Text::MarkUpTypeWithOptions }
{341 => TorAlgebra::TorAlgebra }
{342 => Triplets::Triplet }
{343 => Triplets::Triplets }
{344 => VectorFields::isFreeDivisor }
{345 => VersalDeformations::versalDeformation }
{346 => VirtualResolutions::isVirtual }
{347 => VirtualResolutions::isVirtual(..., Strategy => ...) }
{348 => VirtualResolutions::resolveViaFatPoint }
{349 => VirtualResolutions::virtualOfPair }
{350 => VirtualResolutions::VirtualResolutions }
o71 : NumberedVerticalList
i72 : help 341
o72 = TorAlgebra::TorAlgebra -- Classification of local rings based on multiplication in homology
*******************************************************************************************
Let $I$ be an ideal of a regular local ring $Q$ with residue field $k$. The minimal free resolution of
$R=Q/I$ carries a structure of a differential graded algebra. If the length of the resolution, which is
called the codepth of $R$, is at most $3$, then the induced algebra structure on Tor$_Q*$ ($R,k$) is
unique and provides for a classification of such local rings.
According to the multiplicative structure on Tor$_Q*$ ($R,k$), a non-zero local ring $R$ of codepth at
most 3 belongs to exactly one of the (parametrized) classes designated {\bf B}, {\bf C}(c), {\bf G}(r),
{\bf H}(p,q), {\bf S}, or {\bf T}. An overview of the theory can be found in L.L. Avramov, {\it A
cohomological study of local rings of embedding codepth 3}, http://arxiv.org/abs/1105.3991.
There is a similar classification of Gorenstein local rings of codepth 4, due to A.R. Kustin and M.
Miller. There are four classes, which in the original paper, {\it Classification of the Tor-Algebras of
Codimension Four Gorenstein Local rings} https://doi.org/10.1007/BF01215134, are called A, B, C, and D,
while in the survey {\it Homological asymptotics of modules over local rings}
https://doi.org/10.1007/978-1-4612-3660-3_3 by L.L. Avramov, they are called CI, GGO, GTE, and GH(p),
respectively. Here we denote these classes {\bf C}(c), {\bf GS}, {\bf GT}, and {\bf GH}(p), respectively.
The package implements an algorithm for classification of local rings in the sense discussed above. For
rings of codepth at most 3 it is described in L.W. Christensen and O. Veliche, {\it Local rings of
embedding codepth 3: a classification algorithm}, http://arxiv.org/abs/1402.4052. The classification of
Gorenstein rings of codepth 4 is analogous.
The package also recognizes Golod rings, Gorenstein rings, and complete intersection rings of any
codepth. To recognize Golod rings the package implements a test found in J. Burke, {\it Higher homotopies
and Golod rings} https://arxiv.org/abs/1508.03782.
o72 : DIV
i73 : about ("res...tion", Body => true)
o73 = {0 => BeginningMacaulay2::BeginningMacaulay2 }
{1 => BGG::BGG }
{2 => BGG::directImageComplex(ChainComplex) }
{3 => BGG::directImageComplex(Matrix) }
{4 => BGG::pureResolution }
{5 => BGG::tateResolution }
{6 => BoijSoederberg::BoijSoederberg }
{7 => BoijSoederberg::facetEquation(List,ZZ,ZZ,ZZ) }
{8 => BoijSoederberg::makePureBetti(List) }
{9 => BoijSoederberg::pureAll }
{10 => BoijSoederberg::pureBetti(List) }
{11 => BoijSoederberg::pureCharFree }
{12 => BoijSoederberg::pureTwoInvariant }
{13 => BoijSoederberg::pureWeyman }
{14 => BoijSoederberg::randomSocleModule(List,ZZ) }
{15 => Bruns::bruns }
{16 => ChainComplexExtras::cartanEilenbergResolution }
{17 => ChainComplexExtras::isExact(..., LengthLimit => ...) }
{18 => ChainComplexExtras::isQuasiIsomorphism(..., LengthLimit => ...) }
{19 => ChainComplexExtras::resolution(ChainComplex) }
{20 => ChainComplexExtras::resolutionOfChainComplex }
{21 => ChainComplexExtras::resolutionOfChainComplex(..., LengthLimit => ...) }
{22 => ChainComplexExtras::resolutionOfChainComplex(ChainComplex) }
{23 => ChainComplexExtras::taylor }
{24 => ChainComplexExtras::taylorResolution }
{25 => ChainComplexOperations::ChainComplexOperations }
{26 => CompleteIntersectionResolutions::CompleteIntersectionResolutions }
{27 => CompleteIntersectionResolutions::complexity }
{28 => CompleteIntersectionResolutions::EisenbudShamash }
{29 => CompleteIntersectionResolutions::expo }
{30 => CompleteIntersectionResolutions::exteriorExtModule }
{31 => CompleteIntersectionResolutions::exteriorTorModule }
{32 => CompleteIntersectionResolutions::ExtModuleData }
{33 => CompleteIntersectionResolutions::extVsCohomology }
{34 => CompleteIntersectionResolutions::finiteBettiNumbers }
{35 => CompleteIntersectionResolutions::highSyzygy }
{36 => CompleteIntersectionResolutions::infiniteBettiNumbers }
{37 => CompleteIntersectionResolutions::koszulExtension }
{38 => CompleteIntersectionResolutions::layeredResolution }
{39 => CompleteIntersectionResolutions::makeFiniteResolution }
{40 => CompleteIntersectionResolutions::makeFiniteResolutionCodim2 }
{41 => CompleteIntersectionResolutions::matrixFactorization }
{42 => CompleteIntersectionResolutions::moduleAsExt }
{43 => CompleteIntersectionResolutions::Shamash }
{44 => CompleteIntersectionResolutions::TateResolution }
{45 => Complexes::betti(Complex) }
{46 => Complexes::cone(ComplexMap) }
{47 => Complexes::HH Complex }
{48 => Complexes::isExact }
{49 => Complexes::isFree(Complex) }
{50 => Complexes::isWellDefined(Complex) }
{51 => Complexes::length(Complex) }
{52 => CorrespondenceScrolls::multiHilbertPolynomial }
{53 => DGAlgebras::Basic operations on DG Algebras }
{54 => DGAlgebras::toComplex(DGAlgebra,ZZ) }
{55 => Dmodules::Ddual }
{56 => Dmodules::deRham(..., Strategy => ...) }
{57 => Dmodules::deRhamAll(..., Strategy => ...) }
{58 => Dmodules::DExt(..., Strategy => ...) }
{59 => Dmodules::DHom(..., Strategy => ...) }
{60 => Dmodules::Dintegration(..., Strategy => ...) }
{61 => Dmodules::DintegrationIdeal(..., Strategy => ...) }
{62 => Dmodules::Dmodules }
{63 => Dmodules::Dres }
{64 => Dmodules::Dres(..., LengthLimit => ...) }
{65 => Dmodules::Dres(..., Strategy => ...) }
{66 => Dmodules::Dresolution }
{67 => Dmodules::Dresolution(..., LengthLimit => ...) }
{68 => Dmodules::Dresolution(..., Strategy => ...) }
{69 => Dmodules::Dresolution(Ideal) }
{70 => Dmodules::Dresolution(Ideal,List) }
{71 => Dmodules::Dresolution(Module) }
{72 => Dmodules::Dresolution(Module,List) }
{73 => Dmodules::Drestriction }
{74 => Dmodules::PolyExt(..., Strategy => ...) }
{75 => Dmodules::RatExt }
{76 => Dmodules::RatExt(..., Strategy => ...) }
{77 => Dmodules::Schreyer }
{78 => Dmodules::Vhomogenize }
{79 => EdgeIdeals::isChordal }
{80 => EdgeIdeals::isSCM }
{81 => EdgeIdeals::smallestCycleSize }
{82 => EliminationMatrices::byResolution }
{83 => EliminationMatrices::ciResidual }
{84 => EliminationMatrices::EliminationMatrices }
{85 => EliminationMatrices::eliminationMatrix }
{86 => EliminationMatrices::eliminationMatrix(List,Matrix,Matrix) }
{87 => EliminationMatrices::regularityVar }
{88 => FiniteFittingIdeals::co1Fitting }
{89 => FiniteFittingIdeals::nextDegree }
{90 => FourierMotzkin::Applications to multigraded polynomial rings }
{91 => HigherCIOperators::ciOperatorResolution }
{92 => HigherCIOperators::HigherCIOperators }
{93 => HigherCIOperators::higherCIOperators }
{94 => HigherCIOperators::makeALDifferential }
{95 => HighestWeights::Example 1 }
{96 => HighestWeights::Example 2 }
{97 => HighestWeights::Example 3 }
{98 => HighestWeights::Example 4 }
{99 => HighestWeights::Example 5 }
{100 => HighestWeights::Example 6 }
{101 => HighestWeights::Example 7 }
{102 => HighestWeights::HighestWeights }
{103 => HighestWeights::highestWeightsDecomposition(ChainComplex,ZZ,List) }
{104 => HighestWeights::propagateWeights }
{105 => HighestWeights::propagateWeights(Matrix,List) }
{106 => HyperplaneArrangements::EPY }
{107 => InvolutiveBases::Involutive }
{108 => InvolutiveBases::InvolutiveBases }
{109 => InvolutiveBases::janetBasis }
{110 => InvolutiveBases::janetResolution }
{111 => InvolutiveBases::multVar }
{112 => InvolutiveBases::multVars }
{113 => K3Carpets::allGradings }
{114 => K3Carpets::analyzeStrand }
{115 => K3Carpets::canonicalHomotopies }
{116 => K3Carpets::carpetBettiTable }
{117 => K3Carpets::carpetBettiTables }
{118 => K3Carpets::carpetDet }
{119 => K3Carpets::computeBound }
{120 => K3Carpets::degenerateK3BettiTables }
{121 => K3Carpets::gorensteinDouble }
{122 => K3Carpets::K3Carpets }
{123 => K3Carpets::relativeResolution }
{124 => K3Carpets::relativeResolutionTwists }
{125 => K3Carpets::resonanceDet }
{126 => K3Carpets::schreyerName }
{127 => KustinMiller::Cyclic Polytopes }
{128 => KustinMiller::isExactRes }
{129 => KustinMiller::Jerry }
{130 => KustinMiller::KustinMiller }
{131 => KustinMiller::kustinMillerComplex }
{132 => KustinMiller::resBE }
{133 => KustinMiller::Stellar Subdivisions }
{134 => KustinMiller::Tom }
{135 => LexIdeals::cancelAll }
{136 => LexIdeals::LPP }
{137 => LexIdeals::multBounds }
{138 => LexIdeals::multLowerBound }
{139 => LexIdeals::multUpperBound }
{140 => LexIdeals::multUpperHF }
{141 => LocalRings::LocalRings }
{142 => Macaulay2Doc::a first Macaulay2 session }
{143 => Macaulay2Doc::betti }
{144 => Macaulay2Doc::betti(..., Minimize => ...) }
{145 => Macaulay2Doc::betti(BettiTally) }
{146 => Macaulay2Doc::betti(GradedModule) }
{147 => Macaulay2Doc::betti(GroebnerBasis) }
{148 => Macaulay2Doc::betti(Ideal) }
{149 => Macaulay2Doc::betti(Matrix) }
{150 => Macaulay2Doc::betti(Module) }
{151 => Macaulay2Doc::chain complexes }
{152 => Macaulay2Doc::ChainComplex }
{153 => Macaulay2Doc::ChainComplex ++ ChainComplex }
{154 => Macaulay2Doc::ChainComplex _ ZZ }
{155 => Macaulay2Doc::ChainComplexMap _ ZZ }
{156 => Macaulay2Doc::changes, 1.0 and 1.1 }
{157 => Macaulay2Doc::changes, 1.6 }
{158 => Macaulay2Doc::changes, 1.7 }
{159 => Macaulay2Doc::changes, 1.8 }
{160 => Macaulay2Doc::changes, 1.9 }
{161 => Macaulay2Doc::changes, 1.9.1 }
{162 => Macaulay2Doc::changes, 1.10 }
{163 => Macaulay2Doc::changes, 1.11 }
{164 => Macaulay2Doc::changes, 1.12 }
{165 => Macaulay2Doc::changes, 1.13 }
{166 => Macaulay2Doc::complete }
{167 => Macaulay2Doc::complete(ChainComplex) }
{168 => Macaulay2Doc::computing resolutions }
{169 => Macaulay2Doc::cone(ChainComplexMap) }
{170 => Macaulay2Doc::David Eisenbud }
{171 => Macaulay2Doc::dd }
{172 => Macaulay2Doc::document }
{173 => Macaulay2Doc::document(..., Inputs => ...) }
{174 => Macaulay2Doc::document(..., Key => ...) }
{175 => Macaulay2Doc::document(..., Outputs => ...) }
{176 => Macaulay2Doc::documentation keys }
{177 => Macaulay2Doc::eagonNorthcott(Matrix) }
{178 => Macaulay2Doc::Elementary uses of Groebner bases I. Math 634 Fall 2005 }
{179 => Macaulay2Doc::engine }
{180 => Macaulay2Doc::Ext^ZZ(CoherentSheaf,CoherentSheaf) }
{181 => Macaulay2Doc::Ext^ZZ(CoherentSheaf,SumOfTwists) }
{182 => Macaulay2Doc::Ext^ZZ(Matrix,Module) }
{183 => Macaulay2Doc::Ext^ZZ(Module,Matrix) }
{184 => Macaulay2Doc::Ext^ZZ(Module,Module) }
{185 => Macaulay2Doc::extend(ChainComplex,ChainComplex,Matrix) }
{186 => Macaulay2Doc::extracting information from chain complexes }
{187 => Macaulay2Doc::factor }
{188 => Macaulay2Doc::FastNonminimal }
{189 => Macaulay2Doc::findSynonyms(Symbol) }
{190 => Macaulay2Doc::frac }
{191 => Macaulay2Doc::free resolutions of modules }
{192 => Macaulay2Doc::gbTrace }
{193 => Macaulay2Doc::getNonUnit }
{194 => Macaulay2Doc::graded and multigraded polynomial rings }
{195 => Macaulay2Doc::heft }
{196 => Macaulay2Doc::HH^ZZ CoherentSheaf }
{197 => Macaulay2Doc::Hilbert functions and free resolutions }
{198 => Macaulay2Doc::Hom(Module,ChainComplex) }
{199 => Macaulay2Doc::Ideal }
{200 => Macaulay2Doc::ideals }
{201 => Macaulay2Doc::ideals to and from modules }
{202 => Macaulay2Doc::LengthLimit }
{203 => Macaulay2Doc::lift }
{204 => Macaulay2Doc::maps between chain complexes }
{205 => Macaulay2Doc::methods }
{206 => Macaulay2Doc::minimalBetti(Ideal) }
{207 => Macaulay2Doc::Module }
{208 => Macaulay2Doc::modules }
{209 => Macaulay2Doc::modules in Macaulay2 }
{210 => Macaulay2Doc::nullhomotopy }
{211 => Macaulay2Doc::packages provided with Macaulay2 }
{212 => Macaulay2Doc::path }
{213 => Macaulay2Doc::pdim }
{214 => Macaulay2Doc::peek'(ZZ,Thing) }
{215 => Macaulay2Doc::pseudocode }
{216 => Macaulay2Doc::regularity }
{217 => Macaulay2Doc::replacements for commands and scripts from Macaulay }
{218 => Macaulay2Doc::Resolution }
{219 => Macaulay2Doc::resolution }
{220 => Macaulay2Doc::resolution(..., DegreeLimit => ...) }
{221 => Macaulay2Doc::resolution(..., FastNonminimal => ...) }
{222 => Macaulay2Doc::resolution(..., HardDegreeLimit => ...) }
{223 => Macaulay2Doc::resolution(..., LengthLimit => ...) }
{224 => Macaulay2Doc::resolution(..., PairLimit => ...) }
{225 => Macaulay2Doc::resolution(..., SortStrategy => ...) }
{226 => Macaulay2Doc::resolution(..., StopBeforeComputation => ...) }
{227 => Macaulay2Doc::resolution(..., Strategy => ...) }
{228 => Macaulay2Doc::resolution(..., SyzygyLimit => ...) }
{229 => Macaulay2Doc::resolution(Ideal) }
{230 => Macaulay2Doc::resolution(Matrix) }
{231 => Macaulay2Doc::resolution(Module) }
{232 => Macaulay2Doc::resolution(MonomialIdeal) }
{233 => Macaulay2Doc::RingMap RingElement }
{234 => Macaulay2Doc::running Macaulay2 in emacs }
{235 => Macaulay2Doc::Schreyer orders }
{236 => Macaulay2Doc::Singular Book 2.4.12 }
{237 => Macaulay2Doc::Singular Book 2.4.15 }
{238 => Macaulay2Doc::Singular Book 2.5.18 }
{239 => Macaulay2Doc::source(ChainComplexMap) }
{240 => Macaulay2Doc::status }
{241 => Macaulay2Doc::syzygyScheme }
{242 => Macaulay2Doc::target(ChainComplexMap) }
{243 => Macaulay2Doc::Tutorial: Canonical Embeddings of Plane Curves and Gonality}
{244 => Macaulay2Doc::Tutorial: Elementary uses of Groebner bases }
{245 => Macaulay2Doc::Tutorial: Fano varieties }
{246 => Macaulay2Doc::two dimensional formatting }
{247 => Macaulay2Doc::Usage }
{248 => Macaulay2Doc::using Macaulay2 with emacs after it has been set up }
{249 => MCMApproximations::approximation }
{250 => MCMApproximations::MCMApproximations }
{251 => MCMApproximations::syzygyModule }
{252 => MultiplierIdealsDim2::MultiplierIdealsDim2 }
{253 => MultiplierIdealsDim2::RelativeCanonicalDivisor }
{254 => NCAlgebra::Basic operations on noncommutative algebras }
{255 => NCAlgebra::betti(NCChainComplex) }
{256 => NCAlgebra::NCChainComplex }
{257 => NCAlgebra::NCMatrix // NCMatrix }
{258 => NCAlgebra::resolution(NCMatrix) }
{259 => NCAlgebra::rightKernel }
{260 => NCAlgebra::Using the Bergman interface }
{261 => NonminimalComplexes::SVDBetti }
{262 => NormalToricVarieties::makeSmooth(NormalToricVariety) }
{263 => NormalToricVarieties::Making normal toric varieties }
{264 => NormalToricVarieties::Resolution of singularities }
{265 => PieriMaps::pieri }
{266 => PieriMaps::PieriMaps }
{267 => PieriMaps::pureFree }
{268 => Points::expectedBetti }
{269 => Points::minMaxResolution }
{270 => Points::Points }
{271 => Posets::Example: Constructing common posets }
{272 => Posets::Example: Hibi ideals }
{273 => Posets::Example: LCM-lattices }
{274 => Posets::lcmLattice }
{275 => Posets::resolutionPoset }
{276 => Posets::resolutionPoset(ChainComplex) }
{277 => Posets::resolutionPoset(Ideal) }
{278 => Posets::resolutionPoset(MonomialIdeal) }
{279 => PrimaryDecomposition::primaryDecomposition(..., Strategy => ...) }
{280 => PruneComplex::PruneComplex }
{281 => PruneComplex::pruneComplex }
{282 => PruneComplex::toChainComplex }
{283 => RandomMonomialIdeals::bettiStats }
{284 => RandomSpaceCurves::knownUnirationalComponentOfSpaceCurves }
{285 => RandomSpaceCurves::spaceCurve }
{286 => ReesAlgebra::PlaneCurveSingularities }
{287 => ReesAlgebra::ReesAlgebra }
{288 => ReesAlgebra::reesIdeal }
{289 => Regularity::Regularity }
{290 => RelativeCanonicalResolution::eagonNorthcottType }
{291 => RelativeCanonicalResolution::iteratedMC }
{292 => RelativeCanonicalResolution::liftMatrixToENT }
{293 => RelativeCanonicalResolution::RelativeCanonicalResolution }
{294 => RelativeCanonicalResolution::resCurveOnScroll }
{295 => RelativeCanonicalResolution::rkSyzModules }
{296 => SchurRings::schurResolution }
{297 => SchurRings::schurResolution(..., DegreeLimit => ...) }
{298 => SchurRings::schurResolution(..., SyzygyLimit => ...) }
{299 => SchurRings::SchurRings }
{300 => SimplicialComplexes::lyubeznikComplex }
{301 => SimplicialComplexes::superficialComplex }
{302 => SLnEquivariantMatrices::SLnEquivariantMatrices }
{303 => SpectralSequences::basis(List,SpectralSequencePage) }
{304 => SpectralSequences::hilbertPolynomial(SpectralSequencePage) }
{305 => SpectralSequences::minimalPresentation(SpectralSequence) }
{306 => SpectralSequences::minimalPresentation(SpectralSequencePage) }
{307 => SpectralSequences::Page }
{308 => SpectralSequences::PageMap }
{309 => SpectralSequences::pruningMaps }
{310 => SpectralSequences::pruningMaps(SpectralSequencePage) }
{311 => SpectralSequences::Spectral sequences and hypercohomology calculations }
{312 => SpectralSequences::SpectralSequence ^ ZZ }
{313 => SpectralSequences::SpectralSequence _ ZZ }
{314 => SpectralSequences::spectralSequencePage(FilteredComplex,ZZ) }
{315 => SpectralSequences::SpectralSequencePageMap ^ List }
{316 => SpectralSequences::SpectralSequencePageMap _ List }
{317 => TateOnProducts::beilinson }
{318 => TateOnProducts::beilinsonWindow }
{319 => TateOnProducts::coarseMultigradedRegularity }
{320 => TateOnProducts::cohomologyHashTable }
{321 => TateOnProducts::cohomologyMatrix }
{322 => TateOnProducts::composedFunctions }
{323 => TateOnProducts::cornerComplex }
{324 => TateOnProducts::eulerPolynomialTable }
{325 => TateOnProducts::firstQuadrantComplex }
{326 => TateOnProducts::lastQuadrantComplex }
{327 => TateOnProducts::strand }
{328 => TateOnProducts::tateExtension }
{329 => TateOnProducts::TateOnProducts }
{330 => TateOnProducts::tateResolution }
{331 => TensorComplexes::flattenedESTensor }
{332 => TensorComplexes::pureResES }
{333 => TensorComplexes::pureResES1 }
{334 => TensorComplexes::pureResTC }
{335 => TensorComplexes::pureResTC1 }
{336 => TensorComplexes::tensorComplex1 }
{337 => TensorComplexes::TensorComplexes }
{338 => TestIdeals::isCohenMacaulay }
{339 => Text::html(TEX) }
{340 => Text::MarkUpTypeWithOptions }
{341 => TorAlgebra::TorAlgebra }
{342 => Triplets::Triplet }
{343 => Triplets::Triplets }
{344 => VectorFields::isFreeDivisor }
{345 => VersalDeformations::versalDeformation }
{346 => VirtualResolutions::isVirtual }
{347 => VirtualResolutions::isVirtual(..., Strategy => ...) }
{348 => VirtualResolutions::resolveViaFatPoint }
{349 => VirtualResolutions::virtualOfPair }
{350 => VirtualResolutions::VirtualResolutions }
o73 : NumberedVerticalList
i74 : R
o74 = R
o74 : PolynomialRing
i75 : describe R
o75 = QQ[x, Degrees => {1}, Heft => {1}, MonomialOrder => {MonomialSize => 32}, DegreeRank => 1]
{GRevLex => {1} }
{Position => Up }
i76 : peek R
o76 = PolynomialRing of RingElement{(?, R, R) => -*Function[/Applications/Macaulay2-1.14/share/Macaulay2/Core/enginering.m2:170:21-170:36]*- }
(_, R, monoid[x, Degrees => {1}, Heft => {1}, MonomialOrder => {MonomialSize => 32}, DegreeRank => 1]) => -*Function[/Applications/Macaulay2-1.14/share/Macaulay2/Core/orderedmonoidrings.m2:226:27-226:78]*-
{GRevLex => {1} }
{Position => Up }
(lift, List, R, QQ) => -*Function[/Applications/Macaulay2-1.14/share/Macaulay2/Core/enginering.m2:195:44-195:65]*-
(lift, List, R, R) => -*Function[/Applications/Macaulay2-1.14/share/Macaulay2/Core/enginering.m2:159:29-159:43]*-
(lift, List, R, ZZ) => -*Function[/Applications/Macaulay2-1.14/share/Macaulay2/Core/enginering.m2:216:50-216:75]*-
(lift, Matrix, R, QQ) => -*Function[/Applications/Macaulay2-1.14/share/Macaulay2/Core/enginering.m2:191:46-191:87]*-
(lift, Matrix, R, R) => -*Function[/Applications/Macaulay2-1.14/share/Macaulay2/Core/enginering.m2:160:31-160:45]*-
(lift, Matrix, R, ZZ) => -*Function[/Applications/Macaulay2-1.14/share/Macaulay2/Core/enginering.m2:212:49-212:91]*-
(lift, Module, R, QQ) => -*Function[/Applications/Macaulay2-1.14/share/Macaulay2/Core/enginering.m2:189:46-189:80]*-
(lift, Module, R, R) => -*Function[/Applications/Macaulay2-1.14/share/Macaulay2/Core/enginering.m2:162:31-162:45]*-
(lift, Module, R, ZZ) => -*Function[/Applications/Macaulay2-1.14/share/Macaulay2/Core/enginering.m2:210:49-210:84]*-
(lift, MutableMatrix, R, QQ) => -*Function[/Applications/Macaulay2-1.14/share/Macaulay2/Core/enginering.m2:193:53-193:99]*-
(lift, MutableMatrix, R, R) => -*Function[/Applications/Macaulay2-1.14/share/Macaulay2/Core/enginering.m2:163:38-163:52]*-
(lift, MutableMatrix, R, ZZ) => -*Function[/Applications/Macaulay2-1.14/share/Macaulay2/Core/enginering.m2:214:56-214:105]*-
(lift, R, QQ) => -*Function[/Applications/Macaulay2-1.14/share/Macaulay2/Core/enginering.m2:187:39-187:75]*-
(lift, R, R) => -*Function[/Applications/Macaulay2-1.14/share/Macaulay2/Core/enginering.m2:155:24-155:36]*-
(lift, R, ZZ) => -*Function[/Applications/Macaulay2-1.14/share/Macaulay2/Core/enginering.m2:208:39-208:74]*-
(promote, List, QQ, R) => -*Function[/Applications/Macaulay2-1.14/share/Macaulay2/Core/enginering.m2:194:50-194:62]*-
(promote, List, R, R) => -*Function[/Applications/Macaulay2-1.14/share/Macaulay2/Core/enginering.m2:157:35-157:38]*-
(promote, List, ZZ, R) => -*Function[/Applications/Macaulay2-1.14/share/Macaulay2/Core/enginering.m2:215:50-215:78]*-
(promote, Matrix, QQ, R) => -*Function[/Applications/Macaulay2-1.14/share/Macaulay2/Core/enginering.m2:190:52-190:78]*-
(promote, Matrix, R, R) => -*Function[/Applications/Macaulay2-1.14/share/Macaulay2/Core/enginering.m2:158:37-158:40]*-
(promote, Matrix, ZZ, R) => -*Function[/Applications/Macaulay2-1.14/share/Macaulay2/Core/enginering.m2:211:52-211:79]*-
(promote, Module, QQ, R) => -*Function[/Applications/Macaulay2-1.14/share/Macaulay2/Core/enginering.m2:188:52-188:78]*-
(promote, Module, R, R) => -*Function[/Applications/Macaulay2-1.14/share/Macaulay2/Core/enginering.m2:161:37-161:40]*-
(promote, Module, ZZ, R) => -*Function[/Applications/Macaulay2-1.14/share/Macaulay2/Core/enginering.m2:209:52-209:79]*-
(promote, MutableMatrix, QQ, R) => -*Function[/Applications/Macaulay2-1.14/share/Macaulay2/Core/enginering.m2:192:59-192:90]*-
(promote, MutableMatrix, R, R) => -*Function[/Applications/Macaulay2-1.14/share/Macaulay2/Core/enginering.m2:164:44-164:47]*-
(promote, MutableMatrix, ZZ, R) => -*Function[/Applications/Macaulay2-1.14/share/Macaulay2/Core/enginering.m2:213:59-213:93]*-
(promote, QQ, R) => -*Function[/Applications/Macaulay2-1.14/share/Macaulay2/Core/enginering.m2:185:37-185:71]*-
(promote, R, R) => -*Function[/Applications/Macaulay2-1.14/share/Macaulay2/Core/enginering.m2:156:28-156:31]*-
(promote, ZZ, R) => -*Function[/Applications/Macaulay2-1.14/share/Macaulay2/Core/enginering.m2:206:37-206:71]*-
0 => 0
1 => 1
basering => QQ
baseRings => {ZZ, QQ}
char => 0
degreesMonoid => monoid[T, Degrees => {1}, MonomialOrder => {MonomialSize => 32}, DegreeRank => 1, Inverses => true, Global => false]
{Weights => {-1} }
{GroupLex => 1 }
{Position => Up }
degreesRing => ZZ[T]
Engine => true
expression => -*Function[/Applications/Macaulay2-1.14/share/Macaulay2/Core/orderedmonoidrings.m2:232:35-239:43]*-
factor => -*Function[/Applications/Macaulay2-1.14/share/Macaulay2/Core/orderedmonoidrings.m2:253:29-283:76]*-
FlatMonoid => monoid[x, Degrees => {1}, Heft => {1}, MonomialOrder => {MonomialSize => 32}, DegreeRank => 1]
{GRevLex => {1} }
{Position => Up }
generatorExpressions => {x}
generators => {x}
generatorSymbols => {x}
indexStrings => HashTable{x => x}
indexSymbols => HashTable{x => x}
isCommutative => true
isPrime => -*Function[/Applications/Macaulay2-1.14/share/Macaulay2/Core/orderedmonoidrings.m2:284:27-288:22]*-
liftDegree => -*Function[/Applications/Macaulay2-1.14/share/Macaulay2/Core/enginering.m2:59:20-61:38]*-
monoid => monoid[x, Degrees => {1}, Heft => {1}, MonomialOrder => {MonomialSize => 32}, DegreeRank => 1]
{GRevLex => {1} }
{Position => Up }
numallvars => 1
promoteDegree => -*Function[/Applications/Macaulay2-1.14/share/Macaulay2/Core/enginering.m2:59:20-61:38]*-
raw creation log => -*a bagged function application expression*-
RawRing => QQGMP[x,
DegreeLength => 1,
Degrees => {1},
Heft => {1},
MonomialOrder => {
GRevLex => {1},
Position => Up
}
]
i77 : f = () -> ( QQ [ local y _ 0 ] )
o77 = f
o77 : FunctionClosure
i78 : f()
warning: clearing value of symbol y to allow access to subscripted variables based on it
: debug with expression debug 9371 or with command line option --debug 9371
o78 = QQ[y ]
0
o78 : PolynomialRing
i79 : f()
warning: clearing value of symbol y to allow access to subscripted variables based on it
: debug with expression debug 9371 or with command line option --debug 9371
o79 = QQ[y ]
0
o79 : PolynomialRing
i80 : y
o80 = y
o80 : IndexedVariableTable
i81 : peek y
o81 = IndexedVariableTable{0 => y }
0
symbol$ => y
i82 : debug 9371
o82 = 9371
i83 : y=0
o83 = 0
i84 : f()
stdio:77:13:(3):[1]: error: clearing value of symbol y to allow access to subscripted variables based on it
i85 : restart
Macaulay2, version 1.14
--loading configuration for package "FourTiTwo" from file /Users/dan/Library/Application Support/Macaulay2/init-FourTiTwo.m2
--loading configuration for package "Topcom" from file /Users/dan/Library/Application Support/Macaulay2/init-Topcom.m2
with packages: ConwayPolynomials, Elimination, IntegralClosure, InverseSystems, LLLBases, PrimaryDecomposition,
ReesAlgebra, TangentCone, Truncations
i1 : f = () -> ( QQ [ local y _ 0 ] )
o1 = f
o1 : FunctionClosure
i2 : QQ[y]
o2 = QQ[y]
o2 : PolynomialRing
i3 : f()
warning: clearing value of symbol y to allow access to subscripted variables based on it
: debug with expression debug 9371 or with command line option --debug 9371
o3 = QQ[y ]
0
o3 : PolynomialRing
i4 : debug 9371
o4 = 9371
i5 : f()
stdio:1:13:(3):[1]: error: clearing value of symbol y to allow access to subscripted variables based on it
i6 : help
o6 = initial help
************
Welcome to Macaulay2
Try entering '2+2' at your next input prompt, which begins with i. The two output prompts begin with o.
The first one, with the equal sign, '=', gives the value computed from your input, and the second one,
with the colon, ':', tells what type of thing the value is.
Type one of these commands to get started reading the documentation:
* copyright -- the copyright
* help "Macaulay2" -- top node of the documentation.
* help "reading the documentation" --
* help "getting started" --
* help "a first Macaulay2 session" --
* help x -- show documentation for x
* help about x -- show documentation about x
* help about (x,Body=>true) -- show documentation mentioning x
* ? f -- display brief documentation for a function f
* printWidth = 80 -- set print width to 80 characters
* viewHelp -- view documentation in a browser
* viewHelp x -- view documentation on x in browser
To read the documentation in info form, in case you happen to be running Macaulay2 in a terminal window,
replace "help" by "infoHelp" in any of the commands above.
o6 : DIV
i7 :
Process M2 finished