Trac #33097: some typos in combinat and modular

Release Manager · Release Manager · commit e0ffa0f92dca · 2022-01-04T23:50:12.000+01:00
found using codespell URL: https://trac.sagemath.org/33097 Reported by: chapoton Ticket author(s): Frédéric Chapoton Reviewer(s): Michael Orlitzky
diff --git a/src/sage/algebras/quantum_groups/ace_quantum_onsager.py b/src/sage/algebras/quantum_groups/ace_quantum_onsager.py
@@ -26,12 +26,13 @@
 from sage.sets.family import Family
 from sage.rings.integer_ring import ZZ
 
+
 class ACEQuantumOnsagerAlgebra(CombinatorialFreeModule):
     r"""
     The alternating central extension of the `q`-Onsager algebra.
 
     The *alternating central extension* `\mathcal{A}_q` of the `q`-Onsager
-    alegbra `O_q` is a current algebra of `O_q` introduced by Baseilhac
+    algebra `O_q` is a current algebra of `O_q` introduced by Baseilhac
     and Koizumi [BK2005]_. A presentation was given by Baseilhac
     and Shigechi [BS2010]_, which was then reformulated in terms of currents
     in [Ter2021]_ and then used to prove that the generators form a PBW basis.
@@ -163,7 +164,7 @@ def _monomial_key(self, x):
 
             sage: A = algebras.AlternatingCentralExtensionQuantumOnsager(QQ)
             sage: AG = A.algebra_generators()
-            sage: AG[1,1] * AG[1,0] * AG[0,1]               # indirect doctest                                                                    
+            sage: AG[1,1] * AG[1,0] * AG[0,1]               # indirect doctest
             G[1]*W[0]*W[1] + (q/(q^2+1))*G[1]^2 + (-q/(q^2+1))*G[1]*Gt[1]
              + ((-q^8+2*q^4-1)/q^5)*W[-1]*W[1] + ((-q^8+2*q^4-1)/q^5)*W[0]^2
              + ((q^8-2*q^4+1)/q^5)*W[0]*W[2] + ((q^8-2*q^4+1)/q^5)*W[1]^2
@@ -276,6 +277,7 @@ def algebra_generators(self):
         """
         G = self._indices.gens()
         q = self._q
+
         def monomial_map(x):
             if x[0] != 1 and x[1] == 0:
                 return self.term(self.one_basis(), -(q-~q)*(q+~q)**2)
@@ -658,7 +660,7 @@ def sigma(self):
             sage: A = algebras.AlternatingCentralExtensionQuantumOnsager(QQ)
             sage: G = A.algebra_generators()
             sage: x = A.an_element()^2
-            sage: A.sigma(A.sigma(x)) == x                                                                                    
+            sage: A.sigma(A.sigma(x)) == x
             True
             sage: A.sigma(G[1,-1] * G[1,1]) == A.sigma(G[1,-1]) * A.sigma(G[1,1])
             True
@@ -677,7 +679,7 @@ def dagger(self):
             sage: A = algebras.AlternatingCentralExtensionQuantumOnsager(QQ)
             sage: G = A.algebra_generators()
             sage: x = A.an_element()^2
-            sage: A.dagger(A.dagger(x)) == x                                                                                    
+            sage: A.dagger(A.dagger(x)) == x
             True
             sage: A.dagger(G[1,-1] * G[1,1]) == A.dagger(G[1,1]) * A.dagger(G[1,-1])
             True
@@ -687,4 +689,3 @@ def dagger(self):
             True
         """
         return self.module_morphism(self._dagger_on_basis, codomain=self)
-
diff --git a/src/sage/combinat/abstract_tree.py b/src/sage/combinat/abstract_tree.py
@@ -1454,12 +1454,12 @@ def _latex_(self):
                 (a) edge (b) edge (e);
             \end{tikzpicture}}
         """
-        ###############################################################################
+        #######################################################################
         # load tikz in the preamble for *view*
         from sage.misc.latex import latex
         latex.add_package_to_preamble_if_available("tikz")
