Trac #34289: minor tweaks in the doc

little details, mainly cosmetics

URL: https://trac.sagemath.org/34289
Reported by: chapoton
Ticket author(s): Frédéric Chapoton
Reviewer(s): Matthias Koeppe

src/doc/en/developer/coding_in_other.rst

@@ -106,8 +106,7 @@ convert output from PARI to Sage objects:
 
     def frobenius(self, flag=0, var='x'):
         """
-        Return the Frobenius form (rational canonical form) of this
-        matrix.
+        Return the Frobenius form (rational canonical form) of this matrix.
 
         INPUT:
 
@@ -125,7 +124,7 @@ convert output from PARI to Sage objects:
 
         -  ``var`` -- a string (default: 'x')
 
-        ALGORITHM: uses PARI's matfrobenius()
+        ALGORITHM: uses PARI's :pari:`matfrobenius`
 
         EXAMPLES::
 
@@ -143,15 +142,15 @@ convert output from PARI to Sage objects:
             raise ArithmeticError("frobenius matrix of non-square matrix not defined.")
 
         v = self.__pari__().matfrobenius(flag)
-        if flag==0:
+        if flag == 0:
             return self.matrix_space()(v.python())
-        elif flag==1:
+        elif flag == 1:
             r = PolynomialRing(self.base_ring(), names=var)
             retr = []
             for f in v:
                 retr.append(eval(str(f).replace("^","**"), {'x':r.gen()}, r.gens_dict()))
             return retr
-        elif flag==2:
+        elif flag == 2:
             F = matrix_space.MatrixSpace(QQ, self.nrows())(v[0].python())
             B = matrix_space.MatrixSpace(QQ, self.nrows())(v[1].python())
             return F, B
@@ -212,11 +211,13 @@ object.
         Return the Cartan matrix of given Chevalley type and rank.
 
         INPUT:
-            type -- a Chevalley letter name, as a string, for
-                    a family type of simple Lie algebras
-            rank -- an integer (legal for that type).
 
-        EXAMPLES:
+        - type -- a Chevalley letter name, as a string, for
+          a family type of simple Lie algebras
+        - rank -- an integer (legal for that type).
+
+        EXAMPLES::
+
             sage: cartan_matrix("A",5)
             [ 2 -1  0  0  0]
             [-1  2 -1  0  0]
@@ -227,12 +228,11 @@ object.
             [ 2 -1]
             [-3  2]
         """
-
-        L = gap.SimpleLieAlgebra('"%s"'%type, rank, 'Rationals')
+        L = gap.SimpleLieAlgebra('"%s"' % type, rank, 'Rationals')
         R = L.RootSystem()
         sM = R.CartanMatrix()
         ans = eval(str(sM))
-        MS  = MatrixSpace(QQ, rank)
+        MS = MatrixSpace(QQ, rank)
         return MS(ans)
 
 The output ``ans`` is a Python list. The last two lines convert that
@@ -460,50 +460,51 @@ just that.
 
 .. CODE-BLOCK:: python
 
-    def points_parser(string_points,F):
+    def points_parser(string_points, F):
         """
         This function will parse a string of points
         of X over a finite field F returned by Singular's NSplaces
         command into a Python list of points with entries from F.
 
-        EXAMPLES:
+        EXAMPLES::
+
             sage: F = GF(5)
             sage: points_parser(L,F)
             ((0, 1, 0), (3, 4, 1), (0, 0, 1), (2, 3, 1), (3, 1, 1), (2, 2, 1))
         """
-        Pts=[]
-        n=len(L)
-        #start block to compute a pt
-        L1=L
-        while len(L1)>32:
-            idx=L1.index("     ")
-            pt=[]
-            ## start block1 for compute pt
-            idx=L1.index("     ")
-            idx2=L1[idx:].index("\n")
-            L2=L1[idx:idx+idx2]
+        Pts = []
+        n = len(L)
+        # start block to compute a pt
+        L1 = L
+        while len(L1) > 32:
+            idx =L1.index("     ")
+            pt = []
+            # start block1 for compute pt
+            idx = L1.index("     ")
+            idx2 = L1[idx:].index("\n")
+            L2 = L1[idx:idx+idx2]
             pt.append(F(eval(L2)))
             # end block1 to compute pt
