def _default_folded_cartan_type(self):
"""
Return the default folded Cartan type.
EXAMPLES::
sage: CartanType(['B', 4, 1])._default_folded_cartan_type()
['B', 4, 1] as a folding of ['D', 5, 1]
"""
from sage.combinat.root_system.type_folded import CartanTypeFolded
n = self.n
if n == 1:
return CartanTypeFolded(self, ['A', 1, 1], [[0], [1]])
return CartanTypeFolded(self, ['D', n + 1, 1],
[[i] for i in range(n)] + [[n, n + 1]])
def _default_folded_cartan_type(self):
"""
Return the default folded Cartan type.
In general, this just returns ``self`` in ``self`` with `\sigma` as
the identity map.
EXAMPLES::
sage: CartanType(['A',1,1])._default_folded_cartan_type()
['A', 1, 1] as a folding of ['A', 3, 1]
sage: CartanType(['A',3,1])._default_folded_cartan_type()
['A', 3, 1] as a folding of ['A', 3, 1]
"""
from sage.combinat.root_system.type_folded import CartanTypeFolded
if self.n == 1:
return CartanTypeFolded(self, ['A', 3, 1], [[0,2], [1,3]])
return CartanTypeFolded(self, self, [[i] for i in self.index_set()])
def _default_folded_cartan_type(self):
"""
Return the default folded Cartan type.
EXAMPLES::
sage: CartanType(['G', 2])._default_folded_cartan_type()
['G', 2] as a folding of ['D', 4]
"""
from sage.combinat.root_system.type_folded import CartanTypeFolded
return CartanTypeFolded(self, ['D', 4], [[1, 3, 4], [2]])
def _default_folded_cartan_type(self):
"""
Return the default folded Cartan type.
EXAMPLES::
sage: CartanType(['F', 4])._default_folded_cartan_type()
['F', 4] as a folding of ['E', 6]
"""
from sage.combinat.root_system.type_folded import CartanTypeFolded
return CartanTypeFolded(self, ['E', 6], [[2], [4], [3, 5], [1, 6]])
def _default_folded_cartan_type(self):
"""
Return the default folded Cartan type.
EXAMPLES::
sage: CartanType(['A', 6, 2]).dual()._default_folded_cartan_type()
['BC', 3, 2]^* as a folding of ['A', 5, 1]
sage: CartanType(['A', 5, 2])._default_folded_cartan_type()
['B', 3, 1]^* as a folding of ['D', 4, 1]
sage: CartanType(['D', 4, 2])._default_folded_cartan_type()
['C', 3, 1]^* as a folding of ['A', 5, 1]
sage: CartanType(['E', 6, 2])._default_folded_cartan_type()
['F', 4, 1]^* as a folding of ['E', 6, 1]
sage: CartanType(['G', 2, 1]).dual()._default_folded_cartan_type()
['G', 2, 1]^* as a folding of ['D', 4, 1]
"""
from sage.combinat.root_system.type_folded import CartanTypeFolded
letter = self._type.type()
if letter == 'BC': # A_{2n}^{(2)\dagger}
n = self._type.classical().rank()
return CartanTypeFolded(self, ['A', 2 * n - 1, 1],
[[0]] + [[i, 2 * n - i]
for i in range(1, n)] + [[n]])
if letter == 'B': # A_{2n-1}^{(2)}
n = self._type.classical().rank()
return CartanTypeFolded(self, ['D', n + 1, 1],
[[i] for i in range(n)] + [[n, n + 1]])
if letter == 'C': # D_{n+1}^{(2)}
n = self._type.classical().rank()
return CartanTypeFolded(self, ['A', 2 * n - 1, 1],
[[0]] + [[i, 2 * n - i]
for i in range(1, n)] + [[n]])
if letter == 'F': # E_6^{(2)}
return CartanTypeFolded(self, ['E', 6, 1],
[[0], [2], [4], [3, 5], [1, 6]])
if letter == 'G': # D_4^{(3)}
return CartanTypeFolded(self, ['D', 4, 1], [[0], [1, 3, 4], [2]])
return super(CartanType, self)._default_folded_cartan_type()
def _default_folded_cartan_type(self):
"""
Return the default folded Cartan type.
EXAMPLES::
sage: CartanType(['C', 3])._default_folded_cartan_type()
['C', 3] as a folding of ['A', 5]
"""
from sage.combinat.root_system.type_folded import CartanTypeFolded
n = self.n
return CartanTypeFolded(self, ['A', 2 * n - 1],
[[i, 2 * n - i] for i in range(1, n)] + [[n]])
def _default_folded_cartan_type(self):
"""
Return the default folded Cartan type.
EXAMPLES::
sage: fct = CartanType(['D', 4, 3])._default_folded_cartan_type(); fct
['G', 2, 1]^* relabelled by {0: 0, 1: 2, 2: 1} as a folding of ['D', 4, 1]
sage: fct.folding_orbit()
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()
Finite family {0: 1, 1: 2, 2: 2, 3: 1}
"""
from sage.combinat.root_system.type_folded import CartanTypeFolded
vct = self._type._default_folded_cartan_type()
sigma = vct.folding_orbit()
return CartanTypeFolded(self, vct._folding,
{self._relabelling[i]: sigma[i] for i in self._type.index_set()})
def _default_folded_cartan_type(self):
"""
Return the default folded Cartan type.
If a node `a` is marked, then all nodes in the orbit of `a` are marked
in the ambient type.
EXAMPLES::
sage: fct = CartanType(['D', 4, 3])._default_folded_cartan_type(); fct
['G', 2, 1]^* relabelled by {0: 0, 1: 2, 2: 1} as a folding of ['D', 4, 1]
sage: fct.folding_orbit()
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()
Finite family {0: 1, 1: 2, 2: 2, 3: 1}
"""
from sage.combinat.root_system.type_folded import CartanTypeFolded
vct = self._type._default_folded_cartan_type()
sigma = vct.folding_orbit()
marked_nodes = sum([sigma[i] for i in self._marked_nodes], ())
folding = vct._folding.marked_nodes(marked_nodes)
return CartanTypeFolded(self, folding, sigma)
