Documentation

TauCeti.LinearAlgebra.RootSystem.SimplyConnectedRootDatum.B.Model

The pinned coordinate model of the roots of type Bₙ #

This file records the roots of type Bₙ in the two lattices pinned by the Bourbaki numbering: the character lattice Fin n → ℤ written in the fundamental-weight basis, and the cocharacter lattice Fin n → ℤ written in the simple-coroot basis. It stops just short of assembling a RootDatum, which is done in TauCeti.LinearAlgebra.RootSystem.SimplyConnectedRootDatum.B.Datum once the roots have been enumerated by Fin (2 * n ^ 2).

The coordinates #

Write e₀, …, e_{n-1} for the standard basis of the classical model ℤ ^ n, in which the roots of type Bₙ are the 2 * n ^ 2 vectors ± e_a ± e_b (a ≠ b) and ± e_a, the simple roots are αᵢ = eᵢ - eᵢ₊₁ for i + 1 < n and α_{n-1} = e_{n-1}, and the coroot of a root α is 2 α / (α, α), so the long roots are self-dual while (± e_a)^∨ = ± 2 e_a. Everything below is the image of that model in the two pinned lattices:

weight n a   = (⟨e_a, αₖ^∨⟩)ₖ,          the character coordinates of `e_a`,
coweight n b = the simple-coroot coordinates of `2 e_b`.

The doubling in coweight is not a normalisation: e_b itself is a half-integral combination of the simple coroots, because α_{n-1}^∨ = 2 e_{n-1}, while 2 e_b is integral. The single identity TauCeti.DynkinType.TypeB.weight_dotProduct_coweight, that the two families pair to 2 * [a = b], is what the rest of the file computes with.

Signed basis vectors and the pairs naming a root #

A root is a sum of one or two signed basis vectors on distinct axes, so Fin (2 * n) indexes the signed basis vectors, u < n standing for e_u and u ≥ n for -e_{u-n}, and a root is named by an unordered pair {u, v}, with u = v for a short root. Two devices make this uniform.

The cyclic offset TauCeti.DynkinType.TypeB.shift turns the unordered pair into the ordered datum (u, d) : Fin (2 * n) × Fin n. For a distinct admissible pair, exactly one of the two orders has its offset in the range Fin n; a short root uses the coincident order with offset zero. This is the index type the datum is built on, and TauCeti.DynkinType.TypeB.index is the inverse normalisation.

The coroot is uniform in the pair while the root is not: TauCeti.DynkinType.TypeB.corootOfPair computes the simple-coroot coordinates of the coroot from the pair, and specialises to the short coroot when the two entries agree, since (e_a)^∨ = 2 e_a = e_a + e_a. It is a genuine half, and the integral identity TauCeti.DynkinType.TypeB.corootOfPair_add_self is how the reflection identity for coroots is proved.

Main definitions #

The coordinate definitions are used through their defining and case-characterization lemmas below; their bodies are not exposed to importing modules.

Main results #

References #

The coordinates and the node numbering follow Bourbaki, Lie Groups and Lie Algebras, Chapters 4--6, Plate II, and Humphreys, Introduction to Lie Algebras and Representation Theory, section 12.1. This is part of the Bₙ branch of the target "a named datum per valid type" in Layer 6 of TauCetiRoadmap/RepresentationTheory/RootSystems/README.md.

The two coordinate families #

The character-lattice coordinates of the classical basis vector e_a of type Bₙ, namely its pairings ⟨e_a, αₖ^∨⟩ against the simple coroots. The last simple coroot is 2 e_{n-1}, which is why the diagonal entry doubles there. The value is 0 for n ≤ a, where there is no basis vector.

