src/sage/combinat/root_system: Add # optional

Author: Matthias Koeppe

src/sage/combinat/root_system/type_A.py

@@ -22,7 +22,7 @@ class AmbientSpace(ambient_space.AmbientSpace):
         sage: R = RootSystem(["A",3])
         sage: e = R.ambient_space(); e
         Ambient space of the Root system of type ['A', 3]
-        sage: TestSuite(e).run()
+        sage: TestSuite(e).run()                                                        # optional - sage.graphs
 
     By default, this ambient space uses the barycentric projection for plotting::
 

src/sage/combinat/root_system/type_C.py

@@ -31,7 +31,7 @@ class AmbientSpace(ambient_space.AmbientSpace):
 
     TESTS::
 
-        sage: TestSuite(e).run()
+        sage: TestSuite(e).run()                                                        # optional - sage.graphs
     """
 
     def dimension(self):

src/sage/combinat/root_system/type_F.py

@@ -37,7 +37,7 @@ def __init__(self, root_system, base_ring):
 
         TESTS::
 
-            sage: TestSuite(e).run()
+            sage: TestSuite(e).run()                                                    # optional - sage.graphs
         """
         ambient_space.AmbientSpace.__init__(self, root_system, base_ring)
         v = ZZ(1)/ZZ(2)

src/sage/combinat/root_system/type_affine.py

@@ -37,7 +37,7 @@ class AmbientSpace(CombinatorialFreeModule):
         In type `BC`, the null root is in fact::
 
             sage: R = RootSystem(["BC",3,2]).ambient_space()
-            sage: R.null_root()
+            sage: R.null_root()                                                         # optional - sage.graphs
             2*e['delta']
 
     .. WARNING::
@@ -54,16 +54,16 @@ class AmbientSpace(CombinatorialFreeModule):
         are identified::
 
             sage: L = RootSystem(["A",3,1]).ambient_space()
-            sage: Lambda = L.fundamental_weights()
-            sage: Lambda[0]
+            sage: Lambda = L.fundamental_weights()                                      # optional - sage.graphs
+            sage: Lambda[0]                                                             # optional - sage.graphs
             e['deltacheck']
-            sage: L.null_coroot()
+            sage: L.null_coroot()                                                       # optional - sage.graphs
             e['deltacheck']
 
         Therefore the scalar product of the null coroot with itself
         differs from the larger ambient space::
 
-            sage: L.null_coroot().scalar(L.null_coroot())
+            sage: L.null_coroot().scalar(L.null_coroot())                               # optional - sage.graphs
             1
 
         In general, scalar products between two elements that do not
@@ -108,7 +108,7 @@ class AmbientSpace(CombinatorialFreeModule):
 
     TESTS::
 
