algebra.lie.ideal_operations | Mathlib porting status

Changes since the initial port

The following section lists changes to this file in mathlib3 and mathlib4 that occured after the initial port. Most recent changes are shown first. Hovering over a commit will show all commits associated with the same mathlib3 commit.

Changes in mathlib3

8983bec7

(last sync)

Changes in mathlib3port

mathlib3

mathlib3port

5c1efce1

bump to nightly-2024-03-17-08

mathlib commit https://github.com/leanprover-community/mathlib/commit/65a1391a0106c9204fe45bc73a039f056558cb83

22f01ce4

Diff

@@ -171,7 +171,7 @@ theorem bot_lie : ⁅(⊥ : LieIdeal R L), N⁆ = ⊥ :=
   by
   suffices ⁅(⊥ : LieIdeal R L), N⁆ ≤ ⊥ by exact le_bot_iff.mp this
   rw [lie_ideal_oper_eq_span, lie_span_le]; rintro m ⟨⟨x, hx⟩, n, hn⟩; rw [← hn]
-  change x ∈ (⊥ : LieIdeal R L) at hx ; rw [mem_bot] at hx ; simp [hx]
+  change x ∈ (⊥ : LieIdeal R L) at hx; rw [mem_bot] at hx; simp [hx]
 #align lie_submodule.bot_lie LieSubmodule.bot_lie
 -/
 
