fix a bunch of typos

Author: fchapoton

src/sage/combinat/words/finite_word.py

@@ -217,6 +217,7 @@
 from itertools import repeat
 from collections import defaultdict
 from itertools import islice, cycle
+
 from sage.combinat.words.abstract_word import Word_class
 from sage.combinat.words.words import Words
 from sage.misc.cachefunc import cached_method
@@ -2622,7 +2623,7 @@ def palindromic_lacunas_study(self, f=None):
         and lacunas of ``self`` (see [BMBL2008]_ and [BMBFLR2008]_).
 
         Note that a word `w` has at most `|w| + 1` different palindromic factors
-        (see [DJP2001]_). For `f`-palindromes (or pseudopalidromes or theta-palindromes),
+        (see [DJP2001]_). For `f`-palindromes (or pseudopalindromes or theta-palindromes),
         the maximum number of `f`-palindromic factors is `|w|+1-g_f(w)`, where
         `g_f(w)` is the number of pairs `\{a, f(a)\}` such that `a` is a letter,
         `a` is not equal to `f(a)`, and `a` or `f(a)` occurs in `w`, see [Star2011]_.

src/sage/dynamics/arithmetic_dynamics/berkovich_ds.py

@@ -1,5 +1,5 @@
 r"""
-Dynamical systmes on Berkovich space over `\CC_p`.
+Dynamical systems on Berkovich space over `\CC_p`.
 
 A dynamical system on Berkovich space over `\CC_p` is
 determined by a dynamical system on `A^1(\CC_p)` or `P^1(\CC_p)`,

src/sage/dynamics/arithmetic_dynamics/endPN_automorphism_group.py

@@ -1907,7 +1907,7 @@ def conjugating_set_initializer(f, g):
             repeated_mult_L[repeated] += [mult_to_point_L[mult_L]]
     more = True
 
-    # the n+2 points to be used to specificy PGL conjugations
+    # the n+2 points to be used to specify PGL conjugations
     source = []
 
     # a list of tuples of the form ((multiplier, level), repeat) where the
@@ -1997,9 +1997,10 @@ def conjugating_set_initializer(f, g):
             for r in sorted(repeated_mult_L.keys()):
                 for point_lst in repeated_mult_L[r]:
                     all_points += point_lst
-            # this loop is quite long, so we break after finding the first subset
-            # with the desired property. There is, however, no guarentee that the
-            # subset we found minimizes the combinatorics when checking conjugations
+            # this loop is quite long, so we break after finding the
+            # first subset with the desired property. There is,
+            # however, no guarantee that the subset we found minimizes
+            # the combinatorics when checking conjugations
             for subset in Subsets(range(len(all_points)), n+2):
                 source = []
                 for i in subset:
@@ -2166,10 +2167,10 @@ def conjugating_set_helper(f, g, num_cpus, source, possible_targets):
         subset_iterators.append(Subsets(range(len(lst[0])), lst[1]))
 
     # helper function for parallelization
-    # given a list of tuples which specify indicies of possible target points
-    # in possible_targets, check all arragements of those possible target points
-    # and if any of them define a conjugation which sends f to g, return
-    # those conjugations as a list
+    # given a list of tuples which specify indices of possible target
+    # points in possible_targets, check all arrangements of those
+    # possible target points and if any of them define a conjugation
+    # which sends f to g, return those conjugations as a list
     def find_conjugations_subset(tuples):
         conj = []
         for tup in tuples:
@@ -2195,9 +2196,9 @@ def find_conjugations_subset(tuples):
         return conj
 
     # helper function for parallelization
-    # given a list of tuples which specify indicies of possible target points
-    # in possible_targets, check all possible target points
-    # and if any of them define a conjugation which sends f to g, return
+    # given a list of tuples which specify indices of possible target
+    # points in possible_targets, check all possible target points and
+    # if any of them define a conjugation which sends f to g, return
     # those conjugations as a list
     def find_conjugations_arrangement(tuples):
         conj = []
@@ -2229,7 +2230,7 @@ def find_conjugations_arrangement(tuples):
                 if ret[1]:
                     Conj += ret[1]
         # otherwise, we need to first check linear independence of the subsets
-        # and then build a big list of all the arrangemenets to split among
+        # and then build a big list of all the arrangements to split among
         # the threads
         else:
             good_targets = []
@@ -2307,9 +2308,10 @@ def is_conjugate_helper(f, g, num_cpus, source, possible_targets):
         subset_iterators.append(Subsets(range(len(lst[0])), lst[1]))
 
     # helper function for parallelization
-    # given a list of tuples which specify indicies of possible target points
-    # in possible_targets, check all arragements of those possible target points
-    # and if any of them define a conjugation which sends f to g, return True
+    # given a list of tuples which specify indices of possible target
+    # points in possible_targets, check all arrangements of those
+    # possible target points and if any of them define a conjugation
+    # which sends f to g, return True
     def find_conjugations_subset(tuples):
         for tup in tuples:
             target_set = []
@@ -2334,7 +2336,7 @@ def find_conjugations_subset(tuples):
         return False
 
     # helper function for parallelization
-    # given a list of tuples which specify indicies of possible target points
+    # given a list of tuples which specify indices of possible target points
     # in possible_targets, check all possible target points
     # and if any of them define a conjugation which sends f to g, return True
     def find_conjugations_arrangement(tuples):
@@ -2367,7 +2369,7 @@ def find_conjugations_arrangement(tuples):
                     is_conj = True
                     break
         # otherwise, we need to first check linear independence of the subsets
-        # and then build a big list of all the arrangemenets to split among
+        # and then build a big list of all the arrangements to split among
         # the threads
         else:
             good_targets = []

src/sage/dynamics/arithmetic_dynamics/projective_ds.py

@@ -4219,7 +4219,7 @@ def preperiodic_points(self, m, n, **kwds):
                     f_deformed = DynamicalSystem(deformed_polys)
 
                     # after deforming by the parameter, the preperiodic points with multiplicity
-                    # will seperate into different points. we can now calculate the minimal preperiodic
+                    # will separate into different points. we can now calculate the minimal preperiodic
                     # points with the parameter, and then specialize to get the formal preperiodic points
                     ideal = f_deformed.preperiodic_points(m, n, return_scheme=True).defining_ideal()
                     L = [poly.specialization({t:0}) for poly in ideal.gens()]
@@ -4569,7 +4569,7 @@ def periodic_points(self, n, minimal=True, formal=False, R=None, algorithm='vari
                             f_deformed = DynamicalSystem(deformed_polys)
 
                             # after deforming by the parameter, the preperiodic points with multiplicity
-                            # will seperate into different points. we can now calculate the minimal preperiodic
+                            # will separate into different points. we can now calculate the minimal preperiodic
                             # points with the parameter, and then specialize to get the formal periodic points
                             ideal = f_deformed.periodic_points(n, return_scheme=True).defining_ideal()
                             L = [poly.specialization({t:0}) for poly in ideal.gens()]
@@ -4901,7 +4901,7 @@ def sigma_invariants(self, n, formal=False, embedding=None, type='point',
 
         - ``n`` periodic points are repeated, multipliers are all distinct -- to deal
           with this case, we deform the map by a formal parameter `k`. The deformation
-          seperates the ``n`` periodic points, making them distinct, and we can recover
+          separates the ``n`` periodic points, making them distinct, and we can recover
           the ``n`` periodic points of the original map by specializing `k` to 0.
           This corresponds to ``deform=True``.
 
@@ -4952,7 +4952,7 @@ def sigma_invariants(self, n, formal=False, embedding=None, type='point',
 
         - ``check`` -- (default: ``True``) boolean; when ``True`` the degree of
           the sigma polynomial is checked against the expected degree. This is
-          done as the sigma polynomial may drop degree if multiplicites of periodic
+          done as the sigma polynomial may drop degree if multiplicities of periodic
           points or multipliers are not correctly accounted for using ``chow`` or
           ``deform``.
 
@@ -5236,8 +5236,8 @@ def sigma_invariants(self, n, formal=False, embedding=None, type='point',
                     # create polynomial ring for result
                     R2 = PolynomialRing(F, var[:N] + var[-2:])
                     psi = R2.hom(N*[0]+list(newR.gens()), newR)
-                    # create substition to set extra variables to 0
-                    R_zero = {R.gen(N):1}
+                    # create substitution to set extra variables to 0
+                    R_zero = {R.gen(N): 1}
                     for j in range(N+1, 2*N+1):
                         R_zero[R.gen(j)] = 0
                     t = var.pop()
@@ -5251,7 +5251,7 @@ def sigma_invariants(self, n, formal=False, embedding=None, type='point',
                     w = var.pop()
                 sigma_polynomial = 1
                 # go through each affine patch to avoid repeating periodic points
-                # setting the visited coordiantes to 0 as we go
+                # setting the visited coordinates to 0 as we go
                 for j in range(N,-1,-1):
                     Xa = X.affine_patch(j)
                     fa = Fn.dehomogenize(j)
@@ -5308,7 +5308,7 @@ def sigma_invariants(self, n, formal=False, embedding=None, type='point',
                                      'try setting chow=True and/or deform=True')
             if return_polynomial:
                 return sigma_polynomial
-            # if we are returing a numerical list, read off the coefficients
+            # if we are returning a numerical list, read off the coefficients
             # in order of degree adjusting sign appropriately
             sigmas = []
             sigma_dictionary = dict([list(reversed(i)) for i in list(sigma_polynomial)])
@@ -6833,7 +6833,7 @@ def conjugating_set(self, other, R=None, num_cpus=2):
         by taking the fixed points of one map and mapping
         them to permutations of the fixed points of the other map.
         As conjugacy preserves the multipliers as a set, fixed points
-        are only maped to fixed points with the same multiplier.
+        are only mapped to fixed points with the same multiplier.
         If there are not enough fixed points the
         function compares the mapping between rational preimages of
         fixed points and the rational preimages of the preimages of

src/sage/ext_data/pari/simon/ell.gp

@@ -1503,7 +1503,7 @@ if( DEBUGLEVEL_ell >= 4, print("    end of bnfredquartique"));
 \\ si bigflag !=0 alors on applique bnfredquartique.
 \\ si flag3 ==1 alors on utilise bnfqfsolve2 (equation aux normes) pour resoudre Legendre
 \\ aut est une liste d'automorphismes connus de bnf
-\\ (ca peut aider a factoriser certains discriminiants).
+\\ (ca peut aider a factoriser certains discriminants).
 \\ ell est de la forme y^2=x^3+A*x^2+B*x+C
 \\ ie ell=[0,A,0,B,C], avec A,B et C entiers.
 \\

src/sage/graphs/graph_decompositions/modular_decomposition.py

@@ -1278,7 +1278,7 @@ def permute_decomposition(trials, algorithm, vertices, prob, verbose=False):
         t1p = relabel_tree(t1, random_perm)
         assert(equivalent_trees(t1p, t2))
         if verbose:
-            print("Passses!")
+            print("Passes!")
 
 
 def random_md_tree(max_depth, max_fan_out, leaf_probability):

src/sage/groups/braid.py

@@ -2200,7 +2200,7 @@ def reduced_word(self):
 
         .. TODO::
 
-            Paralellize this function, calculating all summands in the sum
+            Parallelize this function, calculating all summands in the sum
             in parallel.
         """
         M = self._algebra._indices
