File: Mathlib/LinearAlgebra/RootSystem/Basic.lean

full_name: _private.Mathlib.LinearAlgebra.RootSystem.Basic.0.RootPairing.exist_eq_reflection_of_mapsTo
code: private theorem exist_eq_reflection_of_mapsTo  :
    ∃ k, root k = (preReflection (root i) (p.toLin.flip (coroot i))) (root j) 
goal: ∃ k, root k = (Module.preReflection (root i) (p.toLin.flip (coroot i))) (root j)

full_name: _private.Mathlib.LinearAlgebra.RootSystem.Basic.0.RootPairing.choose_choose_eq_of_mapsTo
code: private theorem choose_choose_eq_of_mapsTo :
    (exist_eq_reflection_of_mapsTo p root coroot i
      (exist_eq_reflection_of_mapsTo p root coroot i j h).choose h).choose = j 
goal: ⋯.choose = j

full_name: RootPairing.equiv_of_mapsTo
code: /-- The bijection on the indexing set induced by reflection. -/
@[simps]
protected def equiv_of_mapsTo :
    ι ≃ ι 
goal: ι ≃ ι

full_name: RootPairing.equiv_of_mapsTo_apply
code: /-- The bijection on the indexing set induced by reflection. -/
@[simps]
protected def equiv_of_mapsTo :
    ι ≃ ι 
goal: (RootPairing.equiv_of_mapsTo p root coroot i h hp) j = ⋯.choose

full_name: RootPairing.equiv_of_mapsTo_symm_apply
code: /-- The bijection on the indexing set induced by reflection. -/
@[simps]
protected def equiv_of_mapsTo :
    ι ≃ ι 
goal: (RootPairing.equiv_of_mapsTo p root coroot i h hp).symm j = ⋯.choose

full_name: RootPairing.injOn_dualMap_subtype_span_root_coroot
code: /-- Even though the roots may not span, coroots are distinguished by their pairing with the
roots. The proof depends crucially on the fact that there are finitely-many roots.

Modulo trivial generalisations, this statement is exactly Lemma 1.1.4 on page 87 of SGA 3 XXI. -/
lemma injOn_dualMap_subtype_span_root_coroot [NoZeroSMulDivisors ℤ M] :
    InjOn ((span R (range P.root)).subtype.dualMap ∘ₗ P.toLin.flip) (range P.coroot) 
goal: Set.InjOn (⇑((Submodule.span R (Set.range ⇑P.root)).subtype.dualMap ∘ₗ P.toLin.flip)) (Set.range ⇑P.coroot)

full_name: RootPairing.ext
code: /-- In characteristic zero if there is no torsion, the correspondence between roots and coroots is
unique.

Formally, the point is that the hypothesis `hc` depends only on the range of the coroot mappings. -/
@[ext]
protected lemma ext [CharZero R] [NoZeroSMulDivisors R M]
    {P₁ P₂ : RootPairing ι R M N}
    (he : P₁.toLin = P₂.toLin)
    (hr : P₁.root = P₂.root)
    (hc : range P₁.coroot = range P₂.coroot) :
    P₁ = P₂ 
goal: P₁ = P₂

full_name: _private.Mathlib.LinearAlgebra.RootSystem.Basic.0.RootPairing.coroot_eq_coreflection_of_root_eq'
code: private lemma coroot_eq_coreflection_of_root_eq' [CharZero R] [NoZeroSMulDivisors R M]
    (p : PerfectPairing R M N)
    (root : ι ↪ M)
    (coroot : ι ↪ N)
    (hp : ∀ i, p.toLin (root i) (coroot i) = 2)
    (hr : ∀ i, MapsTo (preReflection (root i) (p.toLin.flip (coroot i))) (range root) (range root))
    (hc : ∀ i, MapsTo (preReflection (coroot i) (p.toLin (root i))) (range coroot) (range coroot))
    {i j k : ι} (hk : root k = preReflection (root i) (p.toLin.flip (coroot i)) (root j)) :
    coroot k = preReflection (coroot i) (p.toLin (root i)) (coroot j) 
goal: coroot k = (Module.preReflection (coroot i) (p.toLin (root i))) (coroot j)

full_name: RootPairing.mk'
code: /-- In characteristic zero if there is no torsion, to check that two finite familes of of roots and
coroots form a root pairing, it is sufficient to check that they are stable under reflections. -/
def mk' [Finite ι] [CharZero R] [NoZeroSMulDivisors R M]
    (p : PerfectPairing R M N)
    (root : ι ↪ M)
    (coroot : ι ↪ N)
    (hp : ∀ i, p.toLin (root i) (coroot i) = 2)
    (hr : ∀ i, MapsTo (preReflection (root i) (p.toLin.flip (coroot i))) (range root) (range root))
    (hc : ∀ i, MapsTo (preReflection (coroot i) (p.toLin (root i))) (range coroot) (range coroot)) :
    RootPairing ι R M N 
goal: RootPairing ι R M N

full_name: RootSystem.ext
code: /-- In characteristic zero if there is no torsion, a finite root system is determined entirely by
its roots. -/
@[ext]
protected lemma ext [CharZero R] [NoZeroSMulDivisors R M]
    {P₁ P₂ : RootSystem ι R M N}
    (he : P₁.toLin = P₂.toLin)
    (hr : P₁.root = P₂.root) :
    P₁ = P₂ 
goal: P₁ = P₂

full_name: _private.Mathlib.LinearAlgebra.RootSystem.Basic.0.RootSystem.coroot_eq_coreflection_of_root_eq_of_span_eq_top
code: private lemma coroot_eq_coreflection_of_root_eq_of_span_eq_top [CharZero R] [NoZeroSMulDivisors R M]
    (p : PerfectPairing R M N)
    (root : ι ↪ M)
    (coroot : ι ↪ N)
    (hp : ∀ i, p.toLin (root i) (coroot i) = 2)
    (hs : ∀ i, MapsTo (preReflection (root i) (p.toLin.flip (coroot i))) (range root) (range root))
    (hsp : span R (range root) = ⊤)
    {i j k : ι} (hk : root k = preReflection (root i) (p.toLin.flip (coroot i)) (root j)) :
    coroot k = preReflection (coroot i) (p.toLin (root i)) (coroot j) 
goal: coroot k = (Module.preReflection (coroot i) (p.toLin (root i))) (coroot j)

full_name: RootSystem.mk'
code: /-- In characteristic zero if there is no torsion, to check that a finite family of roots form a
root system, we do not need to check that the coroots are stable under reflections since this
follows from the corresponding property for the roots. -/
def mk' [CharZero R] [NoZeroSMulDivisors R M]
    (p : PerfectPairing R M N)
    (root : ι ↪ M)
    (coroot : ι ↪ N)
    (hp : ∀ i, p.toLin (root i) (coroot i) = 2)
    (hs : ∀ i, MapsTo (preReflection (root i) (p.toLin.flip (coroot i))) (range root) (range root))
    (hsp : span R (range root) = ⊤) :
    RootSystem ι R M N 
goal: RootSystem ι R M N