### Navigation

- index
- modules |
- next |
- previous |
- Combinatorics »
- Root Systems »
- Root System Types »

# Root system data for type F

class `sage.combinat.root_system.type_F.``AmbientSpace`(root_system, base_ring)

  Bases: `sage.combinat.root_system.ambient_space.AmbientSpace`

  The lattice behind \(F_4\). The computations are based on Bourbaki, Groupes et Algebres de Lie, Ch. 4,5,6 (planche VIII).

  `dimension`()

    Return the dimension of `self`.

    EXAMPLES:

        sage: e = RootSystem(['F',4]).ambient_space()
        sage: e.dimension()
        4

  `fundamental_weights`()

    Return the fundamental weights of `self`.

    EXAMPLES:

        sage: e =  RootSystem(['F',4]).ambient_space()
        sage: e.fundamental_weights()
        Finite family {1: (1, 1, 0, 0), 2: (2, 1, 1, 0), 3: (3/2, 1/2, 1/2, 1/2), 4: (1, 0, 0, 0)}

  `negative_roots`()

    Return the negative roots.

    EXAMPLES:

        sage: e = RootSystem(['F',4]).ambient_space()
        sage: e.negative_roots()
        [(-1, 0, 0, 0),
        (0, -1, 0, 0),
        (0, 0, -1, 0),
        (0, 0, 0, -1),
        (-1, -1, 0, 0),
        (-1, 0, -1, 0),
        (-1, 0, 0, -1),
        (0, -1, -1, 0),
        (0, -1, 0, -1),
        (0, 0, -1, -1),
        (-1, 1, 0, 0),
        (-1, 0, 1, 0),
        (-1, 0, 0, 1),
        (0, -1, 1, 0),
        (0, -1, 0, 1),
        (0, 0, -1, 1),
        (-1/2, -1/2, -1/2, -1/2),
        (-1/2, -1/2, -1/2, 1/2),
        (-1/2, -1/2, 1/2, -1/2),
        (-1/2, -1/2, 1/2, 1/2),
        (-1/2, 1/2, -1/2, -1/2),
        (-1/2, 1/2, -1/2, 1/2),
        (-1/2, 1/2, 1/2, -1/2),
        (-1/2, 1/2, 1/2, 1/2)]

  `positive_roots`()

    Return the positive roots.

    These are the roots which are positive with respect to the lexicographic ordering of the basis elements (\(\epsilon_1<\epsilon_2<\epsilon_3<\epsilon_4\)).

    EXAMPLES:

        sage: e = RootSystem(['F',4]).ambient_space()
        sage: e.positive_roots()
        [(1, 0, 0, 0),
        (0, 1, 0, 0),
        (0, 0, 1, 0),
        (0, 0, 0, 1),
        (1, 1, 0, 0),
        (1, 0, 1, 0),
        (1, 0, 0, 1),
        (0, 1, 1, 0),
        (0, 1, 0, 1),
        (0, 0, 1, 1),
        (1, -1, 0, 0),
        (1, 0, -1, 0),
        (1, 0, 0, -1),
        (0, 1, -1, 0),
        (0, 1, 0, -1),
        (0, 0, 1, -1),
        (1/2, 1/2, 1/2, 1/2),
        (1/2, 1/2, 1/2, -1/2),
        (1/2, 1/2, -1/2, 1/2),
        (1/2, 1/2, -1/2, -1/2),
        (1/2, -1/2, 1/2, 1/2),
        (1/2, -1/2, 1/2, -1/2),
        (1/2, -1/2, -1/2, 1/2),
        (1/2, -1/2, -1/2, -1/2)]
        sage: e.rho()
        (11/2, 5/2, 3/2, 1/2)

  `root`(i, j=None, k=None, l=None, p1=0, p2=0, p3=0, p4=0)

    Compute a root from base elements of the underlying lattice. The arguments specify the basis elements and the signs. Sadly, the base elements are indexed zero-based. We assume that if one of the indices is not given, the rest are not as well.

    EXAMPLES:

        sage: e = RootSystem(['F',4]).ambient_space()
        sage: [ e.root(i,j,p2=1) for i in xrange(e.n) for j in xrange(i+1,e.n) ]
        [(1, -1, 0, 0), (1, 0, -1, 0), (1, 0, 0, -1), (0, 1, -1, 0), (0, 1, 0, -1), (0, 0, 1, -1)]

  `simple_root`(i)

    Return the \(i\)-th simple root.

    It is computed according to what Bourbaki calls the Base:

    \[\alpha_1 = \epsilon_2-\epsilon_3, \alpha_2 = \epsilon_3-\epsilon_4, \alpha_3 = \epsilon_4, \alpha_4 = \frac{1}{2} \left( \epsilon_1-\epsilon_2-\epsilon_3-\epsilon_4 \right).\]

    EXAMPLES:

        sage: e = RootSystem(['F',4]).ambient_space()
        sage: e.simple_roots()
        Finite family {1: (0, 1, -1, 0), 2: (0, 0, 1, -1), 3: (0, 0, 0, 1), 4: (1/2, -1/2, -1/2, -1/2)}