-            L1=L1[idx+8:] # repeat block 2 more times
-            ## start block2 for compute pt
-            idx=L1.index("     ")
-            idx2=L1[idx:].index("\n")
-            L2=L1[idx:idx+idx2]
+            L1 = L1[idx+8:] # repeat block 2 more times
+            # start block2 for compute pt
+            idx = L1.index("     ")
+            idx2 = L1[idx:].index("\n")
+            L2 = L1[idx:idx+idx2]
             pt.append(F(eval(L2)))
             # end block2 to compute pt
             L1=L1[idx+8:] # repeat block 1 more time
-            ## start block3 for compute pt
+            # start block3 for compute pt
             idx=L1.index("     ")
             if "\n" in L1[idx:]:
-                idx2=L1[idx:].index("\n")
+                idx2 = L1[idx:].index("\n")
             else:
-                idx2=len(L1[idx:])
-            L2=L1[idx:idx+idx2]
+                idx2 = len(L1[idx:])
+            L2 = L1[idx:idx+idx2]
             pt.append(F(eval(L2)))
             # end block3 to compute pt
-            #end block to compute a pt
+            # end block to compute a pt
             Pts.append(tuple(pt))  # repeat until no more pts
-            L1=L1[idx+8:] # repeat block 2 more times
+            L1 = L1[idx+8:] # repeat block 2 more times
         return tuple(Pts)
 
 Now it is an easy matter to put these ingredients together into a Sage
@@ -519,20 +520,23 @@ ourselves to points of degree one.
 
 .. CODE-BLOCK:: python
 
-    def places_on_curve(f,F):
+    def places_on_curve(f, F):
         """
         INPUT:
-            f -- element of F[x,y], defining X: f(x,y)=0
-            F -- a finite field of *prime order*
+
+        - f -- element of F[x,y], defining X: f(x,y)=0
+        - F -- a finite field of *prime order*
 
         OUTPUT:
-            integer -- the number of places in X of degree d=1 over F
 
-        EXAMPLES:
-            sage: F=GF(5)
-            sage: R=PolynomialRing(F,2,names=["x","y"])
-            sage: x,y=R.gens()
-            sage: f=y^2-x^9-x
+        integer -- the number of places in X of degree d=1 over F
+
+        EXAMPLES::
+
+            sage: F = GF(5)
+            sage: R = PolynomialRing(F,2,names=["x","y"])
+            sage: x,y = R.gens()
+            sage: f = y^2-x^9-x
             sage: places_on_curve(f,F)
             ((0, 1, 0), (3, 4, 1), (0, 0, 1), (2, 3, 1), (3, 1, 1), (2, 2, 1))
         """
@@ -600,7 +604,7 @@ function is not required:
 
 .. CODE-BLOCK:: python
 
-    def places_on_curve(f,F):
+    def places_on_curve(f, F):
         p = F.characteristic()
         if F.degree() > 1:
             raise NotImplementedError
@@ -677,7 +681,7 @@ This uses the class ``Expect`` to set up the Octave interface:
             """
             Set the variable var to the given value.
             """
-            cmd = '%s=%s;'%(var,value)
+            cmd = '%s=%s;' % (var,value)
             out = self.eval(cmd)
             if out.find("error") != -1:
                 raise TypeError("Error executing code in Octave\nCODE:\n\t%s\nOctave ERROR:\n\t%s"%(cmd, out))
@@ -686,7 +690,7 @@ This uses the class ``Expect`` to set up the Octave interface:
             """
             Get the value of the variable var.
             """
-            s = self.eval('%s'%var)
+            s = self.eval('%s' % var)
             i = s.find('=')
             return s[i+1:]
 
@@ -729,16 +733,16 @@ dumps the user into an Octave interactive shell:
                 raise ValueError("dimensions of A and b must be compatible")
             from sage.matrix.all import MatrixSpace
             from sage.rings.all import QQ
-            MS = MatrixSpace(QQ,m,1)
-            b  = MS(list(b)) # converted b to a "column vector"
+            MS = MatrixSpace(QQ, m, 1)
+            b  = MS(list(b))  # converted b to a "column vector"
             sA = self.sage2octave_matrix_string(A)
             sb = self.sage2octave_matrix_string(b)
             self.eval("a = " + sA )
             self.eval("b = " + sb )
             soln = octave.eval("c = a \\ b")
