File: Mathlib/LinearAlgebra/RootSystem/Defs.lean

full_name: RootPairing.root_coroot_two
code: /-- Given two perfectly-paired `R`-modules `M` and `N`, a root pairing with indexing set `ι`
is the data of an `ι`-indexed subset of `M` ("the roots"), an `ι`-indexed subset of `N`
("the coroots"), and an `ι`-indexed set of permutations of `ι`, such that each root-coroot pair
evaluates to `2`, and the permutation attached to each element of `ι` is compatible with the
reflections on the corresponding roots and coroots.

It exists to allow for a convenient unification of the theories of root systems and root data. -/
structure RootPairing extends PerfectPairing R M N :=
  /-- A parametrized family of vectors, called roots. -/
  root : ι ↪ M
  /-- A parametrized family of dual vectors, called coroots. -/
  coroot : ι ↪ N
  root_coroot_two : ∀ i, toLin (root i) (coroot i) = 2
  /-- A parametrized family of permutations, induced by reflection. -/
  reflection_perm : ι → (ι ≃ ι)
  reflection_perm_root : ∀ i j,
    root j - toLin (root j) (coroot i) • root i = root (reflection_perm i j)
  reflection_perm_coroot : ∀ i j,
    coroot j - toLin (root i) (coroot j) • coroot i = coroot (reflection_perm i j)
goal: (self.toLin (self.root i)) (self.coroot i) = 2

full_name: RootPairing.root
code: /-- Given two perfectly-paired `R`-modules `M` and `N`, a root pairing with indexing set `ι`
is the data of an `ι`-indexed subset of `M` ("the roots"), an `ι`-indexed subset of `N`
("the coroots"), and an `ι`-indexed set of permutations of `ι`, such that each root-coroot pair
evaluates to `2`, and the permutation attached to each element of `ι` is compatible with the
reflections on the corresponding roots and coroots.

It exists to allow for a convenient unification of the theories of root systems and root data. -/
structure RootPairing extends PerfectPairing R M N :=
  /-- A parametrized family of vectors, called roots. -/
  root : ι ↪ M
  /-- A parametrized family of dual vectors, called coroots. -/
  coroot : ι ↪ N
  root_coroot_two : ∀ i, toLin (root i) (coroot i) = 2
  /-- A parametrized family of permutations, induced by reflection. -/
  reflection_perm : ι → (ι ≃ ι)
  reflection_perm_root : ∀ i j,
    root j - toLin (root j) (coroot i) • root i = root (reflection_perm i j)
  reflection_perm_coroot : ∀ i j,
    coroot j - toLin (root i) (coroot j) • coroot i = coroot (reflection_perm i j)
goal: ι ↪ M

full_name: RootPairing.coroot
code: /-- Given two perfectly-paired `R`-modules `M` and `N`, a root pairing with indexing set `ι`
is the data of an `ι`-indexed subset of `M` ("the roots"), an `ι`-indexed subset of `N`
("the coroots"), and an `ι`-indexed set of permutations of `ι`, such that each root-coroot pair
evaluates to `2`, and the permutation attached to each element of `ι` is compatible with the
reflections on the corresponding roots and coroots.

It exists to allow for a convenient unification of the theories of root systems and root data. -/
structure RootPairing extends PerfectPairing R M N :=
  /-- A parametrized family of vectors, called roots. -/
  root : ι ↪ M
  /-- A parametrized family of dual vectors, called coroots. -/
  coroot : ι ↪ N
  root_coroot_two : ∀ i, toLin (root i) (coroot i) = 2
  /-- A parametrized family of permutations, induced by reflection. -/
  reflection_perm : ι → (ι ≃ ι)
  reflection_perm_root : ∀ i j,
    root j - toLin (root j) (coroot i) • root i = root (reflection_perm i j)
  reflection_perm_coroot : ∀ i j,
    coroot j - toLin (root i) (coroot j) • coroot i = coroot (reflection_perm i j)
goal: ι ↪ N

