trac #33980: typos in graphs

src/sage/graphs/bliss.pyx

@@ -525,7 +525,7 @@ cpdef canonical_form(G, partition=None, return_graph=False, use_edge_labels=True
     if partition:
         from itertools import chain
         int2vert = list(chain(*partition))
-        # We check that the partition constains only vertices of the graph
+        # We check that the partition contains only vertices of the graph
         # and that it is actually a partition
         seen = set()
         for u in int2vert:

src/sage/graphs/chrompoly.pyx

@@ -402,7 +402,7 @@ def chromatic_polynomial_with_cache(G, cache=None):
         sage: chromatic_polynomial_with_cache(graphs.CompleteBipartiteGraph(3,3))
         x^6 - 9*x^5 + 36*x^4 - 75*x^3 + 78*x^2 - 31*x
 
-    If a cache is provided, it is feeded::
+    If a cache is provided, it is fed::
 
         sage: cache = {}
         sage: G = graphs.CycleGraph(4)

src/sage/graphs/comparability.pyx

@@ -161,7 +161,7 @@ Implementation details
 This is done by a call to :meth:`Graph.is_bipartite`, and here is how :
 
    Around a vertex `u`, any two edges `uv, uv'` such that `vv'\not\in G` are
-   equivalent. Hence, the equivalence classe of edges around a vertex are
+   equivalent. Hence, the equivalence class of edges around a vertex are
    precisely the connected components of the complement of the graph induced by
    the neighbors of `u`.
 

src/sage/graphs/generators/distance_regular.pyx

@@ -1871,7 +1871,7 @@ def is_classical_parameters_graph(list array):
     from sage.combinat.q_analogues import q_binomial
 
     def integral_log(const int x, const int b):
-        # compute log_b(x) if is not a positive iteger, return -1
+        # compute log_b(x) if is not a positive integer, return -1
         if x <= 0:
             return -1
         k = log(x, b)
@@ -2358,7 +2358,7 @@ def is_near_polygon(array):
         sage: _.is_distance_regular(True)
         ([7, 6, 6, 5, 5, 4, None], [None, 1, 1, 2, 2, 3, 3])
 
-    REFERECES:
+    REFERENCES:
 
     See [BCN1989]_ pp. 198-206 for some theory about near polygons as well as
     a list of known examples.
@@ -2481,7 +2481,7 @@ def near_polygon_graph(family, params):
 
     - ``family`` -- int; an element of the enum ``NearPolygonGraph``.
 
-    - ``params`` -- int or tuple; the paramters needed to construct a graph
+    - ``params`` -- int or tuple; the parameters needed to construct a graph
       of the family ``family``.
 
     EXAMPLES::

src/sage/graphs/generators/families.py

@@ -1851,10 +1851,10 @@ def RoseWindowGraph(n, a, r):
 
     - ``n`` -- the number of nodes is `2 * n`
 
-    - ``a`` -- integer such that `1 \leq a < n` determing a-spoke edges
+    - ``a`` -- integer such that `1 \leq a < n` determining a-spoke edges
 
-    - ``r`` -- integer such that `1 \leq r < n` and `r \neq n / 2` determing how
-      inner vertices are connected
+    - ``r`` -- integer such that `1 \leq r < n` and `r \neq n / 2` determining
+      how inner vertices are connected
 
     PLOTTING: Upon construction, the position dictionary is filled to override
     the spring-layout algorithm. By convention, the rose window graphs are

src/sage/graphs/graph_decompositions/cutwidth.pyx

@@ -117,7 +117,7 @@ optimal layout for the cutwidth of `G`.
 
 - `z` -- Objective value to minimize. It is equal to the maximum over all
   position `k` of the number of edges with one extremity at position at most `k`
-  and the other at position stricly more than `k`, that is `\sum_{uv\in
+  and the other at position strictly more than `k`, that is `\sum_{uv\in
   E}y_{u,v}^{k}`.
 
 
@@ -142,7 +142,7 @@ optimal layout for the cutwidth of `G`.
 Constraints (1)-(3) ensure that all vertices have a distinct position.
 Constraints (4)-(5) force variable `y_{u,v}^k` to 1 if the edge is in the cut.
 Constraint (6) count the number of edges starting at position at most `k` and
-ending at a position stricly larger than `k`.
+ending at a position strictly larger than `k`.
 
 This formulation corresponds to method :meth:`cutwidth_MILP`.
 

src/sage/graphs/graph_decompositions/modular_decomposition.py

@@ -2962,7 +2962,7 @@ def test_module(module, graph):
 # Function implemented for testing
 def children_node_type(module, node_type):
     """
-    Check whether the node type of the childrens of ``module`` is ``node_type``.
+    Check whether the node type of the children of ``module`` is ``node_type``.
 
     INPUT:
 

src/sage/graphs/graph_decompositions/tree_decomposition.pyx

@@ -5,7 +5,7 @@ Tree decompositions
 This module implements tree-decomposition methods.
 
 A tree-decomposition of a graph `G = (V, E)` is a pair `(X, T)`, where `X=\{X_1,
-X_2, \ldots, X_t\}` is a familly of subsets of `V`, usually called *bags*, and
+X_2, \ldots, X_t\}` is a family of subsets of `V`, usually called *bags*, and
 `T` is a tree of order `t` whose nodes are the subsets `X_i` satisfying the
 following properties:
 
@@ -33,7 +33,7 @@ dist_G(u, v)`). The *treelength* `tl(G)` of a graph `G` is the minimum length
 among all possible tree decompositions of `G`.
 
 While deciding whether a graph has treelength 1 can be done in linear time
-(equivalant to deciding if the graph is chordal), deciding if it has treelength
+(equivalent to deciding if the graph is chordal), deciding if it has treelength
 at most `k` for any fixed constant `k \leq 2` is NP-complete [Lokshtanov2009]_.
 
 Treewidth and treelength are different measures of tree-likeness. In particular,

src/sage/graphs/spanning_tree.pyx

@@ -1305,7 +1305,7 @@ def edge_disjoint_spanning_trees(G, k, by_weight=False, weight_function=None, ch
 
     # Initialization of data structures
 
-    # - partition[0] is used to maitain known clumps.
+    # - partition[0] is used to maintain known clumps.
     # - partition[i], 1 <= i <= k, is used to check if a given edge has both its
     #   endpoints in the same tree of forest Fi.
     partition = [DisjointSet_of_hashables(G) for _ in range(k + 1)]