class `sage.combinat.root_system.type_F.``CartanType`

  Bases: `sage.combinat.root_system.cartan_type.CartanType_standard_finite`, `sage.combinat.root_system.cartan_type.CartanType_simple`, `sage.combinat.root_system.cartan_type.CartanType_crystallographic`

  EXAMPLES:

      sage: ct = CartanType(['F',4])
      sage: ct
      ['F', 4]
      sage: ct._repr_(compact = True)
      'F4'

      sage: ct.is_irreducible()
      True
      sage: ct.is_finite()
      True
      sage: ct.is_crystallographic()
      True
      sage: ct.is_simply_laced()
      False
      sage: ct.dual()
      ['F', 4] relabelled by {1: 4, 2: 3, 3: 2, 4: 1}
      sage: ct.affine()
      ['F', 4, 1]

  TESTS:

      sage: TestSuite(ct).run()

  `AmbientSpace`

    alias of `AmbientSpace`

  `ascii_art`(label=<function <lambda> at 0xef0ae144>)

    Return an ascii art representation of the extended Dynkin diagram.

    EXAMPLES:

        sage: print CartanType(['F',4]).ascii_art(label = lambda x: x+2)
        O---O=>=O---O
        3   4   5   6

  `coxeter_number`()

    Return the Coxeter number associated with `self`.

    EXAMPLES:

        sage: CartanType(['F',4]).coxeter_number()
        12

  `dual`()

    Return the dual Cartan type.

    This uses that \(F_4\) is self-dual up to relabelling.

    EXAMPLES:

        sage: F4 = CartanType(['F',4])
        sage: F4.dual()
        ['F', 4] relabelled by {1: 4, 2: 3, 3: 2, 4: 1}

        sage: F4.dynkin_diagram()
        O---O=>=O---O
        1   2   3   4
        F4
        sage: F4.dual().dynkin_diagram()
        O---O=>=O---O
        4   3   2   1
        F4 relabelled by {1: 4, 2: 3, 3: 2, 4: 1}

  `dual_coxeter_number`()

    Return the dual Coxeter number associated with `self`.

    EXAMPLES:

        sage: CartanType(['F',4]).dual_coxeter_number()
        9

  `dynkin_diagram`()

    Returns a Dynkin diagram for type F.

    EXAMPLES:

        sage: f = CartanType(['F',4]).dynkin_diagram()
        sage: f
        O---O=>=O---O
        1   2   3   4
        F4
        sage: sorted(f.edges())
        [(1, 2, 1), (2, 1, 1), (2, 3, 2), (3, 2, 1), (3, 4, 1), (4, 3, 1)]

### Navigation

- index
- modules |
- next |
- previous |
- Combinatorics »
- Root Systems »
- Root System Types »