full_name: RootPairing.reflection_perm_root
code: /-- Given two perfectly-paired `R`-modules `M` and `N`, a root pairing with indexing set `ι`
is the data of an `ι`-indexed subset of `M` ("the roots"), an `ι`-indexed subset of `N`
("the coroots"), and an `ι`-indexed set of permutations of `ι`, such that each root-coroot pair
evaluates to `2`, and the permutation attached to each element of `ι` is compatible with the
reflections on the corresponding roots and coroots.

It exists to allow for a convenient unification of the theories of root systems and root data. -/
structure RootPairing extends PerfectPairing R M N :=
  /-- A parametrized family of vectors, called roots. -/
  root : ι ↪ M
  /-- A parametrized family of dual vectors, called coroots. -/
  coroot : ι ↪ N
  root_coroot_two : ∀ i, toLin (root i) (coroot i) = 2
  /-- A parametrized family of permutations, induced by reflection. -/
  reflection_perm : ι → (ι ≃ ι)
  reflection_perm_root : ∀ i j,
    root j - toLin (root j) (coroot i) • root i = root (reflection_perm i j)
  reflection_perm_coroot : ∀ i j,
    coroot j - toLin (root i) (coroot j) • coroot i = coroot (reflection_perm i j)
goal: self.root j - (self.toLin (self.root j)) (self.coroot i) • self.root i = self.root ((self.reflection_perm i) j)

full_name: RootPairing.reflection_perm
code: /-- Given two perfectly-paired `R`-modules `M` and `N`, a root pairing with indexing set `ι`
is the data of an `ι`-indexed subset of `M` ("the roots"), an `ι`-indexed subset of `N`
("the coroots"), and an `ι`-indexed set of permutations of `ι`, such that each root-coroot pair
evaluates to `2`, and the permutation attached to each element of `ι` is compatible with the
reflections on the corresponding roots and coroots.

It exists to allow for a convenient unification of the theories of root systems and root data. -/
structure RootPairing extends PerfectPairing R M N :=
  /-- A parametrized family of vectors, called roots. -/
  root : ι ↪ M
  /-- A parametrized family of dual vectors, called coroots. -/
  coroot : ι ↪ N
  root_coroot_two : ∀ i, toLin (root i) (coroot i) = 2
  /-- A parametrized family of permutations, induced by reflection. -/
  reflection_perm : ι → (ι ≃ ι)
  reflection_perm_root : ∀ i j,
    root j - toLin (root j) (coroot i) • root i = root (reflection_perm i j)
  reflection_perm_coroot : ∀ i j,
    coroot j - toLin (root i) (coroot j) • coroot i = coroot (reflection_perm i j)
goal: ι → ι ≃ ι

full_name: RootPairing.reflection_perm_coroot
code: /-- Given two perfectly-paired `R`-modules `M` and `N`, a root pairing with indexing set `ι`
is the data of an `ι`-indexed subset of `M` ("the roots"), an `ι`-indexed subset of `N`
("the coroots"), and an `ι`-indexed set of permutations of `ι`, such that each root-coroot pair
evaluates to `2`, and the permutation attached to each element of `ι` is compatible with the
reflections on the corresponding roots and coroots.

It exists to allow for a convenient unification of the theories of root systems and root data. -/
structure RootPairing extends PerfectPairing R M N :=
  /-- A parametrized family of vectors, called roots. -/
  root : ι ↪ M
  /-- A parametrized family of dual vectors, called coroots. -/
  coroot : ι ↪ N
  root_coroot_two : ∀ i, toLin (root i) (coroot i) = 2
  /-- A parametrized family of permutations, induced by reflection. -/
  reflection_perm : ι → (ι ≃ ι)
  reflection_perm_root : ∀ i j,
    root j - toLin (root j) (coroot i) • root i = root (reflection_perm i j)
  reflection_perm_coroot : ∀ i j,
    coroot j - toLin (root i) (coroot j) • coroot i = coroot (reflection_perm i j)
goal: self.coroot j - (self.toLin (self.root i)) (self.coroot j) • self.coroot i = self.coroot ((self.reflection_perm i) j)