-        sage: Lambda[1]
+        sage: Lambda[1]                                                                 # optional - sage.graphs
         e[0] + e['deltacheck']
     """
     @classmethod
@@ -247,36 +247,43 @@ def fundamental_weight(self, i):
 
         EXAMPLES::
 
-            sage: RootSystem(['A',3,1]).ambient_space().fundamental_weight(2)
+            sage: RootSystem(['A',3,1]).ambient_space().fundamental_weight(2)           # optional - sage.graphs
             e[0] + e[1] + e['deltacheck']
-            sage: RootSystem(['A',3,1]).ambient_space().fundamental_weights()
-            Finite family {0: e['deltacheck'], 1: e[0] + e['deltacheck'],
-                           2: e[0] + e[1] + e['deltacheck'], 3: e[0] + e[1] + e[2] + e['deltacheck']}
+            sage: RootSystem(['A',3,1]).ambient_space().fundamental_weights()           # optional - sage.graphs
+            Finite family {0: e['deltacheck'],
+                           1: e[0] + e['deltacheck'],
+                           2: e[0] + e[1] + e['deltacheck'],
+                           3: e[0] + e[1] + e[2] + e['deltacheck']}
             sage: RootSystem(['A',3]).ambient_space().fundamental_weights()
             Finite family {1: (1, 0, 0, 0), 2: (1, 1, 0, 0), 3: (1, 1, 1, 0)}
-            sage: RootSystem(['A',3,1]).weight_lattice().fundamental_weights().map(attrcall("level"))
+            sage: A31wl = RootSystem(['A',3,1]).weight_lattice()
+            sage: A31wl.fundamental_weights().map(attrcall("level"))                    # optional - sage.graphs
             Finite family {0: 1, 1: 1, 2: 1, 3: 1}
 
-            sage: RootSystem(['B',3,1]).ambient_space().fundamental_weights()
-            Finite family {0: e['deltacheck'], 1: e[0] + e['deltacheck'],
-                           2: e[0] + e[1] + 2*e['deltacheck'], 3: 1/2*e[0] + 1/2*e[1] + 1/2*e[2] + e['deltacheck']}
+            sage: RootSystem(['B',3,1]).ambient_space().fundamental_weights()           # optional - sage.graphs
+            Finite family {0: e['deltacheck'],
+                           1: e[0] + e['deltacheck'],
+                           2: e[0] + e[1] + 2*e['deltacheck'],
+                           3: 1/2*e[0] + 1/2*e[1] + 1/2*e[2] + e['deltacheck']}
             sage: RootSystem(['B',3]).ambient_space().fundamental_weights()
             Finite family {1: (1, 0, 0), 2: (1, 1, 0), 3: (1/2, 1/2, 1/2)}
-            sage: RootSystem(['B',3,1]).weight_lattice().fundamental_weights().map(attrcall("level"))
+            sage: B31wl = RootSystem(['B',3,1]).weight_lattice().
+            sage: B31wlfundamental_weights().map(attrcall("level"))                     # optional - sage.graphs
             Finite family {0: 1, 1: 1, 2: 2, 3: 1}
 
        In type `BC` dual, the coefficient of '\delta^\vee' is the level
        divided by `2` to take into account that the null coroot is
        `2\delta^\vee`::
 
             sage: R = CartanType(['BC',3,2]).dual().root_system()
-            sage: R.ambient_space().fundamental_weights()
-            Finite family {0: e['deltacheck'], 1: e[0] + e['deltacheck'],
+            sage: R.ambient_space().fundamental_weights()                               # optional - sage.graphs
+            Finite family {0: e['deltacheck'],
+                           1: e[0] + e['deltacheck'],
                            2: e[0] + e[1] + e['deltacheck'],
                            3: 1/2*e[0] + 1/2*e[1] + 1/2*e[2] + 1/2*e['deltacheck']}
-            sage: R.weight_lattice().fundamental_weights().map(attrcall("level"))
+            sage: R.weight_lattice().fundamental_weights().map(attrcall("level"))       # optional - sage.graphs
             Finite family {0: 2, 1: 2, 2: 2, 3: 1}
-            sage: R.ambient_space().null_coroot()
+            sage: R.ambient_space().null_coroot()                                       # optional - sage.graphs
             2*e['deltacheck']
 
         By a slight naming abuse this function also accepts "delta" as
@@ -314,22 +321,26 @@ def simple_root(self, i):
 
             sage: RootSystem(["A",3]).ambient_space().simple_roots()
             Finite family {1: (1, -1, 0, 0), 2: (0, 1, -1, 0), 3: (0, 0, 1, -1)}
-            sage: RootSystem(["A",3,1]).ambient_space().simple_roots()
-            Finite family {0: -e[0] + e[3] + e['delta'], 1: e[0] - e[1], 2: e[1] - e[2], 3: e[2] - e[3]}
+            sage: RootSystem(["A",3,1]).ambient_space().simple_roots()                  # optional - sage.graphs
+            Finite family {0: -e[0] + e[3] + e['delta'], 1: e[0] - e[1],
+                           2: e[1] - e[2], 3: e[2] - e[3]}
 
         Here is a twisted affine example::
 
-            sage: RootSystem(CartanType(["B",3,1]).dual()).ambient_space().simple_roots()
-            Finite family {0: -e[0] - e[1] + e['delta'], 1: e[0] - e[1], 2: e[1] - e[2], 3: 2*e[2]}
+            sage: B31ᵛ = RootSystem(CartanType(["B",3,1]).dual())
+            sage: B31ᵛ.ambient_space().simple_roots()                                   # optional - sage.graphs
+            Finite family {0: -e[0] - e[1] + e['delta'], 1: e[0] - e[1],
+                           2: e[1] - e[2], 3: 2*e[2]}
 
         In fact `\delta` is really `1/a_0` times the null root (see
         the discussion in :class:`~sage.combinat.root_system.weight_space.WeightSpace`)
         but this only makes a difference in type `BC`::
 
             sage: L = RootSystem(CartanType(["BC",3,2])).ambient_space()
-            sage: L.simple_roots()
-            Finite family {0: -e[0] + e['delta'], 1: e[0] - e[1], 2: e[1] - e[2], 3: 2*e[2]}
-            sage: L.null_root()
+            sage: L.simple_roots()                                                      # optional - sage.graphs
+            Finite family {0: -e[0] + e['delta'], 1: e[0] - e[1],
+                           2: e[1] - e[2], 3: 2*e[2]}
+            sage: L.null_root()                                                         # optional - sage.graphs
             2*e['delta']
 
         .. NOTE::
@@ -367,10 +378,12 @@ def simple_coroot(self, i):
         It is built as the coroot associated to the simple root
         `\alpha_i`::
 
-            sage: RootSystem(["B",3,1]).ambient_space().simple_roots()
-            Finite family {0: -e[0] - e[1] + e['delta'], 1: e[0] - e[1], 2: e[1] - e[2], 3: e[2]}
-            sage: RootSystem(["B",3,1]).ambient_space().simple_coroots()
-            Finite family {0: -e[0] - e[1] + e['deltacheck'], 1: e[0] - e[1], 2: e[1] - e[2], 3: 2*e[2]}
+            sage: RootSystem(["B",3,1]).ambient_space().simple_roots()                  # optional - sage.graphs
+            Finite family {0: -e[0] - e[1] + e['delta'], 1: e[0] - e[1],
+                           2: e[1] - e[2], 3: e[2]}
+            sage: RootSystem(["B",3,1]).ambient_space().simple_coroots()                # optional - sage.graphs
+            Finite family {0: -e[0] - e[1] + e['deltacheck'], 1: e[0] - e[1],
+                           2: e[1] - e[2], 3: 2*e[2]}
 
         .. TODO:: Factor out this code with the classical ambient space.
         """