@@ -2245,7 +2245,7 @@ def eps(self, N):
 
         .. TODO::
 
-            Paralellize this function, calculating all summands in the sum
+            Parallelize this function, calculating all summands in the sum
             in parallel.
         """
         def eps_monom(q_tuple):

src/sage/knots/knotinfo.py

@@ -117,7 +117,7 @@
     sage: l6sn.sage_link().is_isotopic(l6)     # optional - snappy
     True
 
-But observe that the name conversion to SnapPy does not distingiush orientation
+But observe that the name conversion to SnapPy does not distinguish orientation
 types::
 
     sage: L6b = KnotInfo.L6a1_1

src/sage/rings/padics/relaxed_template.pxi

@@ -702,7 +702,7 @@ cdef class RelaxedElement(pAdicGenericElement):
           use the default halting precision of the parent
 
         - ``secure`` -- a boolean (default: ``False`` if ``prec`` is given,
-          ``True`` otherwise); when the elements cannot be distingiushed
+          ``True`` otherwise); when the elements cannot be distinguished
           at the given precision, raise an error if ``secure`` is ``True``,
           return ``True`` otherwise.
 

src/sage/rings/polynomial/skew_polynomial_finite_field.pyx

@@ -822,10 +822,9 @@ cdef class SkewPolynomial_finite_field_dense(SkewPolynomial_finite_order_dense):
         factors.reverse()
         return Factorization(factors, sort=False, unit=unit)
 
-
     cdef _factor_uniform_c(self):
         r"""
-        Compute a uniformly distrbuted factorization of ``self``.
+        Compute a uniformly distributed factorization of ``self``.
 
         This is the low level implementation of :meth:`factor`.
         """