full_name: RootPairing
code: /-- Given two perfectly-paired `R`-modules `M` and `N`, a root pairing with indexing set `ι`
is the data of an `ι`-indexed subset of `M` ("the roots"), an `ι`-indexed subset of `N`
("the coroots"), and an `ι`-indexed set of permutations of `ι`, such that each root-coroot pair
evaluates to `2`, and the permutation attached to each element of `ι` is compatible with the
reflections on the corresponding roots and coroots.

It exists to allow for a convenient unification of the theories of root systems and root data. -/
structure RootPairing extends PerfectPairing R M N :=
  /-- A parametrized family of vectors, called roots. -/
  root : ι ↪ M
  /-- A parametrized family of dual vectors, called coroots. -/
  coroot : ι ↪ N
  root_coroot_two : ∀ i, toLin (root i) (coroot i) = 2
  /-- A parametrized family of permutations, induced by reflection. -/
  reflection_perm : ι → (ι ≃ ι)
  reflection_perm_root : ∀ i j,
    root j - toLin (root j) (coroot i) • root i = root (reflection_perm i j)
  reflection_perm_coroot : ∀ i j,
    coroot j - toLin (root i) (coroot j) • coroot i = coroot (reflection_perm i j)
goal: Type (max (max (max u_1 u_2) u_3) u_4)

full_name: RootDatum
code: /-- A root datum is a root pairing with coefficients in the integers and for which the root and
coroot spaces are finitely-generated free Abelian groups.

Note that the latter assumptions `[Free ℤ X₁] [Finite ℤ X₁] [Free ℤ X₂] [Finite ℤ X₂]` should be
supplied as mixins. -/
abbrev RootDatum (X₁ X₂ : Type*) [AddCommGroup X₁] [AddCommGroup X₂] 
goal: Type (max (max u_1 u_5) u_6)

full_name: RootSystem.span_eq_top
code: /-- A root system is a root pairing for which the roots span their ambient module.

Note that this is slightly more general than the usual definition in the sense that `N` is not
required to be the dual of `M`. -/
structure RootSystem extends RootPairing ι R M N :=
  span_eq_top : span R (range root) = ⊤
goal: Submodule.span R (Set.range ⇑self.root) = ⊤

full_name: RootSystem
code: /-- A root system is a root pairing for which the roots span their ambient module.

Note that this is slightly more general than the usual definition in the sense that `N` is not
required to be the dual of `M`. -/
structure RootSystem extends RootPairing ι R M N :=
  span_eq_top : span R (range root) = ⊤
goal: Type (max (max (max u_1 u_2) u_3) u_4)

full_name: RootPairing.ne_zero
code: lemma ne_zero [CharZero R] : (P.root i : M) ≠ 0 
goal: P.root i ≠ 0

full_name: RootPairing.ne_zero'
code: lemma ne_zero' [CharZero R] : (P.coroot i : N) ≠ 0 
goal: P.coroot i ≠ 0

full_name: RootPairing.flip
code: /-- If we interchange the roles of `M` and `N`, we still have a root pairing. -/
protected def flip : RootPairing ι R N M 
goal: RootPairing ι R N M

full_name: RootPairing.flip_flip
code: @[simp]
lemma flip_flip : P.flip.flip = P 
goal: P.flip.flip = P

full_name: RootPairing.pairing
code: /-- This is the pairing between roots and coroots. -/
def pairing : R 
goal: R

full_name: RootPairing.root_coroot_eq_pairing
code: @[simp]
lemma root_coroot_eq_pairing : P.toLin (P.root i) (P.coroot j) = P.pairing i j 
goal: (P.toLin (P.root i)) (P.coroot j) = P.pairing i j

full_name: RootPairing.coroot_root_eq_pairing
code: lemma coroot_root_eq_pairing : P.toLin.flip (P.coroot i) (P.root j) = P.pairing j i 
goal: (P.toLin.flip (P.coroot i)) (P.root j) = P.pairing j i

full_name: RootPairing.pairing_same
code: @[simp]
lemma pairing_same : P.pairing i i = 2 
goal: P.pairing i i = 2

full_name: RootPairing.coroot_root_two
code: lemma coroot_root_two :
    P.toLin.flip (P.coroot i) (P.root i) = 2 
