rewrite minimiz_result decorator: deal with result is self

Author: dkrenn

src/sage/combinat/k_regular_sequence.py

@@ -397,7 +397,8 @@ def _error_if_degenerated_(self):
                 "for correcting this.")
 
     @cached_method
-    def regenerated(self, **kwds):
+    @minimize_result
+    def regenerated(self):
         r"""
         Return a `k`-regular sequence that satisfies
         `\mu[0] \mathit{right} = \mathit{right}`.
@@ -462,40 +463,7 @@ def regenerated(self, **kwds):
         """
         if not self.is_degenerated():
             return self
-        return self._regenerated_(**kwds)
-
-    @minimize_result
-    def _regenerated_(self):
-        r"""
-        Return a `k`-regular sequence that satisfies
-        `\mu[0] \mathit{right} = \mathit{right}`.
-
-        Compared to :meth:`regenerated`, this method skips some initial checks
-        whether the sequence is degenerated or not.
-
-        See also :meth:`regenerated`.
-
-        INPUT:
-
-        - ``minimize`` -- (default: ``None``) a boolean or ``None``.
-          If ``True``, then :meth:`~RecognizableSeries.minimized` is called after the operation,
-          if ``False``, then not. If this argument is ``None``, then
-          the default specified by the parent's ``minimize_results`` is used.
-
-        OUTPUT:
-
-        A :class:`kRegularSequence`
-
-        TESTS::
 
-            sage: Seq2 = kRegularSequenceSpace(2, ZZ)
-            sage: C = Seq2((Matrix([[2, 0], [2, 1]]), Matrix([[0, 1], [-2, 3]])),
-            ....:          vector([1, 0]), vector([0, 1]))
-            sage: C.is_degenerated()
-            False
-            sage: C.regenerated() is C  # indirect doctest
-            True
-        """
         from sage.matrix.constructor import Matrix
         from sage.matrix.special import zero_matrix, identity_matrix
         from sage.modules.free_module_element import vector

src/sage/combinat/recognizable_series.py

@@ -317,6 +317,12 @@ def minimize_result(operation):
       if ``False``, then not. If this argument is ``None``, then
       the default specified by the parent's ``minimize_results`` is used.
 
+    .. NOTE::
+
+        If the result of ``operation`` is ``self``, then minimization is
+        not applied unless ``minimize=True`` is explicitly set,
+        in particular, independent of the parent's ``minimize_results``.
+
     TESTS::
 
         sage: from sage.combinat.recognizable_series import minimize_result
@@ -351,14 +357,39 @@ def minimize_result(operation):
         some result minimized
         sage: S('some').operation(minimize=False)
         some result
+
+    ::
+
+        sage: class T(S):
+        ....:     @minimize_result
+        ....:     def nooperation(self):
+        ....:         return self
+        sage: t = T('some')
+        sage: p.minimize_results = True
+        sage: t.nooperation() is t
+        True
+        sage: t.nooperation(minimize=True) is t
+        False
+        sage: t.nooperation(minimize=False) is t
+        True
+        sage: p.minimize_results = False
+        sage: t.nooperation() is t
+        True
+        sage: t.nooperation(minimize=True) is t
+        False
+        sage: t.nooperation(minimize=False) is t
+        True
     """
     @wraps(operation)
     def minimized(self, *args, **kwds):
         minimize = kwds.pop('minimize', None)
-        if minimize is None:
-            minimize = self.parent().minimize_results
 
         result = operation(self, *args, **kwds)
+        if minimize is not True and result is self:
+            return result
+
+        if minimize is None:
+            minimize = self.parent().minimize_results
 
         if minimize:
             result = result.minimized()