@@ -475,14 +488,14 @@ def associated_coroot(self):
 
             EXAMPLES::
 
-                sage: alpha = RootSystem(['C',2,1]).ambient_space().simple_roots()
-                sage: alpha
+                sage: alpha = RootSystem(['C',2,1]).ambient_space().simple_roots()      # optional - sage.graphs
+                sage: alpha                                                             # optional - sage.graphs
                 Finite family {0: -2*e[0] + e['delta'], 1: e[0] - e[1], 2: 2*e[1]}
-                sage: alpha[0].associated_coroot()
+                sage: alpha[0].associated_coroot()                                      # optional - sage.graphs
                 -e[0] + e['deltacheck']
-                sage: alpha[1].associated_coroot()
+                sage: alpha[1].associated_coroot()                                      # optional - sage.graphs
                 e[0] - e[1]
-                sage: alpha[2].associated_coroot()
+                sage: alpha[2].associated_coroot()                                      # optional - sage.graphs
                 e[1]
             """
             # CHECKME: does it make any sense to not rescale the delta term?

src/sage/combinat/root_system/type_dual.py

@@ -379,7 +379,7 @@ class AmbientSpace(ambient_space.AmbientSpace):
         sage: ct = sage.combinat.root_system.type_dual.CartanType(CartanType(['F',4]))
         sage: L = ct.root_system().ambient_space(); L
         Ambient space of the Root system of type ['F', 4]^*
-        sage: TestSuite(L).run(skip=["_test_elements","_test_pickling"])
+        sage: TestSuite(L).run(skip=["_test_elements","_test_pickling"])                # optional - sage.graphs
     """
 
     @lazy_attribute
@@ -472,7 +472,7 @@ def fundamental_weights(self):
 
             sage: ct = sage.combinat.root_system.type_dual.CartanType(CartanType(['F',4]))
             sage: L = ct.root_system().ambient_space()