@@ -189,7 +189,7 @@ theorem lie_eq_bot_iff : ⁅I, N⁆ = ⊥ ↔ ∀ x ∈ I, ∀ m ∈ N, ⁅(x :
 theorem mono_lie (h₁ : I ≤ J) (h₂ : N ≤ N') : ⁅I, N⁆ ≤ ⁅J, N'⁆ :=
   by
   intro m h
-  rw [lie_ideal_oper_eq_span, mem_lie_span] at h ; rw [lie_ideal_oper_eq_span, mem_lie_span]
+  rw [lie_ideal_oper_eq_span, mem_lie_span] at h; rw [lie_ideal_oper_eq_span, mem_lie_span]
   intro N hN; apply h; rintro m' ⟨⟨x, hx⟩, ⟨n, hn⟩, hm⟩; rw [← hm]; apply hN
   use⟨x, h₁ hx⟩, ⟨n, h₂ hn⟩; rfl
 #align lie_submodule.mono_lie LieSubmodule.mono_lie
@@ -215,7 +215,7 @@ theorem lie_sup : ⁅I, N ⊔ N'⁆ = ⁅I, N⁆ ⊔ ⁅I, N'⁆ :=
     constructor <;> apply mono_lie_right <;> [exact le_sup_left; exact le_sup_right]
   suffices ⁅I, N ⊔ N'⁆ ≤ ⁅I, N⁆ ⊔ ⁅I, N'⁆ by exact le_antisymm this h; clear h
   rw [lie_ideal_oper_eq_span, lie_span_le]; rintro m ⟨x, ⟨n, hn⟩, h⟩; erw [LieSubmodule.mem_sup]
-  erw [LieSubmodule.mem_sup] at hn ; rcases hn with ⟨n₁, hn₁, n₂, hn₂, hn'⟩
+  erw [LieSubmodule.mem_sup] at hn; rcases hn with ⟨n₁, hn₁, n₂, hn₂, hn'⟩
   use⁅(x : L), (⟨n₁, hn₁⟩ : N)⁆; constructor; · apply lie_coe_mem_lie
   use⁅(x : L), (⟨n₂, hn₂⟩ : N')⁆; constructor; · apply lie_coe_mem_lie
   simp [← h, ← hn']
@@ -230,7 +230,7 @@ theorem sup_lie : ⁅I ⊔ J, N⁆ = ⁅I, N⁆ ⊔ ⁅J, N⁆ :=
     constructor <;> apply mono_lie_left <;> [exact le_sup_left; exact le_sup_right]
   suffices ⁅I ⊔ J, N⁆ ≤ ⁅I, N⁆ ⊔ ⁅J, N⁆ by exact le_antisymm this h; clear h
   rw [lie_ideal_oper_eq_span, lie_span_le]; rintro m ⟨⟨x, hx⟩, n, h⟩; erw [LieSubmodule.mem_sup]
-  erw [LieSubmodule.mem_sup] at hx ; rcases hx with ⟨x₁, hx₁, x₂, hx₂, hx'⟩
+  erw [LieSubmodule.mem_sup] at hx; rcases hx with ⟨x₁, hx₁, x₂, hx₂, hx'⟩
   use⁅((⟨x₁, hx₁⟩ : I) : L), (n : N)⁆; constructor; · apply lie_coe_mem_lie
   use⁅((⟨x₂, hx₂⟩ : J) : L), (n : N)⁆; constructor; · apply lie_coe_mem_lie
   simp [← h, ← hx']
@@ -262,7 +262,7 @@ theorem map_bracket_eq : map f ⁅I, N⁆ = ⁅I, map f N⁆ :=
   ext m
   constructor
   · rintro ⟨-, ⟨⟨x, ⟨n, hn⟩, rfl⟩, hm⟩⟩
-    simp only [LieModuleHom.coe_toLinearMap, LieModuleHom.map_lie] at hm 
+    simp only [LieModuleHom.coe_toLinearMap, LieModuleHom.map_lie] at hm
     exact ⟨x, ⟨f n, (mem_map (f n)).mpr ⟨n, hn, rfl⟩⟩, hm⟩
   · rintro ⟨x, ⟨m₂, hm₂ : m₂ ∈ map f N⟩, rfl⟩
     obtain ⟨n, hn, rfl⟩ := (mem_map m₂).mp hm₂
@@ -388,9 +388,9 @@ theorem comap_bracket_eq {J₁ J₂ : LieIdeal R L'} (h : f.IsIdealMorphism) :
   congr; simp only [LieHom.coe_toLinearMap, Set.mem_setOf_eq]; ext y
   constructor
   · rintro ⟨⟨x₁, hx₁⟩, ⟨x₂, hx₂⟩, hy⟩; rw [← hy]
-    erw [LieSubmodule.mem_inf, f.mem_ideal_range_iff h] at hx₁ hx₂ 
-    obtain ⟨⟨z₁, hz₁⟩, hz₁'⟩ := hx₁; rw [← hz₁] at hz₁' 
-    obtain ⟨⟨z₂, hz₂⟩, hz₂'⟩ := hx₂; rw [← hz₂] at hz₂' 
+    erw [LieSubmodule.mem_inf, f.mem_ideal_range_iff h] at hx₁ hx₂
+    obtain ⟨⟨z₁, hz₁⟩, hz₁'⟩ := hx₁; rw [← hz₁] at hz₁'
+    obtain ⟨⟨z₂, hz₂⟩, hz₂'⟩ := hx₂; rw [← hz₂] at hz₂'
     use⁅z₁, z₂⁆, ⟨z₁, hz₁'⟩, ⟨z₂, hz₂'⟩, rfl
     simp only [hz₁, hz₂, Submodule.coe_mk, LieHom.map_lie]
   · rintro ⟨x, ⟨⟨z₁, hz₁⟩, ⟨z₂, hz₂⟩, hx⟩, hy⟩; rw [← hy, ← hx]
@@ -429,7 +429,7 @@ theorem comap_bracket_incl {I₁ I₂ : LieIdeal R L} :
 Lie bracket operation on ideals, subject to the conditions shown. -/
 theorem comap_bracket_incl_of_le {I₁ I₂ : LieIdeal R L} (h₁ : I₁ ≤ I) (h₂ : I₂ ≤ I) :
     ⁅comap I.incl I₁, comap I.incl I₂⁆ = comap I.incl ⁅I₁, I₂⁆ := by rw [comap_bracket_incl];
-  rw [← inf_eq_right] at h₁ h₂ ; rw [h₁, h₂]
+  rw [← inf_eq_right] at h₁ h₂; rw [h₁, h₂]
 #align lie_ideal.comap_bracket_incl_of_le LieIdeal.comap_bracket_incl_of_le
 -/

5c1efce1

bump to nightly-2023-09-24-06

mathlib commit https://github.com/leanprover-community/mathlib/commit/ce64cd319bb6b3e82f31c2d38e79080d377be451

5655435f

Diff

@@ -3,7 +3,7 @@ Copyright (c) 2021 Oliver Nash. All rights reserved.
 Released under Apache 2.0 license as described in the file LICENSE.
 Authors: Oliver Nash
 -/
-import Mathbin.Algebra.Lie.Submodule
+import Algebra.Lie.Submodule
 
 #align_import algebra.lie.ideal_operations from "leanprover-community/mathlib"@"5c1efce12ba86d4901463f61019832f6a4b1a0d0"

5c1efce1

bump to nightly-2023-08-02-01

mathlib commit https://github.com/leanprover-community/mathlib/commit/63721b2c3eba6c325ecf8ae8cca27155a4f6306f

7aca3f15

Diff

@@ -81,7 +81,7 @@ theorem lieIdeal_oper_eq_linear_span :
       intro y m' hm'; apply Submodule.span_induction hm'
       · rintro m'' ⟨x, n, hm''⟩; rw [← hm'', leibniz_lie]
         refine' Submodule.add_mem _ _ _ <;> apply Submodule.subset_span
-        · use ⟨⁅y, ↑x⁆, I.lie_mem x.property⟩, n; rfl
+        · use⟨⁅y, ↑x⁆, I.lie_mem x.property⟩, n; rfl
         · use x, ⟨⁅y, ↑n⁆, N.lie_mem n.property⟩; rfl
       · simp only [lie_zero, Submodule.zero_mem]
       · intro m₁ m₂ hm₁ hm₂; rw [lie_add]; exact Submodule.add_mem _ hm₁ hm₂
@@ -191,7 +191,7 @@ theorem mono_lie (h₁ : I ≤ J) (h₂ : N ≤ N') : ⁅I, N⁆ ≤ ⁅J, N'⁆
   intro m h
   rw [lie_ideal_oper_eq_span, mem_lie_span] at h ; rw [lie_ideal_oper_eq_span, mem_lie_span]
   intro N hN; apply h; rintro m' ⟨⟨x, hx⟩, ⟨n, hn⟩, hm⟩; rw [← hm]; apply hN
-  use ⟨x, h₁ hx⟩, ⟨n, h₂ hn⟩; rfl
+  use⟨x, h₁ hx⟩, ⟨n, h₂ hn⟩; rfl
 #align lie_submodule.mono_lie LieSubmodule.mono_lie
 -/
 
@@ -216,8 +216,8 @@ theorem lie_sup : ⁅I, N ⊔ N'⁆ = ⁅I, N⁆ ⊔ ⁅I, N'⁆ :=
   suffices ⁅I, N ⊔ N'⁆ ≤ ⁅I, N⁆ ⊔ ⁅I, N'⁆ by exact le_antisymm this h; clear h
   rw [lie_ideal_oper_eq_span, lie_span_le]; rintro m ⟨x, ⟨n, hn⟩, h⟩; erw [LieSubmodule.mem_sup]
   erw [LieSubmodule.mem_sup] at hn ; rcases hn with ⟨n₁, hn₁, n₂, hn₂, hn'⟩
-  use ⁅(x : L), (⟨n₁, hn₁⟩ : N)⁆; constructor; · apply lie_coe_mem_lie
-  use ⁅(x : L), (⟨n₂, hn₂⟩ : N')⁆; constructor; · apply lie_coe_mem_lie
+  use⁅(x : L), (⟨n₁, hn₁⟩ : N)⁆; constructor; · apply lie_coe_mem_lie
+  use⁅(x : L), (⟨n₂, hn₂⟩ : N')⁆; constructor; · apply lie_coe_mem_lie
   simp [← h, ← hn']
 #align lie_submodule.lie_sup LieSubmodule.lie_sup
 -/
@@ -231,8 +231,8 @@ theorem sup_lie : ⁅I ⊔ J, N⁆ = ⁅I, N⁆ ⊔ ⁅J, N⁆ :=
   suffices ⁅I ⊔ J, N⁆ ≤ ⁅I, N⁆ ⊔ ⁅J, N⁆ by exact le_antisymm this h; clear h
   rw [lie_ideal_oper_eq_span, lie_span_le]; rintro m ⟨⟨x, hx⟩, n, h⟩; erw [LieSubmodule.mem_sup]
   erw [LieSubmodule.mem_sup] at hx ; rcases hx with ⟨x₁, hx₁, x₂, hx₂, hx'⟩
-  use ⁅((⟨x₁, hx₁⟩ : I) : L), (n : N)⁆; constructor; · apply lie_coe_mem_lie
-  use ⁅((⟨x₂, hx₂⟩ : J) : L), (n : N)⁆; constructor; · apply lie_coe_mem_lie
+  use⁅((⟨x₁, hx₁⟩ : I) : L), (n : N)⁆; constructor; · apply lie_coe_mem_lie
+  use⁅((⟨x₂, hx₂⟩ : J) : L), (n : N)⁆; constructor; · apply lie_coe_mem_lie
   simp [← h, ← hx']
 #align lie_submodule.sup_lie LieSubmodule.sup_lie
 -/
@@ -357,7 +357,7 @@ theorem map_bracket_eq {I₁ I₂ : LieIdeal R L} (h : Function.Surjective f) :
   rintro x ⟨⟨z₁, h₁⟩, ⟨z₂, h₂⟩, rfl⟩
   obtain ⟨y₁, rfl⟩ := mem_map_of_surjective h h₁
   obtain ⟨y₂, rfl⟩ := mem_map_of_surjective h h₂
-  use ⁅(y₁ : L), (y₂ : L)⁆, y₁, y₂
+  use⁅(y₁ : L), (y₂ : L)⁆, y₁, y₂
   apply f.map_lie
 #align lie_ideal.map_bracket_eq LieIdeal.map_bracket_eq
 -/
@@ -391,14 +391,14 @@ theorem comap_bracket_eq {J₁ J₂ : LieIdeal R L'} (h : f.IsIdealMorphism) :
     erw [LieSubmodule.mem_inf, f.mem_ideal_range_iff h] at hx₁ hx₂ 
     obtain ⟨⟨z₁, hz₁⟩, hz₁'⟩ := hx₁; rw [← hz₁] at hz₁' 
     obtain ⟨⟨z₂, hz₂⟩, hz₂'⟩ := hx₂; rw [← hz₂] at hz₂' 
-    use ⁅z₁, z₂⁆, ⟨z₁, hz₁'⟩, ⟨z₂, hz₂'⟩, rfl
+    use⁅z₁, z₂⁆, ⟨z₁, hz₁'⟩, ⟨z₂, hz₂'⟩, rfl
     simp only [hz₁, hz₂, Submodule.coe_mk, LieHom.map_lie]
   · rintro ⟨x, ⟨⟨z₁, hz₁⟩, ⟨z₂, hz₂⟩, hx⟩, hy⟩; rw [← hy, ← hx]
     have hz₁' : f z₁ ∈ f.ideal_range ⊓ J₁ := by rw [LieSubmodule.mem_inf];
       exact ⟨f.mem_ideal_range, hz₁⟩
     have hz₂' : f z₂ ∈ f.ideal_range ⊓ J₂ := by rw [LieSubmodule.mem_inf];
       exact ⟨f.mem_ideal_range, hz₂⟩
-    use ⟨f z₁, hz₁'⟩, ⟨f z₂, hz₂'⟩; simp only [Submodule.coe_mk, LieHom.map_lie]
+    use⟨f z₁, hz₁'⟩, ⟨f z₂, hz₂'⟩; simp only [Submodule.coe_mk, LieHom.map_lie]
 #align lie_ideal.comap_bracket_eq LieIdeal.comap_bracket_eq
 -/

5c1efce1

bump to nightly-2023-07-20-09

mathlib commit https://github.com/leanprover-community/mathlib/commit/8ea5598db6caeddde6cb734aa179cc2408dbd345

9c56d0dd

Diff

@@ -2,14 +2,11 @@
 Copyright (c) 2021 Oliver Nash. All rights reserved.
 Released under Apache 2.0 license as described in the file LICENSE.
 Authors: Oliver Nash
-
-! This file was ported from Lean 3 source module algebra.lie.ideal_operations
-! leanprover-community/mathlib commit 5c1efce12ba86d4901463f61019832f6a4b1a0d0
-! Please do not edit these lines, except to modify the commit id
-! if you have ported upstream changes.
 -/
 import Mathbin.Algebra.Lie.Submodule
 
+#align_import algebra.lie.ideal_operations from "leanprover-community/mathlib"@"5c1efce12ba86d4901463f61019832f6a4b1a0d0"
+
 /-!
 # Ideal operations for Lie algebras

5c1efce1

bump to nightly-2023-06-13-21

mathlib commit https://github.com/leanprover-community/mathlib/commit/9fb8964792b4237dac6200193a0d533f1b3f7423

829520ac

Diff

@@ -56,16 +56,20 @@ variable (N N' : LieSubmodule R L M) (I J : LieIdeal R L) (N₂ : LieSubmodule R
 
 section LieIdealOperations
 
+#print LieSubmodule.hasBracket /-
 /-- Given a Lie module `M` over a Lie algebra `L`, the set of Lie ideals of `L` acts on the set
 of submodules of `M`. -/
 instance hasBracket : Bracket (LieIdeal R L) (LieSubmodule R L M) :=
   ⟨fun I N => lieSpan R L {m | ∃ (x : I) (n : N), ⁅(x : L), (n : M)⁆ = m}⟩
 #align lie_submodule.has_bracket LieSubmodule.hasBracket
+-/
 
+#print LieSubmodule.lieIdeal_oper_eq_span /-
 theorem lieIdeal_oper_eq_span :
     ⁅I, N⁆ = lieSpan R L {m | ∃ (x : I) (n : N), ⁅(x : L), (n : M)⁆ = m} :=
   rfl
 #align lie_submodule.lie_ideal_oper_eq_span LieSubmodule.lieIdeal_oper_eq_span
+-/
 
 #print LieSubmodule.lieIdeal_oper_eq_linear_span /-
 /-- See also `lie_submodule.lie_ideal_oper_eq_linear_span'` and
@@ -107,6 +111,7 @@ theorem lieIdeal_oper_eq_linear_span' :
 #align lie_submodule.lie_ideal_oper_eq_linear_span' LieSubmodule.lieIdeal_oper_eq_linear_span'
 -/
 
+#print LieSubmodule.lie_le_iff /-
 theorem lie_le_iff : ⁅I, N⁆ ≤ N' ↔ ∀ x ∈ I, ∀ m ∈ N, ⁅x, m⁆ ∈ N' :=
   by
   rw [lie_ideal_oper_eq_span, LieSubmodule.lieSpan_le]
@@ -114,14 +119,19 @@ theorem lie_le_iff : ⁅I, N⁆ ≤ N' ↔ ∀ x ∈ I, ∀ m ∈ N, ⁅x, m⁆
   rintro h _ ⟨⟨x, hx⟩, ⟨m, hm⟩, rfl⟩
   exact h x hx m hm
 #align lie_submodule.lie_le_iff LieSubmodule.lie_le_iff
+-/
 
+#print LieSubmodule.lie_coe_mem_lie /-
 theorem lie_coe_mem_lie (x : I) (m : N) : ⁅(x : L), (m : M)⁆ ∈ ⁅I, N⁆ := by
   rw [lie_ideal_oper_eq_span]; apply subset_lie_span; use x, m
 #align lie_submodule.lie_coe_mem_lie LieSubmodule.lie_coe_mem_lie
+-/
 
+#print LieSubmodule.lie_mem_lie /-
 theorem lie_mem_lie {x : L} {m : M} (hx : x ∈ I) (hm : m ∈ N) : ⁅x, m⁆ ∈ ⁅I, N⁆ :=
   N.lie_coe_mem_lie I ⟨x, hx⟩ ⟨m, hm⟩
 #align lie_submodule.lie_mem_lie LieSubmodule.lie_mem_lie
+-/
 
 #print LieSubmodule.lie_comm /-
 theorem lie_comm : ⁅I, J⁆ = ⁅J, I⁆ :=
@@ -134,22 +144,31 @@ theorem lie_comm : ⁅I, J⁆ = ⁅J, I⁆ :=
 #align lie_submodule.lie_comm LieSubmodule.lie_comm
 -/
 
+#print LieSubmodule.lie_le_right /-
 theorem lie_le_right : ⁅I, N⁆ ≤ N :=
   by
   rw [lie_ideal_oper_eq_span, lie_span_le]; rintro m ⟨x, n, hn⟩; rw [← hn]
   exact N.lie_mem n.property
 #align lie_submodule.lie_le_right LieSubmodule.lie_le_right
+-/
 
+#print LieSubmodule.lie_le_left /-
 theorem lie_le_left : ⁅I, J⁆ ≤ I := by rw [lie_comm]; exact lie_le_right I J
 #align lie_submodule.lie_le_left LieSubmodule.lie_le_left
+-/
 
+#print LieSubmodule.lie_le_inf /-
 theorem lie_le_inf : ⁅I, J⁆ ≤ I ⊓ J := by rw [le_inf_iff]; exact ⟨lie_le_left I J, lie_le_right J I⟩
 #align lie_submodule.lie_le_inf LieSubmodule.lie_le_inf
+-/
 
+#print LieSubmodule.lie_bot /-
 @[simp]
 theorem lie_bot : ⁅I, (⊥ : LieSubmodule R L M)⁆ = ⊥ := by rw [eq_bot_iff]; apply lie_le_right
 #align lie_submodule.lie_bot LieSubmodule.lie_bot
+-/
 
+#print LieSubmodule.bot_lie /-
 @[simp]
 theorem bot_lie : ⁅(⊥ : LieIdeal R L), N⁆ = ⊥ :=
   by
@@ -157,7 +176,9 @@ theorem bot_lie : ⁅(⊥ : LieIdeal R L), N⁆ = ⊥ :=
   rw [lie_ideal_oper_eq_span, lie_span_le]; rintro m ⟨⟨x, hx⟩, n, hn⟩; rw [← hn]
   change x ∈ (⊥ : LieIdeal R L) at hx ; rw [mem_bot] at hx ; simp [hx]
 #align lie_submodule.bot_lie LieSubmodule.bot_lie
+-/
 
+#print LieSubmodule.lie_eq_bot_iff /-
 theorem lie_eq_bot_iff : ⁅I, N⁆ = ⊥ ↔ ∀ x ∈ I, ∀ m ∈ N, ⁅(x : L), m⁆ = 0 :=
   by
   rw [lie_ideal_oper_eq_span, LieSubmodule.lieSpan_eq_bot_iff]
@@ -165,7 +186,9 @@ theorem lie_eq_bot_iff : ⁅I, N⁆ = ⊥ ↔ ∀ x ∈ I, ∀ m ∈ N, ⁅(x :
   rintro h - ⟨⟨x, hx⟩, ⟨⟨n, hn⟩, rfl⟩⟩
   exact h x hx n hn
 #align lie_submodule.lie_eq_bot_iff LieSubmodule.lie_eq_bot_iff
+-/
 
+#print LieSubmodule.mono_lie /-
 theorem mono_lie (h₁ : I ≤ J) (h₂ : N ≤ N') : ⁅I, N⁆ ≤ ⁅J, N'⁆ :=
   by
   intro m h
@@ -173,15 +196,21 @@ theorem mono_lie (h₁ : I ≤ J) (h₂ : N ≤ N') : ⁅I, N⁆ ≤ ⁅J, N'⁆
   intro N hN; apply h; rintro m' ⟨⟨x, hx⟩, ⟨n, hn⟩, hm⟩; rw [← hm]; apply hN
   use ⟨x, h₁ hx⟩, ⟨n, h₂ hn⟩; rfl
 #align lie_submodule.mono_lie LieSubmodule.mono_lie
+-/
 
+#print LieSubmodule.mono_lie_left /-
 theorem mono_lie_left (h : I ≤ J) : ⁅I, N⁆ ≤ ⁅J, N⁆ :=
   mono_lie _ _ _ _ h (le_refl N)
 #align lie_submodule.mono_lie_left LieSubmodule.mono_lie_left
+-/
 
+#print LieSubmodule.mono_lie_right /-
 theorem mono_lie_right (h : N ≤ N') : ⁅I, N⁆ ≤ ⁅I, N'⁆ :=
   mono_lie _ _ _ _ (le_refl I) h
 #align lie_submodule.mono_lie_right LieSubmodule.mono_lie_right
+-/
 
+#print LieSubmodule.lie_sup /-
 @[simp]
 theorem lie_sup : ⁅I, N ⊔ N'⁆ = ⁅I, N⁆ ⊔ ⁅I, N'⁆ :=
   by
@@ -194,7 +223,9 @@ theorem lie_sup : ⁅I, N ⊔ N'⁆ = ⁅I, N⁆ ⊔ ⁅I, N'⁆ :=
   use ⁅(x : L), (⟨n₂, hn₂⟩ : N')⁆; constructor; · apply lie_coe_mem_lie
   simp [← h, ← hn']
 #align lie_submodule.lie_sup LieSubmodule.lie_sup
+-/
 
+#print LieSubmodule.sup_lie /-
 @[simp]
 theorem sup_lie : ⁅I ⊔ J, N⁆ = ⁅I, N⁆ ⊔ ⁅J, N⁆ :=
   by
@@ -207,16 +238,21 @@ theorem sup_lie : ⁅I ⊔ J, N⁆ = ⁅I, N⁆ ⊔ ⁅J, N⁆ :=
   use ⁅((⟨x₂, hx₂⟩ : J) : L), (n : N)⁆; constructor; · apply lie_coe_mem_lie
   simp [← h, ← hx']
 #align lie_submodule.sup_lie LieSubmodule.sup_lie
+-/
 
+#print LieSubmodule.lie_inf /-
 @[simp]
 theorem lie_inf : ⁅I, N ⊓ N'⁆ ≤ ⁅I, N⁆ ⊓ ⁅I, N'⁆ := by rw [le_inf_iff];
   constructor <;> apply mono_lie_right <;> [exact inf_le_left; exact inf_le_right]
 #align lie_submodule.lie_inf LieSubmodule.lie_inf
+-/
 
+#print LieSubmodule.inf_lie /-
 @[simp]
 theorem inf_lie : ⁅I ⊓ J, N⁆ ≤ ⁅I, N⁆ ⊓ ⁅J, N⁆ := by rw [le_inf_iff];
   constructor <;> apply mono_lie_left <;> [exact inf_le_left; exact inf_le_right]
 #align lie_submodule.inf_lie LieSubmodule.inf_lie
+-/
 
 variable (f : M →ₗ⁅R,L⁆ M₂)
 
@@ -237,25 +273,33 @@ theorem map_bracket_eq : map f ⁅I, N⁆ = ⁅I, map f N⁆ :=
 #align lie_submodule.map_bracket_eq LieSubmodule.map_bracket_eq
 -/
 
+#print LieSubmodule.map_comap_le /-
 theorem map_comap_le : map f (comap f N₂) ≤ N₂ :=
   (N₂ : Set M₂).image_preimage_subset f
 #align lie_submodule.map_comap_le LieSubmodule.map_comap_le
+-/
 
+#print LieSubmodule.map_comap_eq /-
 theorem map_comap_eq (hf : N₂ ≤ f.range) : map f (comap f N₂) = N₂ :=
   by
   rw [SetLike.ext'_iff]
   exact Set.image_preimage_eq_of_subset hf
 #align lie_submodule.map_comap_eq LieSubmodule.map_comap_eq
+-/
 
+#print LieSubmodule.le_comap_map /-
 theorem le_comap_map : N ≤ comap f (map f N) :=
   (N : Set M).subset_preimage_image f
 #align lie_submodule.le_comap_map LieSubmodule.le_comap_map
+-/
 
+#print LieSubmodule.comap_map_eq /-
 theorem comap_map_eq (hf : f.ker = ⊥) : comap f (map f N) = N :=
   by
   rw [SetLike.ext'_iff]
   exact (N : Set M).preimage_image_eq (f.ker_eq_bot.mp hf)
 #align lie_submodule.comap_map_eq LieSubmodule.comap_map_eq
+-/
 
 #print LieSubmodule.comap_bracket_eq /-
 theorem comap_bracket_eq (hf₁ : f.ker = ⊥) (hf₂ : N₂ ≤ f.range) :
@@ -266,12 +310,14 @@ theorem comap_bracket_eq (hf₁ : f.ker = ⊥) (hf₂ : N₂ ≤ f.range) :
 #align lie_submodule.comap_bracket_eq LieSubmodule.comap_bracket_eq
 -/
 
+#print LieSubmodule.map_comap_incl /-
 @[simp]
 theorem map_comap_incl : map N.incl (comap N.incl N') = N ⊓ N' :=
   by
   rw [← coe_to_submodule_eq_iff]
   exact (N : Submodule R M).map_comap_subtype N'
 #align lie_submodule.map_comap_incl LieSubmodule.map_comap_incl
+-/
 
 end LieIdealOperations
 
@@ -287,6 +333,7 @@ variable [CommRing R] [LieRing L] [LieAlgebra R L] [LieRing L'] [LieAlgebra R L'
 
 variable (f : L →ₗ⁅R⁆ L') (I : LieIdeal R L) (J : LieIdeal R L')
 
+#print LieIdeal.map_bracket_le /-
 /-- Note that the inequality can be strict; e.g., the inclusion of an Abelian subalgebra of a
 simple algebra. -/
 theorem map_bracket_le {I₁ I₂ : LieIdeal R L} : map f ⁅I₁, I₂⁆ ≤ ⁅map f I₁, map f I₂⁆ :=
@@ -299,7 +346,9 @@ theorem map_bracket_le {I₁ I₂ : LieIdeal R L} : map f ⁅I₁, I₂⁆ ≤ 
   simp only [Submodule.coe_mk, mem_comap, LieHom.map_lie]
   exact LieSubmodule.lie_coe_mem_lie _ _ fy₁ fy₂
 #align lie_ideal.map_bracket_le LieIdeal.map_bracket_le
+-/
 
+#print LieIdeal.map_bracket_eq /-
 theorem map_bracket_eq {I₁ I₂ : LieIdeal R L} (h : Function.Surjective f) :
     map f ⁅I₁, I₂⁆ = ⁅map f I₁, map f I₂⁆ :=
   by
@@ -314,12 +363,15 @@ theorem map_bracket_eq {I₁ I₂ : LieIdeal R L} (h : Function.Surjective f) :
   use ⁅(y₁ : L), (y₂ : L)⁆, y₁, y₂
   apply f.map_lie
 #align lie_ideal.map_bracket_eq LieIdeal.map_bracket_eq
+-/
 
+#print LieIdeal.comap_bracket_le /-
 theorem comap_bracket_le {J₁ J₂ : LieIdeal R L'} : ⁅comap f J₁, comap f J₂⁆ ≤ comap f ⁅J₁, J₂⁆ :=
   by
   rw [← map_le_iff_le_comap]
   exact le_trans (map_bracket_le f) (LieSubmodule.mono_lie _ _ _ _ map_comap_le map_comap_le)
 #align lie_ideal.comap_bracket_le LieIdeal.comap_bracket_le
+-/
 
 variable {f}
 
@@ -375,12 +427,14 @@ theorem comap_bracket_incl {I₁ I₂ : LieIdeal R L} :
 #align lie_ideal.comap_bracket_incl LieIdeal.comap_bracket_incl
 -/
 
+#print LieIdeal.comap_bracket_incl_of_le /-
 /-- This is a very useful result; it allows us to use the fact that inclusion distributes over the
 Lie bracket operation on ideals, subject to the conditions shown. -/
 theorem comap_bracket_incl_of_le {I₁ I₂ : LieIdeal R L} (h₁ : I₁ ≤ I) (h₂ : I₂ ≤ I) :
     ⁅comap I.incl I₁, comap I.incl I₂⁆ = comap I.incl ⁅I₁, I₂⁆ := by rw [comap_bracket_incl];
   rw [← inf_eq_right] at h₁ h₂ ; rw [h₁, h₂]
 #align lie_ideal.comap_bracket_incl_of_le LieIdeal.comap_bracket_incl_of_le
+-/
 
 end LieIdeal

5c1efce1

bump to nightly-2023-06-04-18

mathlib commit https://github.com/leanprover-community/mathlib/commit/5f25c089cb34db4db112556f23c50d12da81b297

3fb4268b

Diff

@@ -4,7 +4,7 @@ Released under Apache 2.0 license as described in the file LICENSE.
 Authors: Oliver Nash
 
 ! This file was ported from Lean 3 source module algebra.lie.ideal_operations
-! leanprover-community/mathlib commit 8983bec7cdf6cb2dd1f21315c8a34ab00d7b2f6d
+! leanprover-community/mathlib commit 5c1efce12ba86d4901463f61019832f6a4b1a0d0
 ! Please do not edit these lines, except to modify the commit id
 ! if you have ported upstream changes.
 -/
@@ -13,6 +13,9 @@ import Mathbin.Algebra.Lie.Submodule
 /-!
 # Ideal operations for Lie algebras
 
+> THIS FILE IS SYNCHRONIZED WITH MATHLIB4.
+> Any changes to this file require a corresponding PR to mathlib4.
+
 Given a Lie module `M` over a Lie algebra `L`, there is a natural action of the Lie ideals of `L`
 on the Lie submodules of `M`. In the special case that `M = L` with the adjoint action, this
 provides a pairing of Lie ideals which is especially important. For example, it can be used to
@@ -56,22 +59,22 @@ section LieIdealOperations
 /-- Given a Lie module `M` over a Lie algebra `L`, the set of Lie ideals of `L` acts on the set
 of submodules of `M`. -/
 instance hasBracket : Bracket (LieIdeal R L) (LieSubmodule R L M) :=
-  ⟨fun I N => lieSpan R L { m | ∃ (x : I) (n : N), ⁅(x : L), (n : M)⁆ = m }⟩
+  ⟨fun I N => lieSpan R L {m | ∃ (x : I) (n : N), ⁅(x : L), (n : M)⁆ = m}⟩
 #align lie_submodule.has_bracket LieSubmodule.hasBracket
 
 theorem lieIdeal_oper_eq_span :
-    ⁅I, N⁆ = lieSpan R L { m | ∃ (x : I) (n : N), ⁅(x : L), (n : M)⁆ = m } :=
+    ⁅I, N⁆ = lieSpan R L {m | ∃ (x : I) (n : N), ⁅(x : L), (n : M)⁆ = m} :=
   rfl
 #align lie_submodule.lie_ideal_oper_eq_span LieSubmodule.lieIdeal_oper_eq_span
 
+#print LieSubmodule.lieIdeal_oper_eq_linear_span /-
 /-- See also `lie_submodule.lie_ideal_oper_eq_linear_span'` and
 `lie_submodule.lie_ideal_oper_eq_tensor_map_range`. -/
 theorem lieIdeal_oper_eq_linear_span :
-    (↑⁅I, N⁆ : Submodule R M) =
-      Submodule.span R { m | ∃ (x : I) (n : N), ⁅(x : L), (n : M)⁆ = m } :=
+    (↑⁅I, N⁆ : Submodule R M) = Submodule.span R {m | ∃ (x : I) (n : N), ⁅(x : L), (n : M)⁆ = m} :=
   by
   apply le_antisymm
-  · let s := { m : M | ∃ (x : ↥I) (n : ↥N), ⁅(x : L), (n : M)⁆ = m }
+  · let s := {m : M | ∃ (x : ↥I) (n : ↥N), ⁅(x : L), (n : M)⁆ = m}
     have aux : ∀ (y : L), ∀ m' ∈ Submodule.span R s, ⁅y, m'⁆ ∈ Submodule.span R s :=
       by
       intro y m' hm'; apply Submodule.span_induction hm'
@@ -87,9 +90,11 @@ theorem lieIdeal_oper_eq_linear_span :
     exact Submodule.subset_span
   · rw [lie_ideal_oper_eq_span]; apply submodule_span_le_lie_span
 #align lie_submodule.lie_ideal_oper_eq_linear_span LieSubmodule.lieIdeal_oper_eq_linear_span
+-/
 
+#print LieSubmodule.lieIdeal_oper_eq_linear_span' /-
 theorem lieIdeal_oper_eq_linear_span' :
-    (↑⁅I, N⁆ : Submodule R M) = Submodule.span R { m | ∃ x ∈ I, ∃ n ∈ N, ⁅x, n⁆ = m } :=
+    (↑⁅I, N⁆ : Submodule R M) = Submodule.span R {m | ∃ x ∈ I, ∃ n ∈ N, ⁅x, n⁆ = m} :=
   by
   rw [lie_ideal_oper_eq_linear_span]
   congr
@@ -100,6 +105,7 @@ theorem lieIdeal_oper_eq_linear_span' :
   · rintro ⟨x, hx, n, hn, rfl⟩
     exact ⟨⟨x, hx⟩, ⟨n, hn⟩, rfl⟩
 #align lie_submodule.lie_ideal_oper_eq_linear_span' LieSubmodule.lieIdeal_oper_eq_linear_span'
+-/
 
 theorem lie_le_iff : ⁅I, N⁆ ≤ N' ↔ ∀ x ∈ I, ∀ m ∈ N, ⁅x, m⁆ ∈ N' :=
   by
@@ -117,6 +123,7 @@ theorem lie_mem_lie {x : L} {m : M} (hx : x ∈ I) (hm : m ∈ N) : ⁅x, m⁆ 
   N.lie_coe_mem_lie I ⟨x, hx⟩ ⟨m, hm⟩
 #align lie_submodule.lie_mem_lie LieSubmodule.lie_mem_lie
 
+#print LieSubmodule.lie_comm /-
 theorem lie_comm : ⁅I, J⁆ = ⁅J, I⁆ :=
   by
   suffices ∀ I J : LieIdeal R L, ⁅I, J⁆ ≤ ⁅J, I⁆ by exact le_antisymm (this I J) (this J I)
@@ -125,6 +132,7 @@ theorem lie_comm : ⁅I, J⁆ = ⁅J, I⁆ :=
   rw [← lie_skew, ← lie_neg, ← LieSubmodule.coe_neg]
   apply lie_coe_mem_lie
 #align lie_submodule.lie_comm LieSubmodule.lie_comm
+-/
 
 theorem lie_le_right : ⁅I, N⁆ ≤ N :=
   by
@@ -212,6 +220,7 @@ theorem inf_lie : ⁅I ⊓ J, N⁆ ≤ ⁅I, N⁆ ⊓ ⁅J, N⁆ := by rw [le_in
 
 variable (f : M →ₗ⁅R,L⁆ M₂)
 
+#print LieSubmodule.map_bracket_eq /-
 theorem map_bracket_eq : map f ⁅I, N⁆ = ⁅I, map f N⁆ :=
   by
   rw [← coe_to_submodule_eq_iff, coe_submodule_map, lie_ideal_oper_eq_linear_span,
@@ -220,12 +229,13 @@ theorem map_bracket_eq : map f ⁅I, N⁆ = ⁅I, map f N⁆ :=
   ext m
   constructor
   · rintro ⟨-, ⟨⟨x, ⟨n, hn⟩, rfl⟩, hm⟩⟩
-    simp only [LieModuleHom.coe_to_linearMap, LieModuleHom.map_lie] at hm 
+    simp only [LieModuleHom.coe_toLinearMap, LieModuleHom.map_lie] at hm 
     exact ⟨x, ⟨f n, (mem_map (f n)).mpr ⟨n, hn, rfl⟩⟩, hm⟩
   · rintro ⟨x, ⟨m₂, hm₂ : m₂ ∈ map f N⟩, rfl⟩
     obtain ⟨n, hn, rfl⟩ := (mem_map m₂).mp hm₂
     exact ⟨⁅x, n⁆, ⟨x, ⟨n, hn⟩, rfl⟩, by simp⟩
 #align lie_submodule.map_bracket_eq LieSubmodule.map_bracket_eq
+-/
 
 theorem map_comap_le : map f (comap f N₂) ≤ N₂ :=
   (N₂ : Set M₂).image_preimage_subset f
@@ -247,12 +257,14 @@ theorem comap_map_eq (hf : f.ker = ⊥) : comap f (map f N) = N :=
   exact (N : Set M).preimage_image_eq (f.ker_eq_bot.mp hf)
 #align lie_submodule.comap_map_eq LieSubmodule.comap_map_eq
 
+#print LieSubmodule.comap_bracket_eq /-
 theorem comap_bracket_eq (hf₁ : f.ker = ⊥) (hf₂ : N₂ ≤ f.range) :
     comap f ⁅I, N₂⁆ = ⁅I, comap f N₂⁆ :=
   by
   conv_lhs => rw [← map_comap_eq N₂ f hf₂]
   rw [← map_bracket_eq, comap_map_eq _ f hf₁]
 #align lie_submodule.comap_bracket_eq LieSubmodule.comap_bracket_eq
+-/
 
 @[simp]
 theorem map_comap_incl : map N.incl (comap N.incl N') = N ⊓ N' :=
@@ -311,17 +323,19 @@ theorem comap_bracket_le {J₁ J₂ : LieIdeal R L'} : ⁅comap f J₁, comap f
 
 variable {f}
 
+#print LieIdeal.map_comap_incl /-
 theorem map_comap_incl {I₁ I₂ : LieIdeal R L} : map I₁.incl (comap I₁.incl I₂) = I₁ ⊓ I₂ := by
   conv_rhs => rw [← I₁.incl_ideal_range]; rw [← map_comap_eq]; exact I₁.incl_is_ideal_morphism
 #align lie_ideal.map_comap_incl LieIdeal.map_comap_incl
+-/
 
+#print LieIdeal.comap_bracket_eq /-
 theorem comap_bracket_eq {J₁ J₂ : LieIdeal R L'} (h : f.IsIdealMorphism) :
     comap f ⁅f.idealRange ⊓ J₁, f.idealRange ⊓ J₂⁆ = ⁅comap f J₁, comap f J₂⁆ ⊔ f.ker :=
   by
-  rw [← LieSubmodule.coe_to_submodule_eq_iff, comap_coe_submodule,
-    LieSubmodule.sup_coe_to_submodule, f.ker_coe_submodule, ← Submodule.comap_map_eq,
-    LieSubmodule.lieIdeal_oper_eq_linear_span, LieSubmodule.lieIdeal_oper_eq_linear_span,
-    LinearMap.map_span]
+  rw [← LieSubmodule.coe_toSubmodule_eq_iff, comap_coe_submodule, LieSubmodule.sup_coe_toSubmodule,
+    f.ker_coe_submodule, ← Submodule.comap_map_eq, LieSubmodule.lieIdeal_oper_eq_linear_span,
+    LieSubmodule.lieIdeal_oper_eq_linear_span, LinearMap.map_span]
   congr; simp only [LieHom.coe_toLinearMap, Set.mem_setOf_eq]; ext y
   constructor
   · rintro ⟨⟨x₁, hx₁⟩, ⟨x₂, hx₂⟩, hy⟩; rw [← hy]
@@ -337,14 +351,18 @@ theorem comap_bracket_eq {J₁ J₂ : LieIdeal R L'} (h : f.IsIdealMorphism) :
       exact ⟨f.mem_ideal_range, hz₂⟩
     use ⟨f z₁, hz₁'⟩, ⟨f z₂, hz₂'⟩; simp only [Submodule.coe_mk, LieHom.map_lie]
 #align lie_ideal.comap_bracket_eq LieIdeal.comap_bracket_eq
+-/
 
+#print LieIdeal.map_comap_bracket_eq /-
 theorem map_comap_bracket_eq {J₁ J₂ : LieIdeal R L'} (h : f.IsIdealMorphism) :
     map f ⁅comap f J₁, comap f J₂⁆ = ⁅f.idealRange ⊓ J₁, f.idealRange ⊓ J₂⁆ :=
   by
   rw [← map_sup_ker_eq_map, ← comap_bracket_eq h, map_comap_eq h, inf_eq_right]
   exact le_trans (LieSubmodule.lie_le_left _ _) inf_le_left
 #align lie_ideal.map_comap_bracket_eq LieIdeal.map_comap_bracket_eq
+-/
 
+#print LieIdeal.comap_bracket_incl /-
 theorem comap_bracket_incl {I₁ I₂ : LieIdeal R L} :
     ⁅comap I.incl I₁, comap I.incl I₂⁆ = comap I.incl ⁅I ⊓ I₁, I ⊓ I₂⁆ :=
   by
@@ -355,6 +373,7 @@ theorem comap_bracket_incl {I₁ I₂ : LieIdeal R L} :
   rw [comap_bracket_eq]
   simp only [ker_incl, sup_bot_eq]; exact I.incl_is_ideal_morphism
 #align lie_ideal.comap_bracket_incl LieIdeal.comap_bracket_incl
+-/
 
 /-- This is a very useful result; it allows us to use the fact that inclusion distributes over the
 Lie bracket operation on ideals, subject to the conditions shown. -/

8983bec7

bump to nightly-2023-06-01-16

mathlib commit https://github.com/leanprover-community/mathlib/commit/cca40788df1b8755d5baf17ab2f27dacc2e17acb

b9c87c70

Diff

@@ -56,21 +56,22 @@ section LieIdealOperations
 /-- Given a Lie module `M` over a Lie algebra `L`, the set of Lie ideals of `L` acts on the set
 of submodules of `M`. -/
 instance hasBracket : Bracket (LieIdeal R L) (LieSubmodule R L M) :=
-  ⟨fun I N => lieSpan R L { m | ∃ (x : I)(n : N), ⁅(x : L), (n : M)⁆ = m }⟩
+  ⟨fun I N => lieSpan R L { m | ∃ (x : I) (n : N), ⁅(x : L), (n : M)⁆ = m }⟩
 #align lie_submodule.has_bracket LieSubmodule.hasBracket
 
 theorem lieIdeal_oper_eq_span :
-    ⁅I, N⁆ = lieSpan R L { m | ∃ (x : I)(n : N), ⁅(x : L), (n : M)⁆ = m } :=
+    ⁅I, N⁆ = lieSpan R L { m | ∃ (x : I) (n : N), ⁅(x : L), (n : M)⁆ = m } :=
   rfl
 #align lie_submodule.lie_ideal_oper_eq_span LieSubmodule.lieIdeal_oper_eq_span
 
 /-- See also `lie_submodule.lie_ideal_oper_eq_linear_span'` and
 `lie_submodule.lie_ideal_oper_eq_tensor_map_range`. -/
 theorem lieIdeal_oper_eq_linear_span :
-    (↑⁅I, N⁆ : Submodule R M) = Submodule.span R { m | ∃ (x : I)(n : N), ⁅(x : L), (n : M)⁆ = m } :=
+    (↑⁅I, N⁆ : Submodule R M) =
+      Submodule.span R { m | ∃ (x : I) (n : N), ⁅(x : L), (n : M)⁆ = m } :=
   by
   apply le_antisymm
-  · let s := { m : M | ∃ (x : ↥I)(n : ↥N), ⁅(x : L), (n : M)⁆ = m }
+  · let s := { m : M | ∃ (x : ↥I) (n : ↥N), ⁅(x : L), (n : M)⁆ = m }
     have aux : ∀ (y : L), ∀ m' ∈ Submodule.span R s, ⁅y, m'⁆ ∈ Submodule.span R s :=
       by
       intro y m' hm'; apply Submodule.span_induction hm'
@@ -146,7 +147,7 @@ theorem bot_lie : ⁅(⊥ : LieIdeal R L), N⁆ = ⊥ :=
   by
   suffices ⁅(⊥ : LieIdeal R L), N⁆ ≤ ⊥ by exact le_bot_iff.mp this
   rw [lie_ideal_oper_eq_span, lie_span_le]; rintro m ⟨⟨x, hx⟩, n, hn⟩; rw [← hn]
-  change x ∈ (⊥ : LieIdeal R L) at hx; rw [mem_bot] at hx; simp [hx]
+  change x ∈ (⊥ : LieIdeal R L) at hx ; rw [mem_bot] at hx ; simp [hx]
 #align lie_submodule.bot_lie LieSubmodule.bot_lie
 
 theorem lie_eq_bot_iff : ⁅I, N⁆ = ⊥ ↔ ∀ x ∈ I, ∀ m ∈ N, ⁅(x : L), m⁆ = 0 :=
@@ -160,7 +161,7 @@ theorem lie_eq_bot_iff : ⁅I, N⁆ = ⊥ ↔ ∀ x ∈ I, ∀ m ∈ N, ⁅(x :
 theorem mono_lie (h₁ : I ≤ J) (h₂ : N ≤ N') : ⁅I, N⁆ ≤ ⁅J, N'⁆ :=
   by
   intro m h
-  rw [lie_ideal_oper_eq_span, mem_lie_span] at h; rw [lie_ideal_oper_eq_span, mem_lie_span]
+  rw [lie_ideal_oper_eq_span, mem_lie_span] at h ; rw [lie_ideal_oper_eq_span, mem_lie_span]
   intro N hN; apply h; rintro m' ⟨⟨x, hx⟩, ⟨n, hn⟩, hm⟩; rw [← hm]; apply hN
   use ⟨x, h₁ hx⟩, ⟨n, h₂ hn⟩; rfl
 #align lie_submodule.mono_lie LieSubmodule.mono_lie
@@ -177,10 +178,10 @@ theorem mono_lie_right (h : N ≤ N') : ⁅I, N⁆ ≤ ⁅I, N'⁆ :=
 theorem lie_sup : ⁅I, N ⊔ N'⁆ = ⁅I, N⁆ ⊔ ⁅I, N'⁆ :=
   by
   have h : ⁅I, N⁆ ⊔ ⁅I, N'⁆ ≤ ⁅I, N ⊔ N'⁆ := by rw [sup_le_iff];
-    constructor <;> apply mono_lie_right <;> [exact le_sup_left;exact le_sup_right]
+    constructor <;> apply mono_lie_right <;> [exact le_sup_left; exact le_sup_right]
   suffices ⁅I, N ⊔ N'⁆ ≤ ⁅I, N⁆ ⊔ ⁅I, N'⁆ by exact le_antisymm this h; clear h
   rw [lie_ideal_oper_eq_span, lie_span_le]; rintro m ⟨x, ⟨n, hn⟩, h⟩; erw [LieSubmodule.mem_sup]
-  erw [LieSubmodule.mem_sup] at hn; rcases hn with ⟨n₁, hn₁, n₂, hn₂, hn'⟩
+  erw [LieSubmodule.mem_sup] at hn ; rcases hn with ⟨n₁, hn₁, n₂, hn₂, hn'⟩
   use ⁅(x : L), (⟨n₁, hn₁⟩ : N)⁆; constructor; · apply lie_coe_mem_lie
   use ⁅(x : L), (⟨n₂, hn₂⟩ : N')⁆; constructor; · apply lie_coe_mem_lie
   simp [← h, ← hn']
@@ -190,10 +191,10 @@ theorem lie_sup : ⁅I, N ⊔ N'⁆ = ⁅I, N⁆ ⊔ ⁅I, N'⁆ :=
 theorem sup_lie : ⁅I ⊔ J, N⁆ = ⁅I, N⁆ ⊔ ⁅J, N⁆ :=
   by
   have h : ⁅I, N⁆ ⊔ ⁅J, N⁆ ≤ ⁅I ⊔ J, N⁆ := by rw [sup_le_iff];
-    constructor <;> apply mono_lie_left <;> [exact le_sup_left;exact le_sup_right]
+    constructor <;> apply mono_lie_left <;> [exact le_sup_left; exact le_sup_right]
   suffices ⁅I ⊔ J, N⁆ ≤ ⁅I, N⁆ ⊔ ⁅J, N⁆ by exact le_antisymm this h; clear h
   rw [lie_ideal_oper_eq_span, lie_span_le]; rintro m ⟨⟨x, hx⟩, n, h⟩; erw [LieSubmodule.mem_sup]
-  erw [LieSubmodule.mem_sup] at hx; rcases hx with ⟨x₁, hx₁, x₂, hx₂, hx'⟩
+  erw [LieSubmodule.mem_sup] at hx ; rcases hx with ⟨x₁, hx₁, x₂, hx₂, hx'⟩
   use ⁅((⟨x₁, hx₁⟩ : I) : L), (n : N)⁆; constructor; · apply lie_coe_mem_lie
   use ⁅((⟨x₂, hx₂⟩ : J) : L), (n : N)⁆; constructor; · apply lie_coe_mem_lie
   simp [← h, ← hx']
@@ -201,12 +202,12 @@ theorem sup_lie : ⁅I ⊔ J, N⁆ = ⁅I, N⁆ ⊔ ⁅J, N⁆ :=
 
 @[simp]
 theorem lie_inf : ⁅I, N ⊓ N'⁆ ≤ ⁅I, N⁆ ⊓ ⁅I, N'⁆ := by rw [le_inf_iff];
-  constructor <;> apply mono_lie_right <;> [exact inf_le_left;exact inf_le_right]
+  constructor <;> apply mono_lie_right <;> [exact inf_le_left; exact inf_le_right]
 #align lie_submodule.lie_inf LieSubmodule.lie_inf
 
 @[simp]
 theorem inf_lie : ⁅I ⊓ J, N⁆ ≤ ⁅I, N⁆ ⊓ ⁅J, N⁆ := by rw [le_inf_iff];
-  constructor <;> apply mono_lie_left <;> [exact inf_le_left;exact inf_le_right]
+  constructor <;> apply mono_lie_left <;> [exact inf_le_left; exact inf_le_right]
 #align lie_submodule.inf_lie LieSubmodule.inf_lie
 
 variable (f : M →ₗ⁅R,L⁆ M₂)
@@ -219,7 +220,7 @@ theorem map_bracket_eq : map f ⁅I, N⁆ = ⁅I, map f N⁆ :=
   ext m
   constructor
   · rintro ⟨-, ⟨⟨x, ⟨n, hn⟩, rfl⟩, hm⟩⟩
-    simp only [LieModuleHom.coe_to_linearMap, LieModuleHom.map_lie] at hm
+    simp only [LieModuleHom.coe_to_linearMap, LieModuleHom.map_lie] at hm 
     exact ⟨x, ⟨f n, (mem_map (f n)).mpr ⟨n, hn, rfl⟩⟩, hm⟩
   · rintro ⟨x, ⟨m₂, hm₂ : m₂ ∈ map f N⟩, rfl⟩
     obtain ⟨n, hn, rfl⟩ := (mem_map m₂).mp hm₂
@@ -321,12 +322,12 @@ theorem comap_bracket_eq {J₁ J₂ : LieIdeal R L'} (h : f.IsIdealMorphism) :
     LieSubmodule.sup_coe_to_submodule, f.ker_coe_submodule, ← Submodule.comap_map_eq,
     LieSubmodule.lieIdeal_oper_eq_linear_span, LieSubmodule.lieIdeal_oper_eq_linear_span,
     LinearMap.map_span]
-  congr ; simp only [LieHom.coe_toLinearMap, Set.mem_setOf_eq]; ext y
+  congr; simp only [LieHom.coe_toLinearMap, Set.mem_setOf_eq]; ext y
   constructor
   · rintro ⟨⟨x₁, hx₁⟩, ⟨x₂, hx₂⟩, hy⟩; rw [← hy]
-    erw [LieSubmodule.mem_inf, f.mem_ideal_range_iff h] at hx₁ hx₂
-    obtain ⟨⟨z₁, hz₁⟩, hz₁'⟩ := hx₁; rw [← hz₁] at hz₁'
-    obtain ⟨⟨z₂, hz₂⟩, hz₂'⟩ := hx₂; rw [← hz₂] at hz₂'
+    erw [LieSubmodule.mem_inf, f.mem_ideal_range_iff h] at hx₁ hx₂ 
+    obtain ⟨⟨z₁, hz₁⟩, hz₁'⟩ := hx₁; rw [← hz₁] at hz₁' 
+    obtain ⟨⟨z₂, hz₂⟩, hz₂'⟩ := hx₂; rw [← hz₂] at hz₂' 
     use ⁅z₁, z₂⁆, ⟨z₁, hz₁'⟩, ⟨z₂, hz₂'⟩, rfl
     simp only [hz₁, hz₂, Submodule.coe_mk, LieHom.map_lie]
   · rintro ⟨x, ⟨⟨z₁, hz₁⟩, ⟨z₂, hz₂⟩, hx⟩, hy⟩; rw [← hy, ← hx]
@@ -359,7 +360,7 @@ theorem comap_bracket_incl {I₁ I₂ : LieIdeal R L} :
 Lie bracket operation on ideals, subject to the conditions shown. -/
 theorem comap_bracket_incl_of_le {I₁ I₂ : LieIdeal R L} (h₁ : I₁ ≤ I) (h₂ : I₂ ≤ I) :
     ⁅comap I.incl I₁, comap I.incl I₂⁆ = comap I.incl ⁅I₁, I₂⁆ := by rw [comap_bracket_incl];
-  rw [← inf_eq_right] at h₁ h₂; rw [h₁, h₂]
+  rw [← inf_eq_right] at h₁ h₂ ; rw [h₁, h₂]
 #align lie_ideal.comap_bracket_incl_of_le LieIdeal.comap_bracket_incl_of_le
 
 end LieIdeal

8983bec7

bump to nightly-2023-05-28-04

mathlib commit https://github.com/leanprover-community/mathlib/commit/917c3c072e487b3cccdbfeff17e75b40e45f66cb

6797a637

Diff

@@ -73,27 +73,18 @@ theorem lieIdeal_oper_eq_linear_span :
   · let s := { m : M | ∃ (x : ↥I)(n : ↥N), ⁅(x : L), (n : M)⁆ = m }
     have aux : ∀ (y : L), ∀ m' ∈ Submodule.span R s, ⁅y, m'⁆ ∈ Submodule.span R s :=
       by
-      intro y m' hm'
-      apply Submodule.span_induction hm'
-      · rintro m'' ⟨x, n, hm''⟩
-        rw [← hm'', leibniz_lie]
+      intro y m' hm'; apply Submodule.span_induction hm'
+      · rintro m'' ⟨x, n, hm''⟩; rw [← hm'', leibniz_lie]
         refine' Submodule.add_mem _ _ _ <;> apply Submodule.subset_span
-        · use ⟨⁅y, ↑x⁆, I.lie_mem x.property⟩, n
-          rfl
-        · use x, ⟨⁅y, ↑n⁆, N.lie_mem n.property⟩
-          rfl
+        · use ⟨⁅y, ↑x⁆, I.lie_mem x.property⟩, n; rfl
+        · use x, ⟨⁅y, ↑n⁆, N.lie_mem n.property⟩; rfl
       · simp only [lie_zero, Submodule.zero_mem]
-      · intro m₁ m₂ hm₁ hm₂
-        rw [lie_add]
-        exact Submodule.add_mem _ hm₁ hm₂
-      · intro t m'' hm''
-        rw [lie_smul]
-        exact Submodule.smul_mem _ t hm''
+      · intro m₁ m₂ hm₁ hm₂; rw [lie_add]; exact Submodule.add_mem _ hm₁ hm₂
+      · intro t m'' hm''; rw [lie_smul]; exact Submodule.smul_mem _ t hm''
     change _ ≤ ↑({ Submodule.span R s with lie_mem := aux } : LieSubmodule R L M)
     rw [coe_submodule_le_coe_submodule, lie_ideal_oper_eq_span, lie_span_le]
     exact Submodule.subset_span
-  · rw [lie_ideal_oper_eq_span]
-    apply submodule_span_le_lie_span
+  · rw [lie_ideal_oper_eq_span]; apply submodule_span_le_lie_span
 #align lie_submodule.lie_ideal_oper_eq_linear_span LieSubmodule.lieIdeal_oper_eq_linear_span
 
 theorem lieIdeal_oper_eq_linear_span' :
@@ -117,11 +108,8 @@ theorem lie_le_iff : ⁅I, N⁆ ≤ N' ↔ ∀ x ∈ I, ∀ m ∈ N, ⁅x, m⁆
   exact h x hx m hm
 #align lie_submodule.lie_le_iff LieSubmodule.lie_le_iff
 
-theorem lie_coe_mem_lie (x : I) (m : N) : ⁅(x : L), (m : M)⁆ ∈ ⁅I, N⁆ :=
-  by
-  rw [lie_ideal_oper_eq_span]
-  apply subset_lie_span
-  use x, m
+theorem lie_coe_mem_lie (x : I) (m : N) : ⁅(x : L), (m : M)⁆ ∈ ⁅I, N⁆ := by
+  rw [lie_ideal_oper_eq_span]; apply subset_lie_span; use x, m
 #align lie_submodule.lie_coe_mem_lie LieSubmodule.lie_coe_mem_lie
 
 theorem lie_mem_lie {x : L} {m : M} (hx : x ∈ I) (hm : m ∈ N) : ⁅x, m⁆ ∈ ⁅I, N⁆ :=
@@ -131,11 +119,8 @@ theorem lie_mem_lie {x : L} {m : M} (hx : x ∈ I) (hm : m ∈ N) : ⁅x, m⁆ 
 theorem lie_comm : ⁅I, J⁆ = ⁅J, I⁆ :=
   by
   suffices ∀ I J : LieIdeal R L, ⁅I, J⁆ ≤ ⁅J, I⁆ by exact le_antisymm (this I J) (this J I)
-  clear I J
-  intro I J
-  rw [lie_ideal_oper_eq_span, lie_span_le]
-  rintro x ⟨y, z, h⟩
-  rw [← h]
+  clear I J; intro I J
+  rw [lie_ideal_oper_eq_span, lie_span_le]; rintro x ⟨y, z, h⟩; rw [← h]
   rw [← lie_skew, ← lie_neg, ← LieSubmodule.coe_neg]
   apply lie_coe_mem_lie
 #align lie_submodule.lie_comm LieSubmodule.lie_comm
@@ -146,33 +131,22 @@ theorem lie_le_right : ⁅I, N⁆ ≤ N :=
   exact N.lie_mem n.property
 #align lie_submodule.lie_le_right LieSubmodule.lie_le_right
 
-theorem lie_le_left : ⁅I, J⁆ ≤ I := by
-  rw [lie_comm]
-  exact lie_le_right I J
+theorem lie_le_left : ⁅I, J⁆ ≤ I := by rw [lie_comm]; exact lie_le_right I J
 #align lie_submodule.lie_le_left LieSubmodule.lie_le_left
 
-theorem lie_le_inf : ⁅I, J⁆ ≤ I ⊓ J := by
-  rw [le_inf_iff]
-  exact ⟨lie_le_left I J, lie_le_right J I⟩
+theorem lie_le_inf : ⁅I, J⁆ ≤ I ⊓ J := by rw [le_inf_iff]; exact ⟨lie_le_left I J, lie_le_right J I⟩
 #align lie_submodule.lie_le_inf LieSubmodule.lie_le_inf
 
 @[simp]
-theorem lie_bot : ⁅I, (⊥ : LieSubmodule R L M)⁆ = ⊥ :=
-  by
-  rw [eq_bot_iff]
-  apply lie_le_right
+theorem lie_bot : ⁅I, (⊥ : LieSubmodule R L M)⁆ = ⊥ := by rw [eq_bot_iff]; apply lie_le_right
 #align lie_submodule.lie_bot LieSubmodule.lie_bot
 
 @[simp]
 theorem bot_lie : ⁅(⊥ : LieIdeal R L), N⁆ = ⊥ :=
   by
   suffices ⁅(⊥ : LieIdeal R L), N⁆ ≤ ⊥ by exact le_bot_iff.mp this
-  rw [lie_ideal_oper_eq_span, lie_span_le]
-  rintro m ⟨⟨x, hx⟩, n, hn⟩
-  rw [← hn]
-  change x ∈ (⊥ : LieIdeal R L) at hx
-  rw [mem_bot] at hx
-  simp [hx]
+  rw [lie_ideal_oper_eq_span, lie_span_le]; rintro m ⟨⟨x, hx⟩, n, hn⟩; rw [← hn]
+  change x ∈ (⊥ : LieIdeal R L) at hx; rw [mem_bot] at hx; simp [hx]
 #align lie_submodule.bot_lie LieSubmodule.bot_lie
 
 theorem lie_eq_bot_iff : ⁅I, N⁆ = ⊥ ↔ ∀ x ∈ I, ∀ m ∈ N, ⁅(x : L), m⁆ = 0 :=
@@ -202,59 +176,36 @@ theorem mono_lie_right (h : N ≤ N') : ⁅I, N⁆ ≤ ⁅I, N'⁆ :=
 @[simp]
 theorem lie_sup : ⁅I, N ⊔ N'⁆ = ⁅I, N⁆ ⊔ ⁅I, N'⁆ :=
   by
-  have h : ⁅I, N⁆ ⊔ ⁅I, N'⁆ ≤ ⁅I, N ⊔ N'⁆ :=
-    by
-    rw [sup_le_iff]
+  have h : ⁅I, N⁆ ⊔ ⁅I, N'⁆ ≤ ⁅I, N ⊔ N'⁆ := by rw [sup_le_iff];
     constructor <;> apply mono_lie_right <;> [exact le_sup_left;exact le_sup_right]
-  suffices ⁅I, N ⊔ N'⁆ ≤ ⁅I, N⁆ ⊔ ⁅I, N'⁆ by exact le_antisymm this h
-  clear h
-  rw [lie_ideal_oper_eq_span, lie_span_le]
-  rintro m ⟨x, ⟨n, hn⟩, h⟩
-  erw [LieSubmodule.mem_sup]
-  erw [LieSubmodule.mem_sup] at hn
-  rcases hn with ⟨n₁, hn₁, n₂, hn₂, hn'⟩
-  use ⁅(x : L), (⟨n₁, hn₁⟩ : N)⁆
-  constructor
-  · apply lie_coe_mem_lie
-  use ⁅(x : L), (⟨n₂, hn₂⟩ : N')⁆
-  constructor
-  · apply lie_coe_mem_lie
+  suffices ⁅I, N ⊔ N'⁆ ≤ ⁅I, N⁆ ⊔ ⁅I, N'⁆ by exact le_antisymm this h; clear h
+  rw [lie_ideal_oper_eq_span, lie_span_le]; rintro m ⟨x, ⟨n, hn⟩, h⟩; erw [LieSubmodule.mem_sup]
+  erw [LieSubmodule.mem_sup] at hn; rcases hn with ⟨n₁, hn₁, n₂, hn₂, hn'⟩
+  use ⁅(x : L), (⟨n₁, hn₁⟩ : N)⁆; constructor; · apply lie_coe_mem_lie
+  use ⁅(x : L), (⟨n₂, hn₂⟩ : N')⁆; constructor; · apply lie_coe_mem_lie
   simp [← h, ← hn']
 #align lie_submodule.lie_sup LieSubmodule.lie_sup
 
 @[simp]
 theorem sup_lie : ⁅I ⊔ J, N⁆ = ⁅I, N⁆ ⊔ ⁅J, N⁆ :=
   by
-  have h : ⁅I, N⁆ ⊔ ⁅J, N⁆ ≤ ⁅I ⊔ J, N⁆ := by
-    rw [sup_le_iff]
+  have h : ⁅I, N⁆ ⊔ ⁅J, N⁆ ≤ ⁅I ⊔ J, N⁆ := by rw [sup_le_iff];
     constructor <;> apply mono_lie_left <;> [exact le_sup_left;exact le_sup_right]
-  suffices ⁅I ⊔ J, N⁆ ≤ ⁅I, N⁆ ⊔ ⁅J, N⁆ by exact le_antisymm this h
-  clear h
-  rw [lie_ideal_oper_eq_span, lie_span_le]
-  rintro m ⟨⟨x, hx⟩, n, h⟩
-  erw [LieSubmodule.mem_sup]
-  erw [LieSubmodule.mem_sup] at hx
-  rcases hx with ⟨x₁, hx₁, x₂, hx₂, hx'⟩
-  use ⁅((⟨x₁, hx₁⟩ : I) : L), (n : N)⁆
-  constructor
-  · apply lie_coe_mem_lie
-  use ⁅((⟨x₂, hx₂⟩ : J) : L), (n : N)⁆
-  constructor
-  · apply lie_coe_mem_lie
+  suffices ⁅I ⊔ J, N⁆ ≤ ⁅I, N⁆ ⊔ ⁅J, N⁆ by exact le_antisymm this h; clear h
+  rw [lie_ideal_oper_eq_span, lie_span_le]; rintro m ⟨⟨x, hx⟩, n, h⟩; erw [LieSubmodule.mem_sup]
+  erw [LieSubmodule.mem_sup] at hx; rcases hx with ⟨x₁, hx₁, x₂, hx₂, hx'⟩
+  use ⁅((⟨x₁, hx₁⟩ : I) : L), (n : N)⁆; constructor; · apply lie_coe_mem_lie
+  use ⁅((⟨x₂, hx₂⟩ : J) : L), (n : N)⁆; constructor; · apply lie_coe_mem_lie
   simp [← h, ← hx']
 #align lie_submodule.sup_lie LieSubmodule.sup_lie
 
 @[simp]
-theorem lie_inf : ⁅I, N ⊓ N'⁆ ≤ ⁅I, N⁆ ⊓ ⁅I, N'⁆ :=
-  by
-  rw [le_inf_iff]
+theorem lie_inf : ⁅I, N ⊓ N'⁆ ≤ ⁅I, N⁆ ⊓ ⁅I, N'⁆ := by rw [le_inf_iff];
   constructor <;> apply mono_lie_right <;> [exact inf_le_left;exact inf_le_right]
 #align lie_submodule.lie_inf LieSubmodule.lie_inf
 
 @[simp]
-theorem inf_lie : ⁅I ⊓ J, N⁆ ≤ ⁅I, N⁆ ⊓ ⁅J, N⁆ :=
-  by
-  rw [le_inf_iff]
+theorem inf_lie : ⁅I ⊓ J, N⁆ ≤ ⁅I, N⁆ ⊓ ⁅J, N⁆ := by rw [le_inf_iff];
   constructor <;> apply mono_lie_left <;> [exact inf_le_left;exact inf_le_right]
 #align lie_submodule.inf_lie LieSubmodule.inf_lie
 
@@ -359,11 +310,8 @@ theorem comap_bracket_le {J₁ J₂ : LieIdeal R L'} : ⁅comap f J₁, comap f
 
 variable {f}
 
-theorem map_comap_incl {I₁ I₂ : LieIdeal R L} : map I₁.incl (comap I₁.incl I₂) = I₁ ⊓ I₂ :=
-  by
-  conv_rhs => rw [← I₁.incl_ideal_range]
-  rw [← map_comap_eq]
-  exact I₁.incl_is_ideal_morphism
+theorem map_comap_incl {I₁ I₂ : LieIdeal R L} : map I₁.incl (comap I₁.incl I₂) = I₁ ⊓ I₂ := by
+  conv_rhs => rw [← I₁.incl_ideal_range]; rw [← map_comap_eq]; exact I₁.incl_is_ideal_morphism
 #align lie_ideal.map_comap_incl LieIdeal.map_comap_incl
 
 theorem comap_bracket_eq {J₁ J₂ : LieIdeal R L'} (h : f.IsIdealMorphism) :
@@ -375,27 +323,18 @@ theorem comap_bracket_eq {J₁ J₂ : LieIdeal R L'} (h : f.IsIdealMorphism) :
     LinearMap.map_span]
   congr ; simp only [LieHom.coe_toLinearMap, Set.mem_setOf_eq]; ext y
   constructor
-  · rintro ⟨⟨x₁, hx₁⟩, ⟨x₂, hx₂⟩, hy⟩
-    rw [← hy]
+  · rintro ⟨⟨x₁, hx₁⟩, ⟨x₂, hx₂⟩, hy⟩; rw [← hy]
     erw [LieSubmodule.mem_inf, f.mem_ideal_range_iff h] at hx₁ hx₂
-    obtain ⟨⟨z₁, hz₁⟩, hz₁'⟩ := hx₁
-    rw [← hz₁] at hz₁'
-    obtain ⟨⟨z₂, hz₂⟩, hz₂'⟩ := hx₂
-    rw [← hz₂] at hz₂'
+    obtain ⟨⟨z₁, hz₁⟩, hz₁'⟩ := hx₁; rw [← hz₁] at hz₁'
+    obtain ⟨⟨z₂, hz₂⟩, hz₂'⟩ := hx₂; rw [← hz₂] at hz₂'
     use ⁅z₁, z₂⁆, ⟨z₁, hz₁'⟩, ⟨z₂, hz₂'⟩, rfl
     simp only [hz₁, hz₂, Submodule.coe_mk, LieHom.map_lie]
-  · rintro ⟨x, ⟨⟨z₁, hz₁⟩, ⟨z₂, hz₂⟩, hx⟩, hy⟩
-    rw [← hy, ← hx]
-    have hz₁' : f z₁ ∈ f.ideal_range ⊓ J₁ :=
-      by
-      rw [LieSubmodule.mem_inf]
+  · rintro ⟨x, ⟨⟨z₁, hz₁⟩, ⟨z₂, hz₂⟩, hx⟩, hy⟩; rw [← hy, ← hx]
+    have hz₁' : f z₁ ∈ f.ideal_range ⊓ J₁ := by rw [LieSubmodule.mem_inf];
       exact ⟨f.mem_ideal_range, hz₁⟩
-    have hz₂' : f z₂ ∈ f.ideal_range ⊓ J₂ :=
-      by
-      rw [LieSubmodule.mem_inf]
+    have hz₂' : f z₂ ∈ f.ideal_range ⊓ J₂ := by rw [LieSubmodule.mem_inf];
       exact ⟨f.mem_ideal_range, hz₂⟩
-    use ⟨f z₁, hz₁'⟩, ⟨f z₂, hz₂'⟩
-    simp only [Submodule.coe_mk, LieHom.map_lie]
+    use ⟨f z₁, hz₁'⟩, ⟨f z₂, hz₂'⟩; simp only [Submodule.coe_mk, LieHom.map_lie]
 #align lie_ideal.comap_bracket_eq LieIdeal.comap_bracket_eq
 
 theorem map_comap_bracket_eq {J₁ J₂ : LieIdeal R L'} (h : f.IsIdealMorphism) :
@@ -419,11 +358,8 @@ theorem comap_bracket_incl {I₁ I₂ : LieIdeal R L} :
 /-- This is a very useful result; it allows us to use the fact that inclusion distributes over the
 Lie bracket operation on ideals, subject to the conditions shown. -/
 theorem comap_bracket_incl_of_le {I₁ I₂ : LieIdeal R L} (h₁ : I₁ ≤ I) (h₂ : I₂ ≤ I) :
-    ⁅comap I.incl I₁, comap I.incl I₂⁆ = comap I.incl ⁅I₁, I₂⁆ :=
-  by
-  rw [comap_bracket_incl]
-  rw [← inf_eq_right] at h₁ h₂
-  rw [h₁, h₂]
+    ⁅comap I.incl I₁, comap I.incl I₂⁆ = comap I.incl ⁅I₁, I₂⁆ := by rw [comap_bracket_incl];
+  rw [← inf_eq_right] at h₁ h₂; rw [h₁, h₂]
 #align lie_ideal.comap_bracket_incl_of_le LieIdeal.comap_bracket_incl_of_le
 
 end LieIdeal

8983bec7

bump to nightly-2023-05-24-06

mathlib commit https://github.com/leanprover-community/mathlib/commit/8d33f09cd7089ecf074b4791907588245aec5d1b

fbc7b476

Diff

@@ -205,7 +205,7 @@ theorem lie_sup : ⁅I, N ⊔ N'⁆ = ⁅I, N⁆ ⊔ ⁅I, N'⁆ :=
   have h : ⁅I, N⁆ ⊔ ⁅I, N'⁆ ≤ ⁅I, N ⊔ N'⁆ :=
     by
     rw [sup_le_iff]
-    constructor <;> apply mono_lie_right <;> [exact le_sup_left, exact le_sup_right]
+    constructor <;> apply mono_lie_right <;> [exact le_sup_left;exact le_sup_right]
   suffices ⁅I, N ⊔ N'⁆ ≤ ⁅I, N⁆ ⊔ ⁅I, N'⁆ by exact le_antisymm this h
   clear h
   rw [lie_ideal_oper_eq_span, lie_span_le]
@@ -227,7 +227,7 @@ theorem sup_lie : ⁅I ⊔ J, N⁆ = ⁅I, N⁆ ⊔ ⁅J, N⁆ :=
   by
   have h : ⁅I, N⁆ ⊔ ⁅J, N⁆ ≤ ⁅I ⊔ J, N⁆ := by
     rw [sup_le_iff]
-    constructor <;> apply mono_lie_left <;> [exact le_sup_left, exact le_sup_right]
+    constructor <;> apply mono_lie_left <;> [exact le_sup_left;exact le_sup_right]
   suffices ⁅I ⊔ J, N⁆ ≤ ⁅I, N⁆ ⊔ ⁅J, N⁆ by exact le_antisymm this h
   clear h
   rw [lie_ideal_oper_eq_span, lie_span_le]
@@ -248,14 +248,14 @@ theorem sup_lie : ⁅I ⊔ J, N⁆ = ⁅I, N⁆ ⊔ ⁅J, N⁆ :=
 theorem lie_inf : ⁅I, N ⊓ N'⁆ ≤ ⁅I, N⁆ ⊓ ⁅I, N'⁆ :=
   by
   rw [le_inf_iff]
-  constructor <;> apply mono_lie_right <;> [exact inf_le_left, exact inf_le_right]
+  constructor <;> apply mono_lie_right <;> [exact inf_le_left;exact inf_le_right]
 #align lie_submodule.lie_inf LieSubmodule.lie_inf
 
 @[simp]
 theorem inf_lie : ⁅I ⊓ J, N⁆ ≤ ⁅I, N⁆ ⊓ ⁅J, N⁆ :=
   by
   rw [le_inf_iff]
-  constructor <;> apply mono_lie_left <;> [exact inf_le_left, exact inf_le_right]
+  constructor <;> apply mono_lie_left <;> [exact inf_le_left;exact inf_le_right]
 #align lie_submodule.inf_lie LieSubmodule.inf_lie
 
 variable (f : M →ₗ⁅R,L⁆ M₂)

8983bec7

bump to nightly-2023-02-27-16

mathlib commit https://github.com/leanprover-community/mathlib/commit/eb0cb4511aaef0da2462207b67358a0e1fe1e2ee

feafc24f

Diff

@@ -373,7 +373,7 @@ theorem comap_bracket_eq {J₁ J₂ : LieIdeal R L'} (h : f.IsIdealMorphism) :
     LieSubmodule.sup_coe_to_submodule, f.ker_coe_submodule, ← Submodule.comap_map_eq,
     LieSubmodule.lieIdeal_oper_eq_linear_span, LieSubmodule.lieIdeal_oper_eq_linear_span,
     LinearMap.map_span]
-  congr ; simp only [LieHom.coe_to_linearMap, Set.mem_setOf_eq]; ext y
+  congr ; simp only [LieHom.coe_toLinearMap, Set.mem_setOf_eq]; ext y
   constructor
   · rintro ⟨⟨x₁, hx₁⟩, ⟨x₂, hx₂⟩, hy⟩
     rw [← hy]

8983bec7

bump to nightly-2023-02-21-16

mathlib commit https://github.com/leanprover-community/mathlib/commit/bd9851ca476957ea4549eb19b40e7b5ade9428cc

1107b979

Changes in mathlib4

mathlib3

mathlib4

8983bec7

chore: adapt to multiple goal linter 1 (#12338)

A PR accompanying #12339.

Zulip discussion

45f93f3f

Diff

@@ -329,7 +329,8 @@ theorem comap_bracket_incl {I₁ I₂ : LieIdeal R L} :
     next => skip
     rw [← I.incl_idealRange]
   rw [comap_bracket_eq]
-  simp only [ker_incl, sup_bot_eq]; exact I.incl_isIdealMorphism
+  · simp only [ker_incl, sup_bot_eq]
+  · exact I.incl_isIdealMorphism
 #align lie_ideal.comap_bracket_incl LieIdeal.comap_bracket_incl
 
 /-- This is a very useful result; it allows us to use the fact that inclusion distributes over the

8983bec7

feat(Algebra/Lie): define adjoint action and its ideal image (#12106)

This defines the adjoint action of a Lie algebra L on itself, when seen as an homomorphism of Lie algebras from L to the Lie algebra of its derivations.

The adjoint action was also defined in the Mathlib.Algebra.Lie.OfAssociative.lean file, under the name LieAlgebra.ad, as the homomorphism with values in the endormophisms of L. We make the link between both. This design choice was discussed in this thread.

We also establish elementary properties, such as the fact that the image of the adjoint action is an ideal of the derivations.

This is the penultimate step towards proving that all derivations of a finite-dimensional semisimple Lie algebra are inner, a goal described in this thread.

9125a093

Diff

@@ -310,9 +310,9 @@ theorem comap_bracket_eq {J₁ J₂ : LieIdeal R L'} (h : f.IsIdealMorphism) :
     simp only [hz₁, hz₂, Submodule.coe_mk, LieHom.map_lie]
   · rintro ⟨x, ⟨⟨z₁, hz₁⟩, ⟨z₂, hz₂⟩, hx⟩, hy⟩; rw [← hy, ← hx]
     have hz₁' : f z₁ ∈ f.idealRange ⊓ J₁ := by
-      rw [LieSubmodule.mem_inf]; exact ⟨f.mem_idealRange, hz₁⟩
+      rw [LieSubmodule.mem_inf]; exact ⟨f.mem_idealRange z₁, hz₁⟩
     have hz₂' : f z₂ ∈ f.idealRange ⊓ J₂ := by
-      rw [LieSubmodule.mem_inf]; exact ⟨f.mem_idealRange, hz₂⟩
+      rw [LieSubmodule.mem_inf]; exact ⟨f.mem_idealRange z₂, hz₂⟩
     use ⟨f z₁, hz₁'⟩, ⟨f z₂, hz₂'⟩; simp only [Submodule.coe_mk, LieHom.map_lie]
 #align lie_ideal.comap_bracket_eq LieIdeal.comap_bracket_eq

8983bec7

chore(*): remove empty lines between variable statements (#11418)

Empty lines were removed by executing the following Python script twice

import os
import re


# Loop through each file in the repository
for dir_path, dirs, files in os.walk('.'):
  for filename in files:
    if filename.endswith('.lean'):
      file_path = os.path.join(dir_path, filename)

      # Open the file and read its contents
      with open(file_path, 'r') as file:
        content = file.read()

      # Use a regular expression to replace sequences of "variable" lines separated by empty lines
      # with sequences without empty lines
      modified_content = re.sub(r'(variable.*\n)\n(variable(?! .* in))', r'\1\2', content)

      # Write the modified content back to the file
      with open(file_path, 'w') as file:
        file.write(modified_content)

75c86f04

Diff

@@ -39,13 +39,9 @@ universe u v w w₁ w₂
 namespace LieSubmodule
 
 variable {R : Type u} {L : Type v} {M : Type w} {M₂ : Type w₁}
-
 variable [CommRing R] [LieRing L] [LieAlgebra R L]
-
 variable [AddCommGroup M] [Module R M] [LieRingModule L M] [LieModule R L M]
-
 variable [AddCommGroup M₂] [Module R M₂] [LieRingModule L M₂] [LieModule R L M₂]
-
 variable (N N' : LieSubmodule R L M) (I J : LieIdeal R L) (N₂ : LieSubmodule R L M₂)
 
 section LieIdealOperations
@@ -257,9 +253,7 @@ namespace LieIdeal
 open LieAlgebra
 
 variable {R : Type u} {L : Type v} {L' : Type w₂}
-
 variable [CommRing R] [LieRing L] [LieAlgebra R L] [LieRing L'] [LieAlgebra R L']
-
 variable (f : L →ₗ⁅R⁆ L') (I : LieIdeal R L) (J : LieIdeal R L')
 
 /-- Note that the inequality can be strict; e.g., the inclusion of an Abelian subalgebra of a

8983bec7

chore: script to replace headers with #align_import statements (#5979)

depends on: #5966

Co-authored-by: Eric Wieser <wieser.eric@gmail.com> Co-authored-by: Scott Morrison <scott.morrison@gmail.com>

89aa3a3b

Diff

@@ -2,14 +2,11 @@
 Copyright (c) 2021 Oliver Nash. All rights reserved.
 Released under Apache 2.0 license as described in the file LICENSE.
 Authors: Oliver Nash
-
-! This file was ported from Lean 3 source module algebra.lie.ideal_operations
-! leanprover-community/mathlib commit 8983bec7cdf6cb2dd1f21315c8a34ab00d7b2f6d
-! Please do not edit these lines, except to modify the commit id
-! if you have ported upstream changes.
 -/
 import Mathlib.Algebra.Lie.Submodule
 
+#align_import algebra.lie.ideal_operations from "leanprover-community/mathlib"@"8983bec7cdf6cb2dd1f21315c8a34ab00d7b2f6d"
+
 /-!
 # Ideal operations for Lie algebras

8983bec7

chore: remove occurrences of semicolon after space (#5713)

This is the second half of the changes originally in #5699, removing all occurrences of ; after a space and implementing a linter rule to enforce it.

In most cases this 2-character substring has a space after it, so the following command was run first:

find . -type f -name "*.lean" -exec sed -i -E 's/ ; /; /g' {} \;

The remaining cases were few enough in number that they were done manually.

c795bd35

Diff

@@ -142,7 +142,7 @@ theorem lie_bot : ⁅I, (⊥ : LieSubmodule R L M)⁆ = ⊥ := by rw [eq_bot_iff
 theorem bot_lie : ⁅(⊥ : LieIdeal R L), N⁆ = ⊥ := by
   suffices ⁅(⊥ : LieIdeal R L), N⁆ ≤ ⊥ by exact le_bot_iff.mp this
   rw [lieIdeal_oper_eq_span, lieSpan_le]; rintro m ⟨⟨x, hx⟩, n, hn⟩; rw [← hn]
-  change x ∈ (⊥ : LieIdeal R L) at hx ; rw [mem_bot] at hx ; simp [hx]
+  change x ∈ (⊥ : LieIdeal R L) at hx; rw [mem_bot] at hx; simp [hx]
 #align lie_submodule.bot_lie LieSubmodule.bot_lie
 
 theorem lie_eq_bot_iff : ⁅I, N⁆ = ⊥ ↔ ∀ x ∈ I, ∀ m ∈ N, ⁅(x : L), m⁆ = 0 := by
@@ -154,7 +154,7 @@ theorem lie_eq_bot_iff : ⁅I, N⁆ = ⊥ ↔ ∀ x ∈ I, ∀ m ∈ N, ⁅(x :
 
 theorem mono_lie (h₁ : I ≤ J) (h₂ : N ≤ N') : ⁅I, N⁆ ≤ ⁅J, N'⁆ := by
   intro m h
-  rw [lieIdeal_oper_eq_span, mem_lieSpan] at h ; rw [lieIdeal_oper_eq_span, mem_lieSpan]
+  rw [lieIdeal_oper_eq_span, mem_lieSpan] at h; rw [lieIdeal_oper_eq_span, mem_lieSpan]
   intro N hN; apply h; rintro m' ⟨⟨x, hx⟩, ⟨n, hn⟩, hm⟩; rw [← hm]; apply hN
   use ⟨x, h₁ hx⟩, ⟨n, h₂ hn⟩
 #align lie_submodule.mono_lie LieSubmodule.mono_lie
@@ -174,7 +174,7 @@ theorem lie_sup : ⁅I, N ⊔ N'⁆ = ⁅I, N⁆ ⊔ ⁅I, N'⁆ := by
     apply mono_lie_right <;> [exact le_sup_left; exact le_sup_right]
   suffices ⁅I, N ⊔ N'⁆ ≤ ⁅I, N⁆ ⊔ ⁅I, N'⁆ by exact le_antisymm this h
   rw [lieIdeal_oper_eq_span, lieSpan_le]; rintro m ⟨x, ⟨n, hn⟩, h⟩; erw [LieSubmodule.mem_sup]
-  erw [LieSubmodule.mem_sup] at hn ; rcases hn with ⟨n₁, hn₁, n₂, hn₂, hn'⟩
+  erw [LieSubmodule.mem_sup] at hn; rcases hn with ⟨n₁, hn₁, n₂, hn₂, hn'⟩
   use ⁅(x : L), (⟨n₁, hn₁⟩ : N)⁆; constructor; · apply lie_coe_mem_lie
   use ⁅(x : L), (⟨n₂, hn₂⟩ : N')⁆; constructor; · apply lie_coe_mem_lie
   simp [← h, ← hn']
@@ -187,7 +187,7 @@ theorem sup_lie : ⁅I ⊔ J, N⁆ = ⁅I, N⁆ ⊔ ⁅J, N⁆ := by
     apply mono_lie_left <;> [exact le_sup_left; exact le_sup_right]
   suffices ⁅I ⊔ J, N⁆ ≤ ⁅I, N⁆ ⊔ ⁅J, N⁆ by exact le_antisymm this h
   rw [lieIdeal_oper_eq_span, lieSpan_le]; rintro m ⟨⟨x, hx⟩, n, h⟩; erw [LieSubmodule.mem_sup]
-  erw [LieSubmodule.mem_sup] at hx ; rcases hx with ⟨x₁, hx₁, x₂, hx₂, hx'⟩
+  erw [LieSubmodule.mem_sup] at hx; rcases hx with ⟨x₁, hx₁, x₂, hx₂, hx'⟩
   use ⁅((⟨x₁, hx₁⟩ : I) : L), (n : N)⁆; constructor; · apply lie_coe_mem_lie
   use ⁅((⟨x₂, hx₂⟩ : J) : L), (n : N)⁆; constructor; · apply lie_coe_mem_lie
   simp [← h, ← hx']
@@ -345,7 +345,7 @@ theorem comap_bracket_incl {I₁ I₂ : LieIdeal R L} :
 Lie bracket operation on ideals, subject to the conditions shown. -/
 theorem comap_bracket_incl_of_le {I₁ I₂ : LieIdeal R L} (h₁ : I₁ ≤ I) (h₂ : I₂ ≤ I) :
     ⁅comap I.incl I₁, comap I.incl I₂⁆ = comap I.incl ⁅I₁, I₂⁆ := by
-    rw [comap_bracket_incl]; rw [← inf_eq_right] at h₁ h₂ ; rw [h₁, h₂]
+    rw [comap_bracket_incl]; rw [← inf_eq_right] at h₁ h₂; rw [h₁, h₂]
 #align lie_ideal.comap_bracket_incl_of_le LieIdeal.comap_bracket_incl_of_le
 
 end LieIdeal

8983bec7

chore: tidy various files (#5104)

62d90431

Diff

@@ -65,7 +65,7 @@ theorem lieIdeal_oper_eq_span :
 #align lie_submodule.lie_ideal_oper_eq_span LieSubmodule.lieIdeal_oper_eq_span
 
 /-- See also `LieSubmodule.lieIdeal_oper_eq_linear_span'` and
-`lie_submodule.lie_ideal_oper_eq_tensor_map_range`. -/
+`LieSubmodule.lieIdeal_oper_eq_tensor_map_range`. -/
 theorem lieIdeal_oper_eq_linear_span :
     (↑⁅I, N⁆ : Submodule R M) =
       Submodule.span R { m | ∃ (x : I) (n : N), ⁅(x : L), (n : M)⁆ = m } := by

8983bec7

feat: port Algebra.Lie.IdealOperations (#4618)

Co-authored-by: Jeremy Tan Jie Rui <reddeloostw@gmail.com>

bf2154ed

`algebra.lie.ideal_operations` ⟷ `Mathlib.Algebra.Lie.IdealOperations`

Changes since the initial port

Changes in mathlib3

Changes in mathlib3port

Changes in mathlib4

Dependencies 8 + 467

algebra.lie.ideal_operations ⟷ Mathlib.Algebra.Lie.IdealOperations

Changes since the initial port

Changes in mathlib3

Changes in mathlib3port

Changes in mathlib4

Dependencies 8 + 467

`algebra.lie.ideal_operations` ⟷ `Mathlib.Algebra.Lie.IdealOperations`