Revert all commits from 147812d to HEAD

Author: btotaro

M2/Macaulay2/m2/pushforward.m2

@@ -235,27 +235,6 @@ addHook((kernel, Matrix), Strategy => "PushForward",
 	M := coimage map(target m, f ** source m, raw m);
 	image pushNonLinear(options pushForward, f, M)))
 
------------------------------------------------------------------------------
-
--- pushforward the module to PP^n via S/I <-- S
--- this is used for instance before computing pdim
--- or regularity of a module over a quotient ring.
--- cf. https://github.com/Macaulay2/M2/issues/3321
-flattenModule   = M -> (
-    if instance(ring M, PolynomialRing) then M
-    else cokernel flattenMorphism presentation M)
--- TODO: find a name that can't be confused with flatness.
--- Currently this is simply named after flattenRing.
-flattenMorphism = f -> f.cache#"flattenMorphism" ??= (
-    if instance(ring f, PolynomialRing) then return f;
-    g := presentation ring f;
-    -- FIXME: if ring f is a quotient of another quotient ring Q,
-    -- "ambient ring f" would give Q, not a polynomial ring as we want.
-    S := ring g;
-    -- TODO: sometimes lifting to ring g is enough, how can we detect this?
-    -- TODO: why doesn't lift(f, ring g) do this automatically?
-    map(target f ** S, source f ** S, lift(cover f, S)) ** cokernel g)
-
 -- Local Variables:
 -- compile-command: "make -C $M2BUILDDIR/Macaulay2/m2 "
 -- End:

M2/Macaulay2/packages/Complexes.m2

@@ -60,7 +60,6 @@ export {
     "resolutionMap",
     "tensorCommutativity",
     "torSymmetry",
-    "weightedRegularity",
     "yonedaExtension",
     "yonedaExtension'",
     "yonedaMap",
@@ -81,7 +80,6 @@ export {
 
 importFrom_Core {
     "isPackageLoaded",
-    "flattenModule", "flattenMorphism",
 }
 
 -- keys into the type `Complex`

M2/Macaulay2/packages/Complexes/ChainComplex.m2

@@ -603,45 +603,24 @@ betti Complex := opts -> C -> (
         )
     )
 
-pdim Module := M -> length freeResolution flattenModule minimalPresentation M
+pdim Module := M -> length freeResolution minimalPresentation M
 
 regularity Ideal  := opts -> I -> (
     if I == 0 then -infinity else if I == 1 then 0
-    else 1 + regularity betti(freeResolution flattenModule comodule I, opts))
+    else 1 + regularity betti(freeResolution comodule I, opts))
 
--- cf. https://github.com/Macaulay2/M2/issues/3321
 regularity Module := opts -> M -> (
     if not isHomogeneous M then error "regularity: expected homogeneous module";
-    regularity betti(freeResolution flattenModule minimalPresentation M, opts))
+    regularity betti(freeResolution minimalPresentation M, opts))
 
 regularity Complex := opts -> C -> (
     if numgens degreesRing ring C =!= 1 then 
-        error "expected the underlying ring to be singly graded";
+        error "expected the underlying ring to be standard graded";
     if not isFree C then 
         error "expected a complex whose terms are all free";
     regularity betti(C,opts)
     )
 