-            sage: L.fundamental_weights()
+            sage: L.fundamental_weights()                                               # optional - sage.graphs
             Finite family {1: (1, 1, 0, 0), 2: (2, 1, 1, 0), 3: (3, 1, 1, 1), 4: (2, 0, 0, 0)}
 
         Note that this ambient space is isomorphic, but not equal, to

src/sage/combinat/root_system/type_folded.py

@@ -116,7 +116,7 @@ class CartanTypeFolded(UniqueRepresentation, SageObject):
 
         sage: fct = CartanType(['C',4,1]).as_folding(); fct
         ['C', 4, 1] as a folding of ['A', 7, 1]
-        sage: fct.scaling_factors()
+        sage: fct.scaling_factors()                                                     # optional - sage.graphs
         Finite family {0: 2, 1: 1, 2: 1, 3: 1, 4: 2}
         sage: fct.folding_orbit()
         Finite family {0: (0,), 1: (1, 7), 2: (2, 6), 3: (3, 5), 4: (4,)}
@@ -126,7 +126,7 @@ class CartanTypeFolded(UniqueRepresentation, SageObject):
 
         sage: fct = CartanType(['A',4,1]).as_folding(); fct
         ['A', 4, 1] as a folding of ['A', 4, 1]
-        sage: fct.scaling_factors()
+        sage: fct.scaling_factors()                                                     # optional - sage.graphs
         Finite family {0: 1, 1: 1, 2: 1, 3: 1, 4: 1}
         sage: fct.folding_orbit()
         Finite family {0: (0,), 1: (1,), 2: (2,), 3: (3,), 4: (4,)}
@@ -271,15 +271,15 @@ def scaling_factors(self):
         EXAMPLES::
 
             sage: fct = CartanType(['C', 4, 1]).as_folding()
-            sage: fct.scaling_factors()
+            sage: fct.scaling_factors()                                                 # optional - sage.graphs
             Finite family {0: 2, 1: 1, 2: 1, 3: 1, 4: 2}
             sage: fct = CartanType(['BC', 4, 2]).as_folding()
-            sage: fct.scaling_factors()
+            sage: fct.scaling_factors()                                                 # optional - sage.graphs
             Finite family {0: 1, 1: 1, 2: 1, 3: 1, 4: 2}
             sage: fct = CartanType(['BC', 4, 2]).dual().as_folding()
-            sage: fct.scaling_factors()
+            sage: fct.scaling_factors()                                                 # optional - sage.graphs
             Finite family {0: 2, 1: 1, 2: 1, 3: 1, 4: 1}
-            sage: CartanType(['BC', 4, 2]).relabel({0:4, 1:3, 2:2, 3:1, 4:0}).as_folding().scaling_factors()
+            sage: CartanType(['BC', 4, 2]).relabel({0:4, 1:3, 2:2, 3:1, 4:0}).as_folding().scaling_factors()            # optional - sage.graphs
             Finite family {0: 2, 1: 1, 2: 1, 3: 1, 4: 1}
         """
         if self._cartan_type.is_finite():

src/sage/combinat/root_system/type_marked.py

@@ -166,8 +166,8 @@ def _repr_(self, compact=False):
             1   2
             A2 with node 1 marked
 
-            sage: CM = CartanMatrix([[2,-4],[-5,2]])
-            sage: CM.marked_nodes([1])
+            sage: CM = CartanMatrix([[2,-4],[-5,2]])                                    # optional - sage.graphs
+            sage: CM.marked_nodes([1])                                                  # optional - sage.graphs
             [ 2 -4]
             [-5  2] with node 1 marked
         """
@@ -425,7 +425,7 @@ def _default_folded_cartan_type(self):
             Finite family {0: (0,), 1: (2,), 2: (1, 3, 4)}
             sage: CartanType(['G',2,1]).dual()._default_folded_cartan_type().folding_orbit()
             Finite family {0: (0,), 1: (1, 3, 4), 2: (2,)}