-        ###############################################################################
-        # latex environnement : TikZ
+        #######################################################################
+        # latex environment : TikZ
         begin_env = "\\begin{tikzpicture}[auto]\n"
         end_env = "\\end{tikzpicture}"
         # it uses matrix trick to place each node
diff --git a/src/sage/combinat/crystals/affine_factorization.py b/src/sage/combinat/crystals/affine_factorization.py
@@ -184,7 +184,7 @@ def _repr_(self):
         """
         return "Crystal on affine factorizations of type A{} associated to {}".format(self.n-1, self.w)
 
-    # temporary workaround while an_element is overriden by Parent
+    # temporary workaround while an_element is overridden by Parent
     _an_element_ = EnumeratedSets.ParentMethods._an_element_
 
     @lazy_attribute
diff --git a/src/sage/combinat/crystals/fully_commutative_stable_grothendieck.py b/src/sage/combinat/crystals/fully_commutative_stable_grothendieck.py
@@ -424,11 +424,12 @@ def list(self):
         """
         return _generate_decreasing_hecke_factorizations(self.w, self.factors, self.excess, parent=self)
 
-    # temporary workaround while an_element is overriden by Parent
+    # temporary workaround while an_element is overridden by Parent
     _an_element_ = EnumeratedSets.ParentMethods._an_element_
 
     Element = DecreasingHeckeFactorization
 
+
 class FullyCommutativeStableGrothendieckCrystal(UniqueRepresentation, Parent):
     """
     The crystal on fully commutative decreasing factorizations in the 0-Hecke
diff --git a/src/sage/combinat/designs/ext_rep.py b/src/sage/combinat/designs/ext_rep.py
@@ -961,8 +961,8 @@ def _char_data(self, data):
             #@ this stripping may distort char data in the <info> subtree
             # if they are not bracketed in some way.
             data = data.strip()
-            if data != '':
-                # we use the xtree's childrens list here to collect char data
+            if data:
+                # we use the xtree's children list here to collect char data
                 # since only leaves have char data.
                 self.current_node[2].append(data)
 
diff --git a/src/sage/combinat/designs/orthogonal_arrays.py b/src/sage/combinat/designs/orthogonal_arrays.py
@@ -1567,7 +1567,7 @@ def OA_n_times_2_pow_c_from_matrix(k,c,G,A,Y,check=True):
 
     - let `s_1` and `s_2` denote the two values of `s` given above, then exactly
       one of `C_{i,s_1} - C_{j,s_1}` and `C_{i,s_2} - C_{j,s_2}` belongs to the
-      `GF(2)`-hyperplane `(Y_i - Y_j) \cdot H` (we implicitely assumed that `Y_i
+      `GF(2)`-hyperplane `(Y_i - Y_j) \cdot H` (we implicitly assumed that `Y_i
       \not= Y_j`).
 
     Under these conditions, it is easy to check that the array whose `k-1` rows
diff --git a/src/sage/combinat/k_regular_sequence.py b/src/sage/combinat/k_regular_sequence.py
@@ -396,7 +396,7 @@ def from_recurrence(self, *args, **kwds):
           The recurrence relations above uniquely determine a `k`-regular sequence;
           see [HKL2021]_ for further information.
 
-        - ``function`` -- symbolic function ``f`` occuring in the equations
+        - ``function`` -- symbolic function ``f`` occurring in the equations
 
         - ``var`` -- symbolic variable (``n`` in the above description of ``equations``)
 
diff --git a/src/sage/combinat/recognizable_series.py b/src/sage/combinat/recognizable_series.py
@@ -926,7 +926,7 @@ def minimized(self):
 
         A :class:`RecognizableSeries`
 
-        ALOGRITHM:
+        ALGORITHM:
 
         This method implements the minimization algorithm presented in
         Chapter 2 of [BR2010a]_.
diff --git a/src/sage/combinat/root_system/cartan_type.py b/src/sage/combinat/root_system/cartan_type.py
@@ -924,7 +924,7 @@ class options(GlobalOptions):
             D_{5}^{(2)}
 
         For type `A_{2n}^{(2)\dagger}`, the dual string/latex options are
-        automatically overriden::
+        automatically overridden::
 
             sage: dct = CartanType(['A',8,2]).dual(); dct
             ['A', 8, 2]^+
diff --git a/src/sage/combinat/sf/orthotriang.py b/src/sage/combinat/sf/orthotriang.py
@@ -70,7 +70,7 @@ def __init__(self, Sym, base, scalar, prefix, basis_name, leading_coeff=None):
         .. NOTE::
 
             The base ring is required to be a `\QQ`-algebra for this
-            method to be useable, since the scalar product is defined by
+            method to be usable, since the scalar product is defined by
             its values on the power sum basis.
 
         EXAMPLES::
diff --git a/src/sage/combinat/sf/sfa.py b/src/sage/combinat/sf/sfa.py
@@ -1678,7 +1678,7 @@ def _change_by_plethysm(self, x, expr, deg_one):
             sage: s._change_by_plethysm(-a,-1,[])
             s[1, 1, 1]
         """