goal: (P.toLin.flip (P.coroot i)) (P.root i) = 2

full_name: RootPairing.reflection
code: /-- The reflection associated to a root. -/
def reflection : M ≃ₗ[R] M 
goal: M ≃ₗ[R] M

full_name: RootPairing.root_reflection_perm
code: @[simp]
lemma root_reflection_perm (j : ι) :
    P.root (P.reflection_perm i j) = (P.reflection i) (P.root j) 
goal: P.root ((P.reflection_perm i) j) = (P.reflection i) (P.root j)

full_name: RootPairing.mapsTo_reflection_root
code: theorem mapsTo_reflection_root :
    MapsTo (P.reflection i) (range P.root) (range P.root) 
goal: Set.MapsTo (⇑(P.reflection i)) (Set.range ⇑P.root) (Set.range ⇑P.root)

full_name: RootPairing.reflection_apply
code: lemma reflection_apply (x : M) :
    P.reflection i x = x - (P.toLin x (P.coroot i)) • P.root i 
goal: (P.reflection i) x = x - (P.toLin x) (P.coroot i) • P.root i

full_name: RootPairing.reflection_apply_root
code: lemma reflection_apply_root :
    P.reflection i (P.root j) = P.root j - (P.pairing j i) • P.root i 
goal: (P.reflection i) (P.root j) = P.root j - P.pairing j i • P.root i

full_name: RootPairing.reflection_apply_self
code: @[simp]
lemma reflection_apply_self :
    P.reflection i (P.root i) = - P.root i 
goal: (P.reflection i) (P.root i) = -P.root i

full_name: RootPairing.reflection_same
code: @[simp]
lemma reflection_same (x : M) :
    P.reflection i (P.reflection i x) = x 
goal: (P.reflection i) ((P.reflection i) x) = x

full_name: RootPairing.bijOn_reflection_root
code: lemma bijOn_reflection_root :
    BijOn (P.reflection i) (range P.root) (range P.root) 
goal: Set.BijOn (⇑(P.reflection i)) (Set.range ⇑P.root) (Set.range ⇑P.root)

full_name: RootPairing.reflection_image_eq
code: @[simp]
lemma reflection_image_eq :
    P.reflection i '' (range P.root) = range P.root 
goal: ⇑(P.reflection i) '' Set.range ⇑P.root = Set.range ⇑P.root

full_name: RootPairing.coreflection
code: /-- The reflection associated to a coroot. -/
def coreflection : N ≃ₗ[R] N 
goal: N ≃ₗ[R] N

full_name: RootPairing.coroot_reflection_perm
code: @[simp]
lemma coroot_reflection_perm (j : ι) :
    P.coroot (P.reflection_perm i j) = (P.coreflection i) (P.coroot j) 
goal: P.coroot ((P.reflection_perm i) j) = (P.coreflection i) (P.coroot j)

full_name: RootPairing.mapsTo_coreflection_coroot
code: theorem mapsTo_coreflection_coroot :
    MapsTo (P.coreflection i) (range P.coroot) (range P.coroot) 
goal: Set.MapsTo (⇑(P.coreflection i)) (Set.range ⇑P.coroot) (Set.range ⇑P.coroot)

full_name: RootPairing.coreflection_apply
code: lemma coreflection_apply (f : N) :
    P.coreflection i f = f - (P.toLin (P.root i) f) • P.coroot i 
goal: (P.coreflection i) f = f - (P.toLin (P.root i)) f • P.coroot i

full_name: RootPairing.coreflection_apply_coroot
code: lemma coreflection_apply_coroot :
    P.coreflection i (P.coroot j) = P.coroot j - (P.pairing i j) • P.coroot i 
goal: (P.coreflection i) (P.coroot j) = P.coroot j - P.pairing i j • P.coroot i

full_name: RootPairing.coreflection_apply_self
code: @[simp]
lemma coreflection_apply_self :
    P.coreflection i (P.coroot i) = - P.coroot i 
goal: (P.coreflection i) (P.coroot i) = -P.coroot i