-symondsShift = R -> (
-    -- For a graded polynomial ring R with positive integer weights a_0,...,a_(n-1),
-    -- symondsShift(R) means sum_i (a_i-1).
-    if degreeLength R =!= 1 then error "expected degree length 1";
-    degs := flatten degrees R; -- This is a list of the form {a_0,...,a_(n-1)}.
-    -#degs + fold(plus, degs))
-
-weightedRegularity = method(TypicalValue => ZZ, Options => {})
-
--- For a graded polynomial ring R with positive integer weights a_0,...,a_(n-1) and a graded R-module M,
--- weightedRegularity(M) means regularity(M) - sum_i (a_i-1), as suggested by Peter Symonds.
--- (Thus it agrees with the usual regularity when the weights are 1.) The point is
--- that the weighted regularity has a simple relation to local cohomology at the irrelevant ideal m:
--- it is equal to
---            sup_{i>=0} (maximum degree of H^i_m(R, M) + i).
--- For example, if the module M is bounded above, then the weighted regularity of M is equal
--- to the maximum degree of M, and it should be a fast way to compute that.
-weightedRegularity Module := weightedRegularity Ideal := weightedRegularity Complex := opts -> M -> (
-    -symondsShift ring M + regularity M)
-
 poincare Complex := C -> (
     S := degreesRing ring C;
     (lo,hi) := concentration C;
@@ -1362,7 +1341,3 @@ koszulComplex List := Complex => {Concentration => null} >> opts -> L -> (
     if #L === 0 then error "expected a non-empty list";
     koszulComplex(matrix{L}, opts)
     )
-
-koszul Matrix := Complex => f -> koszulComplex f
-
--- TODO: eagonNorthcott

M2/Macaulay2/packages/Complexes/ChainComplexDoc.m2

@@ -135,7 +135,6 @@ doc ///
                 TO (min, Complex),
                 TO (length, Complex),
                 TO (regularity, Complex),
-                TO (weightedRegularity, Complex),		
                 TO (betti, Complex),
                 TO (poincare, Complex),
                 TO (poincareN, Complex),
@@ -4330,7 +4329,7 @@ doc ///
         :ZZ
     Description
         Text
-            Given a free complex $C$ over a singly graded polynomial ring,
+            Given a free complex $C$ over a standard graded polynomial ring,
             the regularity $r$ of $C$ is the smallest integer such that
             each basis element of $C_i$ has degree at most $i + r$.
         Example
@@ -4357,112 +4356,18 @@ doc ///
             regularity FJ
         Text
             Although Castelnuovo-Mumford regularity is defined
-            in more general settings (e.g., toric varieties with multi-degrees),
+            in more general settings (e.g. toric varieties with multi-degrees)
             this method does not currently handle these 
             extensions.  Similarly, Castelnuovo-Mumford
             regularity can be defined for non-free complexes,
             but this method doesn't handle that case either.
     SeeAlso
-        (weightedRegularity, Complex)
         "Basic invariants and properties"
         regularity
         betti
         freeResolution
 ///
 
-doc ///
-Node
-  Key
-     weightedRegularity
-    (weightedRegularity, Ideal)
-    (weightedRegularity, Module)
-  Headline
-    compute the weighted Castelnuovo-Mumford regularity
-  Usage
-    r = weightedRegularity C
-  Inputs
-    C: -- an Ideal, a Module, or a ChainComplex
-  Outputs
-    r:ZZ
-  Description
-    Text
-      Let @TT "R"@ be a graded polynomial algebra over a field, with generators $x_0,\ldots,x_{n-1}$
-      in positive integer weights $a_0,...,a_{n-1}$,
-      and let $\mathfrak{m}$ be the maximal ideal $(x_0,\ldots,x_{n-1})$.
-      For a graded module @TT "R"@-module @TT "M"@, the weighted regularity of @TT "M"@ is defined
-      in terms of local cohomology, as
-      $$\sup_{i\geq 0} (i + \text{maximum degree of }H^i_{\mathfrak{m}}(R, M)).$$
-      For example, if @TT "M"@ is bounded above, then the weighted regularity of @TT "M"@
-      is the maximum degree of @TT "M"@, and this should be a fast way to compute the maximum degree.
-    Text
-      If the weights are equal to 1, this is the same as @TO2{(regularity,Module),"regularity(M)"}@.
-      In general, the weighted regularity is equal to the regularity minus $\sum_i (a_i-1)$.
-      What we call weighted regularity was proposed by Peter Symonds as the definition of regularity.
-    Text
-      In the following example, the module @TT "M"@ is bounded above, with top-degree element $xy$ in degree 12.
-    Example
-      R = QQ[x,y,Degrees=>{5,7}];
-      M = R^1/(x^2,y^2);
-      regularity M
-      weightedRegularity M
-  SeeAlso
-    (regularity, Module)
-    "OldChainComplexes :: resolution"
-    betti
-    comodule
-    "VirtualResolutions :: multigradedRegularity"
-///
-
-doc ///
-    Key
-        (weightedRegularity, Complex)
-    Headline
-        compute the weighted Castelnuovo-Mumford regularity
-    Usage
-        weightedRegularity C
-    Inputs
-        C:Complex
-    Outputs
-        :ZZ
-    Description
-        Text
-            Given a complex @TT "C"@ of free modules over a singly graded polynomial ring $R$,
-            the @TO2 {(regularity,Complex),"regularity"}@ of $C$ is the smallest integer $r$ such that
-            each basis element of $C_i$ has degree at most $i + r$. Let the generators of $R$
-	    have weights $a_0,\ldots,a_{n-1}$. Then @TT "weightedRegularity C"@ is defined
-	    as the regularity of @TT "C"@ minus $\sum_i (a_i-1)$. (Thus the two notions
-	    are the same when the weights are equal to 1.)
-	Text
-	    This is motivated by the case where @TT "C"@ is the minimal free resolution of a graded $R$-module @TT "M"@.
-	    In that case, @TT "weightedRegularity C"@ is equal to the weighted regularity of @TT "M"@, defined
-	    in terms of local cohomology as
-	    $$\sup_{i\geq 0} (i+\text{maximum degree of }H^i_{\m}(R, M)).$$
-	    For example, if @TT "M"@ is bounded above, then this is the maximum degree of @TT "M"@.
-	Text
-	    In the following example, the module @TT "M"@ is bounded above, with top-degree element $xy$ in degree 7.
-        Example
-            R = ZZ/101[x,y,Degrees=>{2,5}];
-	    M = R^1/(x^2,y^2);
-            C = freeResolution M
-            betti C
-            regularity C
-            weightedRegularity C
-            weightedRegularity M
-        Text
-            Although Castelnuovo-Mumford regularity is defined
-            in more general settings (e.g., toric varieties with multi-degrees),
-            this method does not currently handle these 
-            extensions.  Similarly, Castelnuovo-Mumford
-            regularity can be defined for non-free complexes,
-            but this method doesn't handle that case either.
-    SeeAlso
-        "Basic invariants and properties"
-	(regularity, Complex)
-        regularity
-        betti
-        freeResolution
-///
-
 doc ///
     Key
         (Ext,Module,Module)

M2/Macaulay2/packages/Macaulay2Doc/functions/regularity-doc.m2

@@ -22,8 +22,7 @@ Node
     r:ZZ
   Description
     Text
-      For a free chain complex @TT "C"@ over a graded polynomial ring,
-      the regularity is the smallest number @TT "r"@ such that each
+      For a free chain complex @TT "C"@, the regularity @TT "r"@ is the smallest number so that each
       basis element of @TT "C_i"@ has degree at most @TT "i+r"@. For an ideal @TT "I"@, regularity is
       one plus the regularity of the minimal free resolution of the quotient of the ambient ring by @TT "I"@.
       For a module @TT "M"@, regularity is the regularity of a minimal free resolution of @TT "M"@.
@@ -35,19 +34,6 @@ Node
       regularity comodule I
       regularity I
       regularity module I
-    Text
-      A closely related notion is the @TT "weightedRegularity"@ of a module.
-      Let @TT "R"@ be a graded polynomial algebra over a field, with generators $x_0,\ldots,x_{n-1}$
-      in positive integer weights $a_0,...,a_{n-1}$,
-      and let $\mathfrak{m}$ be the maximal ideal $(x_0,\ldots,x_{n-1})$.
-      For a graded @TT "R"@-module @TT "M"@, @TT "weightedRegularity(M)"@ is defined
-      using local cohomology as
-      $$\sup_{i\geq 0} (i + \text{maximum degree of }H^i_{\mathfrak{m}}(R, M)).$$
-      For example, if $M$ is bounded above, then the weighted regularity of @TT "M"@ is the maximum degree of $M$.
-    Text
-      If the weights are equal to 1, then weighted regularity is the same as regularity. In general, the weighted
-      regularity is equal to the regularity minus $\sum_i (a_i-1)$.
-      What we call weighted regularity was proposed by Peter Symonds as the definition of regularity.
     Text
       The regularity is the label of the last row in the @TO2 {betti, "Betti diagram"}@ of a chain complex.
       However, this depends on the total degree weights in the Betti tally, which are computed based on the