-        #Covert to the power sum
+        # Convert to the power sum
         p = self.realization_of().power()
         p_x = p(x)
         expr_k = lambda k: expr.subs(**dict([(str(x),x**k) for x in deg_one]))
@@ -2476,7 +2476,7 @@ def _dual_basis_default(self):
             sage: Sym.p()._dual_basis_default()
             Dual basis to Symmetric Functions over Rational Field in the powersum basis with respect to the Hall scalar product
 
-        This is meant to be overriden by subclasses for which an
+        This is meant to be overridden by subclasses for which an
         explicit dual basis is known::
 
             sage: Sym.s()._dual_basis_default()
diff --git a/src/sage/combinat/tableau.py b/src/sage/combinat/tableau.py
@@ -3699,7 +3699,7 @@ def flush(self):
         """
         for i in range(len(self)-1):
             if len(self[i]) <= len(self[i+1]):
-                raise ValueError('only defined for tableaux with stricly decreasing parts')
+                raise ValueError('only defined for tableaux with strictly decreasing parts')
         f = 0
         S = self._segments().items()
         for s in S:
diff --git a/src/sage/combinat/words/word_generators.py b/src/sage/combinat/words/word_generators.py
@@ -1753,7 +1753,7 @@ def s_adic(self, sequence, letters, morphisms=None):
             sage: words.s_adic(tmword, repeat('a'), [tm,fib])
             word: abbaababbaabbaabbaababbaababbaabbaababba...
 
-        The correspondance of the indices may be given as a dict::
+        The correspondence of the indices may be given as a dict::
 
             sage: words.s_adic(tmword, repeat('a'), {0:tm,1:fib})
             word: abbaababbaabbaabbaababbaababbaabbaababba...
diff --git a/src/sage/groups/galois_group.py b/src/sage/groups/galois_group.py
@@ -408,7 +408,7 @@ def _deg(self):
         This will be the degree of the original number field if `_gc_numbering``
         is ``False``, or the degree of the Galois closure otherwise.
 
-        EXAMPES::
+        EXAMPLES::
 
             sage: R.<x> = ZZ[]
             sage: K.<a> = NumberField(x^5-2)
diff --git a/src/sage/modular/modform/element.py b/src/sage/modular/modform/element.py
@@ -3146,12 +3146,12 @@ class GradedModularFormElement(ModuleElement):
         sage: M(D).parent()
         Ring of Modular Forms for Modular Group SL(2,Z) over Rational Field
 
-    A graded modular form can be initated via a dictionnary or a list::
+    A graded modular form can be initiated via a dictionary or a list::
 
         sage: E4 = ModularForms(1, 4).0
-        sage: M({4:E4, 12:D}) # dictionnary
+        sage: M({4:E4, 12:D})  # dictionary
         1 + 241*q + 2136*q^2 + 6972*q^3 + 16048*q^4 + 35070*q^5 + O(q^6)
-        sage: M([E4, D]) # list
+        sage: M([E4, D])  # list
         1 + 241*q + 2136*q^2 + 6972*q^3 + 16048*q^4 + 35070*q^5 + O(q^6)
 
     Also, when adding two modular forms of different weights, a graded modular form element will be created::
@@ -3218,7 +3218,7 @@ def __init__(self, parent, forms_datum):
         """
         forms_dictionary = {}
         if isinstance(forms_datum, dict):