Equations
Instances For
    @[simp]
    theorem TauCeti.DynkinType.TypeB.weight_apply (n a : ℕ) (k : Fin n) :
    weight n a k = (if a = ↑k then if ↑k + 1 = n then 2 else 1 else 0) - if a = ↑k + 1 ∧ ↑k + 1 < n then 1 else 0

    The cocharacter-lattice coordinates of 2 e_b, that is, its coordinates in the simple coroots αₖ^∨ = e_k - e_{k+1} and α_{n-1}^∨ = 2 e_{n-1}. The vector e_b alone is half-integral in that basis, so it is its double that is recorded.

    Equations
    Instances For
      @[simp]
      theorem TauCeti.DynkinType.TypeB.coweight_apply (n b : ℕ) (k : Fin n) :
      coweight n b k = (if ↑k + 1 = n then 1 else 2) * if b ≤ ↑k then 1 else 0
      @[simp]
      @[simp]

      The fundamental pairing identity of type Bₙ. In the classical model ⟨e_a, 2 e_b⟩ is 2 * [a = b], and the two pinned lattices see exactly that.

      Signed basis vectors #

      def TauCeti.DynkinType.TypeB.axis {n : ℕ} (u : Fin (2 * n)) :

      The axis of the signed basis vector indexed by u, which stands for e_u when u < n and for -e_{u-n} otherwise.

      Equations
      Instances For
        theorem TauCeti.DynkinType.TypeB.axis_def {n : ℕ} (u : Fin (2 * n)) :
        axis u = if ↑u < n then ↑u else ↑u - n
        def TauCeti.DynkinType.TypeB.sgn {n : ℕ} (u : Fin (2 * n)) :

        The sign of the signed basis vector indexed by u.

        Equations
        Instances For
          theorem TauCeti.DynkinType.TypeB.sgn_def {n : ℕ} (u : Fin (2 * n)) :
          sgn u = if ↑u < n then 1 else -1
          def TauCeti.DynkinType.TypeB.opp {n : ℕ} (u : Fin (2 * n)) :
          Fin (2 * n)

          The index of the opposite signed basis vector.

          Equations
          Instances For
            theorem TauCeti.DynkinType.TypeB.axis_lt {n : ℕ} (u : Fin (2 * n)) :
            axis u < n
            theorem TauCeti.DynkinType.TypeB.coe_opp {n : ℕ} (u : Fin (2 * n)) :
            ↑(opp u) = if ↑u < n then ↑u + n else ↑u - n
            @[simp]
            theorem TauCeti.DynkinType.TypeB.axis_opp {n : ℕ} (u : Fin (2 * n)) :
            axis (opp u) = axis u
            @[simp]
            theorem TauCeti.DynkinType.TypeB.sgn_opp {n : ℕ} (u : Fin (2 * n)) :
            sgn (opp u) = -sgn u
            @[simp]
            theorem TauCeti.DynkinType.TypeB.opp_opp {n : ℕ} (u : Fin (2 * n)) :
            opp (opp u) = u
            theorem TauCeti.DynkinType.TypeB.eq_or_eq_opp_of_axis_eq {n : ℕ} {u v : Fin (2 * n)} (h : axis u = axis v) :
            u = v ∨ u = opp v
            theorem TauCeti.DynkinType.TypeB.ne_of_axis_ne {n : ℕ} {u v : Fin (2 * n)} (h : axis u ≠ axis v) :
            u ≠ v
            def TauCeti.DynkinType.TypeB.signedWeight {n : ℕ} (u : Fin (2 * n)) :
            Fin n → ℤ

            The character coordinates of the signed basis vector indexed by u.

            Equations
            Instances For

              The cocharacter coordinates of twice the signed basis vector indexed by u.

              Equations
              Instances For

                The pairing of two signed basis vectors: 2 on the diagonal, -2 on opposite vectors, and 0 on different axes.

                The coroot attached to a pair of signed basis vectors #

                def TauCeti.DynkinType.TypeB.corootOfPair {n : ℕ} (u v : Fin (2 * n)) :
                Fin n → ℤ

                The simple-coroot coordinates of the coroot named by the pair {u, v}: the half of signedCoweight u + signedCoweight v, which is integral. When u = v this is the short coroot signedCoweight u, and otherwise it is the long coroot ± e_a ± e_b itself.

                Equations
                • One or more equations did not get rendered due to their size.
                Instances For
                  theorem TauCeti.DynkinType.TypeB.corootOfPair_apply {n : ℕ} (u v : Fin (2 * n)) (k : Fin n) :
                  corootOfPair u v k = if ↑k + 1 = n then if sgn u = sgn v then sgn u else 0 else (sgn u * if axis u ≤ ↑k then 1 else 0) + sgn v * if axis v ≤ ↑k then 1 else 0

                  The integral form of the halving.

                  Cyclic offsets and the index of a pair #

                  def TauCeti.DynkinType.TypeB.shift {n : ℕ} (u : Fin (2 * n)) (d : Fin n) :
                  Fin (2 * n)

                  The signed basis vector d steps after u in the cyclic order on Fin (2 * n).

                  Equations
                  Instances For
                    theorem TauCeti.DynkinType.TypeB.coe_shift {n : ℕ} (u : Fin (2 * n)) (d : Fin n) :
                    ↑(shift u d) = if ↑u + ↑d < 2 * n then ↑u + ↑d else ↑u + ↑d - 2 * n
                    theorem TauCeti.DynkinType.TypeB.shift_eq_self {n : ℕ} {u : Fin (2 * n)} {d : Fin n} (hd : ↑d = 0) :
                    shift u d = u
                    theorem TauCeti.DynkinType.TypeB.axis_shift_ne {n : ℕ} {u : Fin (2 * n)} {d : Fin n} (hd : ↑d ≠ 0) :
                    axis (shift u d) ≠ axis u

                    The cyclic distance from u to v in Fin (2 * n).

                    Equations
                    Instances For
                      @[simp]
                      theorem TauCeti.DynkinType.TypeB.cyclicDistance_shift {n : ℕ} (u : Fin (2 * n)) (d : Fin n) :
                      cyclicDistance u (shift u d) = ↑d
                      def TauCeti.DynkinType.TypeB.IsPair {n : ℕ} (u v : Fin (2 * n)) :

                      A pair of signed basis vectors naming a root: either equal, for a short root, or on distinct axes, for a long root.

                      Equations
                      Instances For
                        theorem TauCeti.DynkinType.TypeB.isPair_iff {n : ℕ} (u v : Fin (2 * n)) :
                        IsPair u v ↔ u = v ∨ axis u ≠ axis v

                        Characterization of the signed-vector pairs that name roots of type Bₙ. This is the public introduction and elimination rule for the body-hidden predicate IsPair.

                        theorem TauCeti.DynkinType.TypeB.IsPair.cyclicDistance_ne {n : ℕ} {u v : Fin (2 * n)} (h : IsPair u v) (huv : u ≠ v) :
                        theorem TauCeti.DynkinType.TypeB.isPair_shift {n : ℕ} (u : Fin (2 * n)) (d : Fin n) :
                        IsPair u (shift u d)
                        def TauCeti.DynkinType.TypeB.index {n : ℕ} (u v : Fin (2 * n)) :
                        Fin (2 * n) × Fin n

                        The canonical index in Fin (2 * n) × Fin n of the root named by a pair of signed basis vectors. For a distinct admissible pair it uses the unique order whose cyclic offset lies in Fin n; a short pair uses the coincident order with offset zero.

                        Equations
                        • One or more equations did not get rendered due to their size.
                        Instances For
                          @[simp]
                          theorem TauCeti.DynkinType.TypeB.index_shift {n : ℕ} (z : Fin (2 * n) × Fin n) :
                          index z.1 (shift z.1 z.2) = z
                          theorem TauCeti.DynkinType.TypeB.index_comm {n : ℕ} {u v : Fin (2 * n)} (h : IsPair u v) :
                          index u v = index v u
                          theorem TauCeti.DynkinType.TypeB.shift_index {n : ℕ} {u v : Fin (2 * n)} (h : IsPair u v) :
                          (index u v).1 = u ∧ shift (index u v).1 (index u v).2 = v ∨ (index u v).1 = v ∧ shift (index u v).1 (index u v).2 = u

                          Roots and coroots #

                          def TauCeti.DynkinType.TypeB.rootOfPair {n : ℕ} (u v : Fin (2 * n)) :
                          Fin n → ℤ

                          The character coordinates of the root named by a pair of signed basis vectors.

                          Equations
                          Instances For
                            @[simp]
                            def TauCeti.DynkinType.TypeB.rootIdx {n : ℕ} (z : Fin (2 * n) × Fin n) :
                            Fin n → ℤ

                            The root indexed by an element of Fin (2 * n) × Fin n.

                            Equations
                            Instances For
                              theorem TauCeti.DynkinType.TypeB.rootIdx_def {n : ℕ} (z : Fin (2 * n) × Fin n) :
                              rootIdx z = rootOfPair z.1 (shift z.1 z.2)
                              def TauCeti.DynkinType.TypeB.corootIdx {n : ℕ} (z : Fin (2 * n) × Fin n) :
                              Fin n → ℤ

                              The coroot indexed by an element of Fin (2 * n) × Fin n.

                              Equations
                              Instances For
                                @[simp]
                                theorem TauCeti.DynkinType.TypeB.rootIdx_index {n : ℕ} {u v : Fin (2 * n)} (h : IsPair u v) :
                                @[simp]
                                theorem TauCeti.DynkinType.TypeB.corootIdx_index {n : ℕ} {u v : Fin (2 * n)} (h : IsPair u v) :

                                Cartan integers between roots in the classical type B model have absolute value at most two.

                                The reflection in a root #

                                def TauCeti.DynkinType.TypeB.reflMap {n : ℕ} (p q u : Fin (2 * n)) :
                                Fin (2 * n)

                                The signed permutation of the basis vectors realising the reflection in the root named by the pair {p, q}. On a long root it exchanges p with -q and q with -p; on a short root, where p = q, it is the sign change on the axis of p.

                                Equations
                                • One or more equations did not get rendered due to their size.
                                Instances For
                                  theorem TauCeti.DynkinType.TypeB.reflMap_fst {n : ℕ} (p q : Fin (2 * n)) :
                                  reflMap p q p = if p = q then opp p else opp q
                                  theorem TauCeti.DynkinType.TypeB.reflMap_snd {n : ℕ} {p q : Fin (2 * n)} (h : q ≠ p) :
                                  reflMap p q q = opp p
                                  theorem TauCeti.DynkinType.TypeB.reflMap_opp_fst {n : ℕ} {p q : Fin (2 * n)} (h : opp p ≠ q) :
                                  reflMap p q (opp p) = if p = q then p else q
                                  theorem TauCeti.DynkinType.TypeB.reflMap_opp_snd {n : ℕ} {p q : Fin (2 * n)} (h1 : opp q ≠ p) (h2 : opp q ≠ opp p) :
                                  reflMap p q (opp q) = p
                                  theorem TauCeti.DynkinType.TypeB.reflMap_of_ne {n : ℕ} {p q u : Fin (2 * n)} (h1 : u ≠ p) (h2 : u ≠ q) (h3 : u ≠ opp p) (h4 : u ≠ opp q) :
                                  reflMap p q u = u
                                  theorem TauCeti.DynkinType.TypeB.reflMap_opp {n : ℕ} {p q : Fin (2 * n)} (h : IsPair p q) (u : Fin (2 * n)) :
                                  reflMap p q (opp u) = opp (reflMap p q u)
                                  theorem TauCeti.DynkinType.TypeB.isPair_reflMap {n : ℕ} {p q : Fin (2 * n)} (h : IsPair p q) {u v : Fin (2 * n)} (huv : IsPair u v) :
                                  IsPair (reflMap p q u) (reflMap p q v)

                                  The reflection formula on a single signed basis vector.

                                  The reflection formula on the double of a single signed basis vector.

                                  Recovering the index from the root #

                                  The signed basis vectors occurring in a root are exactly those pairing to 2 with it.

                                  The signed basis vectors occurring in a coroot, detected by a doubled pairing so that both the short and the long case are covered.

                                  theorem TauCeti.DynkinType.TypeB.index_eq_of_pair_mem_iff {n : ℕ} {z z' : Fin (2 * n) × Fin n} (h : ∀ (m : Fin (2 * n)), m = z.1 ∨ m = shift z.1 z.2 ↔ m = z'.1 ∨ m = shift z'.1 z'.2) :
                                  z = z'

                                  Two indices naming the same pair of signed basis vectors are equal.