-            soln = soln.replace("\n\n ","[")
-            soln = soln.replace("\n\n","]")
-            soln = soln.replace("\n",",")
+            soln = soln.replace("\n\n ", "[")
+            soln = soln.replace("\n\n", "]")
+            soln = soln.replace("\n", ",")
             sol  = soln[3:]
             return eval(sol)
 

src/doc/en/thematic_tutorials/algebraic_combinatorics/n_cube.rst

@@ -19,8 +19,8 @@ The vertices of the `n`-cube can be described by vectors in
 The distance function measures in how many slots two vectors in
 `\mathbb{Z}_2^n` differ::
 
-    sage: u=(1,0,1,1,1,0)
-    sage: v=(0,0,1,1,0,0)
+    sage: u = (1,0,1,1,1,0)
+    sage: v = (0,0,1,1,0,0)
     sage: dist(u,v)
     2
 

src/doc/en/thematic_tutorials/lie/affine.rst

@@ -381,7 +381,7 @@ The column vector `a` with these entries spans the nullspace of `A`::
 
     sage: RS = RootSystem(['E',6,2]); RS
     Root system of type ['F', 4, 1]^*
-    sage: A=RS.cartan_matrix(); A
+    sage: A = RS.cartan_matrix(); A
     [ 2 -1  0  0  0]
     [-1  2 -1  0  0]
     [ 0 -1  2 -2  0]
@@ -471,4 +471,3 @@ It may be constructed in Sage as follows::
 See the documentation in
 :mod:`~sage.combinat.root_system.extended_affine_weyl_group`
 if you need this.
-

src/doc/en/thematic_tutorials/lie/branching_rules.rst

@@ -50,7 +50,7 @@ Sage has a class ``BranchingRule`` for branching rules. The function
 the natural embedding of `Sp(4)` into `SL(4)` corresponds to
 the branching rule that we may create as follows::
 
-    sage: b=branching_rule("A3","C2",rule="symmetric"); b
+    sage: b = branching_rule("A3","C2",rule="symmetric"); b
     symmetric branching rule A3 => C2
 
 The name "symmetric" of this branching rule will be
@@ -62,10 +62,10 @@ Here ``A3`` and ``C2`` are the Cartan types of the groups
 Now we may see how representations of `SL(4)` decompose
 into irreducibles when they are restricted to `Sp(4)`::
 
-    sage: A3=WeylCharacterRing("A3",style="coroots")
-    sage: chi=A3(1,0,1); chi.degree()
+    sage: A3 = WeylCharacterRing("A3",style="coroots")
+    sage: chi = A3(1,0,1); chi.degree()
     15
-    sage: C2=WeylCharacterRing("C2",style="coroots")
+    sage: C2 = WeylCharacterRing("C2",style="coroots")
     sage: chi.branch(C2,rule=b)
     C2(0,1) + C2(2,0)
 
@@ -95,13 +95,13 @@ Observe that we do not have to build the intermediate
 
 ::
 
-    sage: C4=WeylCharacterRing("C4",style="coroots")
-    sage: b1=branching_rule("C4","A3","levi")*branching_rule("A3","C2","symmetric"); b1
+    sage: C4 = WeylCharacterRing("C4",style="coroots")
+    sage: b1 = branching_rule("C4","A3","levi")*branching_rule("A3","C2","symmetric"); b1
     composite branching rule C4 => (levi) A3 => (symmetric) C2
-    sage: b2=branching_rule("C4","C2xC2","orthogonal_sum")*branching_rule("C2xC2","C2","proj1"); b2
+    sage: b2 = branching_rule("C4","C2xC2","orthogonal_sum")*branching_rule("C2xC2","C2","proj1"); b2
     composite branching rule C4 => (orthogonal_sum) C2xC2 => (proj1) C2