-            for k,f in forms_datum.items():
+            for k, f in forms_datum.items():
                 if isinstance(k, (int, Integer)):
                     k = ZZ(k)
                     if k == 0:
@@ -3505,9 +3505,9 @@ def _lmul_(self, c):
 
         INPUT:
 
-        - ``c`` - an element of the base ring of self
+        - ``c`` -- an element of the base ring of self
 
-        OUPUT: A ``GradedModularFormElement``.
+        OUTPUT: A ``GradedModularFormElement``.
 
         TESTS::
 
diff --git a/src/sage/modular/modform/ring.py b/src/sage/modular/modform/ring.py
@@ -349,10 +349,9 @@ def polynomial_ring(self, names, gens=None):
         degs = [f.weight() for f in gens]
         return PolynomialRing(self.base_ring(), len(gens), names, order=TermOrder('wdeglex', degs)) # Should we remove the deg lexicographic ordering here?
 
-
     def _generators_variables_dictionnary(self, poly_parent, gens):
         r"""
-        Utility function that returns a dictionnary giving an association between
+        Utility function that returns a dictionary giving an association between
         polynomial ring generators and generators of modular forms ring.
 
         INPUT:
diff --git a/src/sage/modular/quasimodform/element.py b/src/sage/modular/quasimodform/element.py
@@ -65,16 +65,16 @@ class QuasiModularFormsElement(ModuleElement):
     """
     def __init__(self, parent, polynomial):
         r"""
-        INPUTS:
+        INPUT:
 
-        - ``parent`` - A quasimodular forms ring.
+        - ``parent`` - a quasimodular forms ring
         - ``polynomial`` - a polynomial `f_0 + f_1 E_2 + ... + f_n E_2^n` where
           each `f_i` are modular forms ring elements and `E_2` correspond to the
-          weight 2 Eisenstein series.
+          weight 2 Eisenstein series
 
         OUTPUT:
 
-        - ``QuasiModularFormsElement``
+        ``QuasiModularFormsElement``
 
         TESTS::
 
@@ -440,7 +440,7 @@ def weight(self):
 
     def homogeneous_components(self):
         r"""
-        Return a dictionnary where the values are the homogeneous components of
+        Return a dictionary where the values are the homogeneous components of
         the given graded form and the keys are the weights of those components.
 
         EXAMPLES::
@@ -458,13 +458,13 @@ def homogeneous_components(self):
         QM = self.parent()
         poly_self = self.to_polynomial()
         pol_hom_comp = poly_self.homogeneous_components()
-        return { k : QM.from_polynomial(pol) for k, pol in pol_hom_comp.items()}
+        return {k: QM.from_polynomial(pol) for k, pol in pol_hom_comp.items()}
 
     def serre_derivative(self):
         r"""
         Return the Serre derivative of the given quasimodular form.
 
-        If the form is not homogeneous, then this method sums the serre
+        If the form is not homogeneous, then this method sums the Serre
         derivative of each homogeneous component.
 
         EXAMPLES::
diff --git a/src/sage/modular/quasimodform/ring.py b/src/sage/modular/quasimodform/ring.py
@@ -9,15 +9,15 @@
 
 where `\sigma` is the sum of divisors function and `q = \mathrm{exp}(2\pi i z)`
 is the classical parameter at infinity, with `\mathrm{im}(z)>0`. This weight 2
-Eisenstein series is not a modular forms as it does not statisfies the
+Eisenstein series is not a modular form as it does not satisfy the
 modularity condition:
 
 .. MATH::
 
     z^2 E_2(-1/z) = E_2(z) + \frac{2k}{4\pi i B_k z}.
 
 `E_2` is a quasimodular form of weight 2. General quasimodular forms of given
-weight can also be defined. We denotes by `QM` the graded ring of quasimodular
+weight can also be defined. We denote by `QM` the graded ring of quasimodular
 forms for the full modular group `\mathrm{SL}_2(\ZZ)`.
 
 The SageMath implementation of the graded ring of quasimodular forms uses the