-            sage: CartanType(['C',3,1]).relabel({0:1, 1:0, 2:3, 3:2}).as_folding().scaling_factors()
+            sage: CartanType(['C',3,1]).relabel({0:1, 1:0, 2:3, 3:2}).as_folding().scaling_factors()                    # optional - sage.graphs
             Finite family {0: 1, 1: 2, 2: 2, 3: 1}
         """
         from sage.combinat.root_system.type_folded import CartanTypeFolded
@@ -461,7 +461,7 @@ class AmbientSpace(ambient_space.AmbientSpace):
 
         sage: L = CartanType(["F",4]).marked_nodes([1,3]).root_system().ambient_space(); L
         Ambient space of the Root system of type ['F', 4] with nodes (1, 3) marked
-        sage: TestSuite(L).run()
+        sage: TestSuite(L).run()                                                        # optional - sage.graphs
     """
     @lazy_attribute
     def _space(self):

src/sage/combinat/root_system/type_reducible.py

@@ -256,18 +256,18 @@ def cartan_matrix(self, subdivide=True):
         EXAMPLES::
 
             sage: ct = CartanType("A2","B2")
-            sage: ct.cartan_matrix()
+            sage: ct.cartan_matrix()                                                    # optional - sage.graphs
             [ 2 -1| 0  0]
             [-1  2| 0  0]
             [-----+-----]
             [ 0  0| 2 -1]
             [ 0  0|-2  2]
-            sage: ct.cartan_matrix(subdivide=False)
+            sage: ct.cartan_matrix(subdivide=False)                                     # optional - sage.graphs
             [ 2 -1  0  0]
             [-1  2  0  0]
             [ 0  0  2 -1]
             [ 0  0 -2  2]
-            sage: ct.index_set() == ct.cartan_matrix().index_set()
+            sage: ct.index_set() == ct.cartan_matrix().index_set()                      # optional - sage.graphs
             True
         """
         from sage.combinat.root_system.cartan_matrix import CartanMatrix

src/sage/combinat/root_system/type_relabel.py

@@ -149,19 +149,19 @@ def __init__(self, type, relabelling):
         Check for the original issues of :trac:`13724`::
 
             sage: A3 = CartanType("A3")
-            sage: A3.cartan_matrix()
+            sage: A3.cartan_matrix()                                                    # optional - sage.graphs
             [ 2 -1  0]
             [-1  2 -1]
             [ 0 -1  2]
             sage: A3r = A3.relabel({1:2,2:3,3:1})
-            sage: A3r.cartan_matrix()
+            sage: A3r.cartan_matrix()                                                   # optional - sage.graphs
             [ 2  0 -1]
             [ 0  2 -1]
             [-1 -1  2]
 
             sage: ct = CartanType(["D",4,3]).classical(); ct
             ['G', 2]
-            sage: ct.symmetrizer()
+            sage: ct.symmetrizer()                                                      # optional - sage.graphs
             Finite family {1: 1, 2: 3}
 
         Check the underlying issue of :trac:`24892`, that the root system
@@ -384,7 +384,7 @@ def _default_folded_cartan_type(self):
             Finite family {0: (0,), 1: (2,), 2: (1, 3, 4)}
             sage: CartanType(['G',2,1]).dual()._default_folded_cartan_type().folding_orbit()
             Finite family {0: (0,), 1: (1, 3, 4), 2: (2,)}
-            sage: CartanType(['C',3,1]).relabel({0:1, 1:0, 2:3, 3:2}).as_folding().scaling_factors()
+            sage: CartanType(['C',3,1]).relabel({0:1, 1:0, 2:3, 3:2}).as_folding().scaling_factors()                    # optional - sage.graphs
             Finite family {0: 1, 1: 2, 2: 2, 3: 1}
         """
         from sage.combinat.root_system.type_folded import CartanTypeFolded
@@ -436,7 +436,7 @@ class AmbientSpace(ambient_space.AmbientSpace):
         sage: cycle = {1:2, 2:3, 3:4, 4:1}
         sage: L = CartanType(["F",4]).relabel(cycle).root_system().ambient_space(); L
         Ambient space of the Root system of type ['F', 4] relabelled by {1: 2, 2: 3, 3: 4, 4: 1}
-        sage: TestSuite(L).run()
+        sage: TestSuite(L).run()                                                        # optional - sage.graphs
     """
 
     @lazy_attribute