-    sage: C2=WeylCharacterRing("C2",style="coroots")
-    sage: C4=WeylCharacterRing("C4",style="coroots")
+    sage: C2 = WeylCharacterRing("C2",style="coroots")
+    sage: C4 = WeylCharacterRing("C4",style="coroots")
     sage: [C4(2,0,0,1).branch(C2, rule=br) for br in [b1,b2]]
     [4*C2(0,0) + 7*C2(0,1) + 15*C2(2,0) + 7*C2(0,2) + 11*C2(2,1) + C2(0,3) + 6*C2(4,0) + 3*C2(2,2),
      10*C2(0,0) + 40*C2(1,0) + 50*C2(0,1) + 16*C2(2,0) + 20*C2(1,1) + 4*C2(3,0) + 5*C2(2,1)]
@@ -187,7 +187,7 @@ Sage has a database of maximal subgroups for every simple Cartan
 type of rank `\le 8`. You may access this with the
 ``maximal_subgroups`` method of the Weyl character ring::
 
-    sage: E7=WeylCharacterRing("E7",style="coroots")
+    sage: E7 = WeylCharacterRing("E7",style="coroots")
     sage: E7.maximal_subgroups()
     A7:branching_rule("E7","A7","extended")
     E6:branching_rule("E7","E6","levi")
@@ -212,7 +212,7 @@ as follows::
 
     sage: b = E7.maximal_subgroup("A2"); b
     miscellaneous branching rule E7 => A2
-    sage: [E7,A2]=[WeylCharacterRing(x,style="coroots") for x in ["E7","A2"]]
+    sage: E7, A2 = [WeylCharacterRing(x,style="coroots") for x in ["E7","A2"]]
     sage: E7(1,0,0,0,0,0,0).branch(A2,rule=b)
     A2(1,1) + A2(4,4)
 
@@ -236,8 +236,8 @@ complete up to inner automorphisms.  For example, `E_6` has a
 nontrivial Dynkin diagram automorphism so it has an outer
 automorphism that is not inner::
 
-    sage: [E6,A2xG2]=[WeylCharacterRing(x,style="coroots") for x in ["E6","A2xG2"]]
-    sage: b=E6.maximal_subgroup("A2xG2"); b
+    sage: E6, A2xG2 = [WeylCharacterRing(x,style="coroots") for x in ["E6","A2xG2"]]
+    sage: b = E6.maximal_subgroup("A2xG2"); b
     miscellaneous branching rule E6 => A2xG2
     sage: E6(1,0,0,0,0,0).branch(A2xG2,rule=b)
     A2xG2(0,1,1,0) + A2xG2(2,0,0,0)
@@ -250,7 +250,7 @@ the `A_2\times G_2` subgroup is changed to a different one
 by the outer automorphism. To obtain the second branching
 rule, we compose the given one with this automorphism::
 
-    sage: b1=branching_rule("E6","E6","automorphic")*b; b1
+    sage: b1 = branching_rule("E6","E6","automorphic")*b; b1
     composite branching rule E6 => (automorphic) E6 => (miscellaneous) A2xG2
 
 .. _levi_branch_rules:
@@ -533,8 +533,8 @@ construct the branching rule to `A_5` we may proceed as follows::
 
     sage: b = branching_rule("E6","A5xA1","extended")*branching_rule("A5xA1","A5","proj1"); b
     composite branching rule E6 => (extended) A5xA1 => (proj1) A5
-    sage: E6=WeylCharacterRing("E6",style="coroots")
-    sage: A5=WeylCharacterRing("A5",style="coroots")
+    sage: E6 = WeylCharacterRing("E6",style="coroots")
+    sage: A5 = WeylCharacterRing("A5",style="coroots")
     sage: E6(0,1,0,0,0,0).branch(A5,rule=b)
     3*A5(0,0,0,0,0) + 2*A5(0,0,1,0,0) + A5(1,0,0,0,1)
     sage: b.describe()
@@ -1006,7 +1006,7 @@ representation of `SO(8)` and the two
 eight-dimensional spin representations. These are
 permuted by triality::
 
-    sage: D4=WeylCharacterRing("D4",style="coroots")
+    sage: D4 = WeylCharacterRing("D4",style="coroots")
     sage: D4(0,0,0,1).branch(D4,rule="triality")
     D4(1,0,0,0)
     sage: D4(0,0,0,1).branch(D4,rule="triality").branch(D4,rule="triality")
@@ -1021,4 +1021,3 @@ spin representations, as it always does in type `D`::
     D4(0,0,1,0)
     sage: D4(0,0,1,0).branch(D4,rule="automorphic")
     D4(0,0,0,1)
-