full_name: RootPairing.coreflection_same
code: @[simp]
lemma coreflection_same (x : N) :
    P.coreflection i (P.coreflection i x) = x 
goal: (P.coreflection i) ((P.coreflection i) x) = x

full_name: RootPairing.bijOn_coreflection_coroot
code: lemma bijOn_coreflection_coroot : BijOn (P.coreflection i) (range P.coroot) (range P.coroot) 
goal: Set.BijOn (⇑(P.coreflection i)) (Set.range ⇑P.coroot) (Set.range ⇑P.coroot)

full_name: RootPairing.coreflection_image_eq
code: @[simp]
lemma coreflection_image_eq :
    P.coreflection i '' (range P.coroot) = range P.coroot 
goal: ⇑(P.coreflection i) '' Set.range ⇑P.coroot = Set.range ⇑P.coroot

full_name: RootPairing.coreflection_eq_flip_reflection
code: lemma coreflection_eq_flip_reflection :
    P.coreflection i = P.flip.reflection i 
goal: P.coreflection i = P.flip.reflection i

full_name: RootPairing.reflection_dualMap_eq_coreflection
code: lemma reflection_dualMap_eq_coreflection :
    (P.reflection i).dualMap ∘ₗ P.toLin.flip = P.toLin.flip ∘ₗ P.coreflection i 
goal: ↑(P.reflection i).dualMap ∘ₗ P.toLin.flip = P.toLin.flip ∘ₗ ↑(P.coreflection i)

full_name: RootPairing.coroot_eq_coreflection_of_root_eq
code: lemma coroot_eq_coreflection_of_root_eq
    {i j k : ι} (hk : P.root k = P.reflection i (P.root j)) :
    P.coroot k = P.coreflection i (P.coroot j) 
goal: P.coroot k = (P.coreflection i) (P.coroot j)

full_name: RootPairing.IsCrystallographic
code: /-- A root pairing is said to be crystallographic if the pairing between a root and coroot is
always an integer. -/
def IsCrystallographic : Prop 
goal: Prop

full_name: RootPairing.isCrystallographic_iff
code: lemma isCrystallographic_iff :
    P.IsCrystallographic ↔ ∀ i j, ∃ z : ℤ, z = P.pairing i j 
goal: P.IsCrystallographic ↔ ∀ (i j : ι), ∃ z, ↑z = P.pairing i j

full_name: RootPairing.IsReduced
code: /-- A root pairing is said to be reduced if any linearly dependent pair of roots is related by a
sign. -/
def IsReduced : Prop 
goal: Prop

full_name: RootPairing.isReduced_iff
code: lemma isReduced_iff : P.IsReduced ↔ ∀ i j : ι, i ≠ j →
    ¬ LinearIndependent R ![P.root i, P.root j] → P.root i = - P.root j 
goal: P.IsReduced ↔ ∀ (i j : ι), i ≠ j → ¬LinearIndependent R ![P.root i, P.root j] → P.root i = -P.root j

full_name: RootPairing.coxeterWeight
code: /-- The Coxeter Weight of a pair gives the weight of an edge in a Coxeter diagram, when it is
finite.  It is `4 cos² θ`, where `θ` describes the dihedral angle between hyperplanes. -/
def coxeterWeight : R 
goal: R

full_name: RootPairing.coxeterWeight_swap
code: lemma coxeterWeight_swap : coxeterWeight P i j = coxeterWeight P j i 
goal: P.coxeterWeight i j = P.coxeterWeight j i

full_name: RootPairing.IsOrthogonal
code: /-- Two roots are orthogonal when they are fixed by each others' reflections. -/
def IsOrthogonal : Prop 
goal: Prop

full_name: RootPairing.IsOrthogonal.symm
code: lemma IsOrthogonal.symm : IsOrthogonal P i j ↔ IsOrthogonal P j i 
goal: P.IsOrthogonal i j ↔ P.IsOrthogonal j i

full_name: RootPairing.isOrthogonal_comm
code: lemma isOrthogonal_comm (h : IsOrthogonal P i j) : Commute (P.reflection i) (P.reflection j) 
goal: Commute (P.reflection i) (P.reflection j)