ring_theory.henselian | 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

d1accf4f

(last sync)

Changes in mathlib3port

mathlib3

mathlib3port

61db041a

bump to nightly-2024-04-07-08

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

b03b8656

Diff

@@ -3,7 +3,7 @@ Copyright (c) 2021 Johan Commelin. All rights reserved.
 Released under Apache 2.0 license as described in the file LICENSE.
 Authors: Johan Commelin
 -/
-import Data.Polynomial.Taylor
+import Algebra.Polynomial.Taylor
 import RingTheory.Ideal.LocalRing
 import LinearAlgebra.AdicCompletion

61db041a

bump to nightly-2024-03-17-08

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

22f01ce4

Diff

@@ -85,9 +85,9 @@ theorem isLocalRingHom_of_le_jacobson_bot {R : Type _} [CommRing R] (I : Ideal R
   obtain ⟨⟨x, y, h1, h2⟩, rfl : x = _⟩ := this
   obtain ⟨y, rfl⟩ := Ideal.Quotient.mk_surjective y
   rw [← (Ideal.Quotient.mk _).map_hMul, ← (Ideal.Quotient.mk _).map_one, Ideal.Quotient.eq,
-    Ideal.mem_jacobson_bot] at h1 h2 
+    Ideal.mem_jacobson_bot] at h1 h2
   specialize h1 1
-  simp at h1 
+  simp at h1
   exact h1.1
 #align is_local_ring_hom_of_le_jacobson_bot isLocalRingHom_of_le_jacobson_bot
 -/
@@ -152,21 +152,21 @@ theorem HenselianLocalRing.TFAE (R : Type u) [CommRing R] [LocalRing R] :
     specialize H f hf (residue R a₀)
     have aux := flip mem_nonunits_iff.mp h₂
     simp only [aeval_def, residue_field.algebra_map_eq, eval₂_at_apply, ←
-      Ideal.Quotient.eq_zero_iff_mem, ← LocalRing.mem_maximalIdeal] at H h₁ aux 
+      Ideal.Quotient.eq_zero_iff_mem, ← LocalRing.mem_maximalIdeal] at H h₁ aux
     obtain ⟨a, ha₁, ha₂⟩ := H h₁ aux
     refine' ⟨a, ha₁, _⟩
     rw [← Ideal.Quotient.eq_zero_iff_mem]
-    rwa [← sub_eq_zero, ← RingHom.map_sub] at ha₂ 
+    rwa [← sub_eq_zero, ← RingHom.map_sub] at ha₂
   tfae_have _1_3 : 1 → 3
   · intro hR K _K φ hφ f hf a₀ h₁ h₂
     obtain ⟨a₀, rfl⟩ := hφ a₀
     have H := HenselianLocalRing.is_henselian f hf a₀
-    simp only [← ker_eq_maximal_ideal φ hφ, eval₂_at_apply, φ.mem_ker] at H h₁ h₂ 
+    simp only [← ker_eq_maximal_ideal φ hφ, eval₂_at_apply, φ.mem_ker] at H h₁ h₂
     obtain ⟨a, ha₁, ha₂⟩ := H h₁ _
-    · refine' ⟨a, ha₁, _⟩; rwa [φ.map_sub, sub_eq_zero] at ha₂ 
+    · refine' ⟨a, ha₁, _⟩; rwa [φ.map_sub, sub_eq_zero] at ha₂
     · contrapose! h₂
       rwa [← mem_nonunits_iff, ← LocalRing.mem_maximalIdeal, ← LocalRing.ker_eq_maximalIdeal φ hφ,
-        φ.mem_ker] at h₂ 
+        φ.mem_ker] at h₂
   tfae_finish
 #align henselian_local_ring.tfae HenselianLocalRing.TFAE
 -/
@@ -178,7 +178,7 @@ instance (R : Type _) [CommRing R] [hR : HenselianLocalRing R] : HenselianRing R
     intro f hf a₀ h₁ h₂
     refine' HenselianLocalRing.is_henselian f hf a₀ h₁ _
     contrapose! h₂
-    rw [← mem_nonunits_iff, ← LocalRing.mem_maximalIdeal, ← Ideal.Quotient.eq_zero_iff_mem] at h₂ 
+    rw [← mem_nonunits_iff, ← LocalRing.mem_maximalIdeal, ← Ideal.Quotient.eq_zero_iff_mem] at h₂
     rw [h₂]
     exact not_isUnit_zero
 
@@ -262,7 +262,7 @@ instance (priority := 100) IsAdicComplete.henselianRing (R : Type _) [CommRing R
       exact Ideal.pow_le_pow le_self_add (hfcI _)
     · show a - a₀ ∈ I
       specialize ha 1
-      rw [hc, pow_one, ← Ideal.one_eq_top, Ideal.smul_eq_mul, mul_one, sub_eq_add_neg] at ha 
+      rw [hc, pow_one, ← Ideal.one_eq_top, Ideal.smul_eq_mul, mul_one, sub_eq_add_neg] at ha
       rw [← SModEq.sub_mem, ← add_zero a₀]
       refine' ha.symm.trans (smodeq.rfl.add _)
       rw [SModEq.zero, Ideal.neg_mem_iff]

61db041a

bump to nightly-2024-02-01-06

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

5433bded

Diff

@@ -192,15 +192,81 @@ instance (priority := 100) IsAdicComplete.henselianRing (R : Type _) [CommRing R
   is_henselian := by
     intro f hf a₀ h₁ h₂
     classical
+    let f' := f.derivative
+    -- we define a sequence `c n` by starting at `a₀` and then continually
+    -- applying the function sending `b` to `b - f(b)/f'(b)` (Newton's method).
+    -- Note that `f'.eval b` is a unit, because `b` has the same residue as `a₀` modulo `I`.
+    let c : ℕ → R := fun n => Nat.recOn n a₀ fun _ b => b - f.eval b * Ring.inverse (f'.eval b)
+    have hc : ∀ n, c (n + 1) = c n - f.eval (c n) * Ring.inverse (f'.eval (c n)) := by intro n;
+      dsimp only [c, Nat.rec_add_one]; rfl
+    -- we now spend some time determining properties of the sequence `c : ℕ → R`
+    -- `hc_mod`: for every `n`, we have `c n ≡ a₀ [SMOD I]`
+    -- `hf'c`  : for every `n`, `f'.eval (c n)` is a unit
+    -- `hfcI`  : for every `n`, `f.eval (c n)` is contained in `I ^ (n+1)`
+    have hc_mod : ∀ n, c n ≡ a₀ [SMOD I] := by
+      intro n; induction' n with n ih; · rfl
+      rw [Nat.succ_eq_add_one, hc, sub_eq_add_neg, ← add_zero a₀]
+      refine' ih.add _
+      rw [SModEq.zero, Ideal.neg_mem_iff]
+      refine' I.mul_mem_right _ _
+      rw [← SModEq.zero] at h₁ ⊢
+      exact (ih.eval f).trans h₁
+    have hf'c : ∀ n, IsUnit (f'.eval (c n)) := by
+      intro n
+      haveI := isLocalRingHom_of_le_jacobson_bot I (IsAdicComplete.le_jacobson_bot I)
+      apply isUnit_of_map_unit (Ideal.Quotient.mk I)
+      convert h₂ using 1
+      exact smodeq.def.mp ((hc_mod n).eval _)
+    have hfcI : ∀ n, f.eval (c n) ∈ I ^ (n + 1) :=
+      by
+      intro n
+      induction' n with n ih; · simpa only [pow_one]
+      simp only [Nat.succ_eq_add_one]
+      rw [← taylor_eval_sub (c n), hc]
+      simp only [sub_eq_add_neg, add_neg_cancel_comm]
+      rw [eval_eq_sum, sum_over_range' _ _ _ (lt_add_of_pos_right _ zero_lt_two), ←
+        Finset.sum_range_add_sum_Ico _ (Nat.le_add_left _ _)]
+      swap; · intro i; rw [MulZeroClass.zero_mul]
+      refine' Ideal.add_mem _ _ _
+      · simp only [Finset.sum_range_succ, taylor_coeff_one, mul_one, pow_one, taylor_coeff_zero,
+          mul_neg, Finset.sum_singleton, Finset.range_one, pow_zero]
+        rw [mul_left_comm, Ring.mul_inverse_cancel _ (hf'c n), mul_one, add_neg_self]
+        exact Ideal.zero_mem _
+      · refine' Submodule.sum_mem _ _; simp only [Finset.mem_Ico]
+        rintro i ⟨h2i, hi⟩
+        have aux : n + 2 ≤ i * (n + 1) := by trans 2 * (n + 1) <;> nlinarith only [h2i]
+        refine' Ideal.mul_mem_left _ _ (Ideal.pow_le_pow aux _)
+        rw [pow_mul']
+        refine' Ideal.pow_mem_pow ((Ideal.neg_mem_iff _).2 <| Ideal.mul_mem_right _ _ ih) _
+    -- we are now in the position to show that `c : ℕ → R` is a Cauchy sequence
+    have aux : ∀ m n, m ≤ n → c m ≡ c n [SMOD (I ^ m • ⊤ : Ideal R)] :=
+      by
+      intro m n hmn
+      rw [← Ideal.one_eq_top, Ideal.smul_eq_mul, mul_one]
+      obtain ⟨k, rfl⟩ := Nat.exists_eq_add_of_le hmn; clear hmn
+      induction' k with k ih; · rw [add_zero]
+      rw [Nat.succ_eq_add_one, ← add_assoc, hc, ← add_zero (c m), sub_eq_add_neg]
+      refine' ih.add _; symm
+      rw [SModEq.zero, Ideal.neg_mem_iff]
+      refine' Ideal.mul_mem_right _ _ (Ideal.pow_le_pow _ (hfcI _))
+      rw [add_assoc]; exact le_self_add
+    -- hence the sequence converges to some limit point `a`, which is the `a` we are looking for
+    obtain ⟨a, ha⟩ := IsPrecomplete.prec' c aux
+    refine' ⟨a, _, _⟩
+    · show f.is_root a
+      suffices ∀ n, f.eval a ≡ 0 [SMOD (I ^ n • ⊤ : Ideal R)] by exact IsHausdorff.haus' _ this
+      intro n; specialize ha n
+      rw [← Ideal.one_eq_top, Ideal.smul_eq_mul, mul_one] at ha ⊢
+      refine' (ha.symm.eval f).trans _
+      rw [SModEq.zero]
+      exact Ideal.pow_le_pow le_self_add (hfcI _)
+    · show a - a₀ ∈ I
+      specialize ha 1
+      rw [hc, pow_one, ← Ideal.one_eq_top, Ideal.smul_eq_mul, mul_one, sub_eq_add_neg] at ha 
+      rw [← SModEq.sub_mem, ← add_zero a₀]
+      refine' ha.symm.trans (smodeq.rfl.add _)
+      rw [SModEq.zero, Ideal.neg_mem_iff]
+      exact Ideal.mul_mem_right _ _ h₁
 #align is_adic_complete.henselian_ring IsAdicComplete.henselianRing
 -/
 
--- we define a sequence `c n` by starting at `a₀` and then continually
--- applying the function sending `b` to `b - f(b)/f'(b)` (Newton's method).
--- Note that `f'.eval b` is a unit, because `b` has the same residue as `a₀` modulo `I`.
--- we now spend some time determining properties of the sequence `c : ℕ → R`
--- `hc_mod`: for every `n`, we have `c n ≡ a₀ [SMOD I]`
--- `hf'c`  : for every `n`, `f'.eval (c n)` is a unit
--- `hfcI`  : for every `n`, `f.eval (c n)` is contained in `I ^ (n+1)`
--- we are now in the position to show that `c : ℕ → R` is a Cauchy sequence
--- hence the sequence converges to some limit point `a`, which is the `a` we are looking for

61db041a

bump to nightly-2024-01-31-06

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

61100fe9

Diff

@@ -192,81 +192,15 @@ instance (priority := 100) IsAdicComplete.henselianRing (R : Type _) [CommRing R
   is_henselian := by
     intro f hf a₀ h₁ h₂
     classical
-    let f' := f.derivative
-    -- we define a sequence `c n` by starting at `a₀` and then continually
-    -- applying the function sending `b` to `b - f(b)/f'(b)` (Newton's method).
-    -- Note that `f'.eval b` is a unit, because `b` has the same residue as `a₀` modulo `I`.
-    let c : ℕ → R := fun n => Nat.recOn n a₀ fun _ b => b - f.eval b * Ring.inverse (f'.eval b)
-    have hc : ∀ n, c (n + 1) = c n - f.eval (c n) * Ring.inverse (f'.eval (c n)) := by intro n;
-      dsimp only [c, Nat.rec_add_one]; rfl
-    -- we now spend some time determining properties of the sequence `c : ℕ → R`
-    -- `hc_mod`: for every `n`, we have `c n ≡ a₀ [SMOD I]`
-    -- `hf'c`  : for every `n`, `f'.eval (c n)` is a unit
-    -- `hfcI`  : for every `n`, `f.eval (c n)` is contained in `I ^ (n+1)`
-    have hc_mod : ∀ n, c n ≡ a₀ [SMOD I] := by
-      intro n; induction' n with n ih; · rfl
-      rw [Nat.succ_eq_add_one, hc, sub_eq_add_neg, ← add_zero a₀]
-      refine' ih.add _
-      rw [SModEq.zero, Ideal.neg_mem_iff]
-      refine' I.mul_mem_right _ _
-      rw [← SModEq.zero] at h₁ ⊢
-      exact (ih.eval f).trans h₁
-    have hf'c : ∀ n, IsUnit (f'.eval (c n)) := by
-      intro n
-      haveI := isLocalRingHom_of_le_jacobson_bot I (IsAdicComplete.le_jacobson_bot I)
-      apply isUnit_of_map_unit (Ideal.Quotient.mk I)
-      convert h₂ using 1
-      exact smodeq.def.mp ((hc_mod n).eval _)
-    have hfcI : ∀ n, f.eval (c n) ∈ I ^ (n + 1) :=
-      by
-      intro n
-      induction' n with n ih; · simpa only [pow_one]
-      simp only [Nat.succ_eq_add_one]
-      rw [← taylor_eval_sub (c n), hc]
-      simp only [sub_eq_add_neg, add_neg_cancel_comm]
-      rw [eval_eq_sum, sum_over_range' _ _ _ (lt_add_of_pos_right _ zero_lt_two), ←
-        Finset.sum_range_add_sum_Ico _ (Nat.le_add_left _ _)]
-      swap; · intro i; rw [MulZeroClass.zero_mul]
-      refine' Ideal.add_mem _ _ _
-      · simp only [Finset.sum_range_succ, taylor_coeff_one, mul_one, pow_one, taylor_coeff_zero,
-          mul_neg, Finset.sum_singleton, Finset.range_one, pow_zero]
-        rw [mul_left_comm, Ring.mul_inverse_cancel _ (hf'c n), mul_one, add_neg_self]
-        exact Ideal.zero_mem _
-      · refine' Submodule.sum_mem _ _; simp only [Finset.mem_Ico]
-        rintro i ⟨h2i, hi⟩
-        have aux : n + 2 ≤ i * (n + 1) := by trans 2 * (n + 1) <;> nlinarith only [h2i]
-        refine' Ideal.mul_mem_left _ _ (Ideal.pow_le_pow aux _)
-        rw [pow_mul']
-        refine' Ideal.pow_mem_pow ((Ideal.neg_mem_iff _).2 <| Ideal.mul_mem_right _ _ ih) _
-    -- we are now in the position to show that `c : ℕ → R` is a Cauchy sequence
-    have aux : ∀ m n, m ≤ n → c m ≡ c n [SMOD (I ^ m • ⊤ : Ideal R)] :=
-      by
-      intro m n hmn
-      rw [← Ideal.one_eq_top, Ideal.smul_eq_mul, mul_one]
-      obtain ⟨k, rfl⟩ := Nat.exists_eq_add_of_le hmn; clear hmn
-      induction' k with k ih; · rw [add_zero]
-      rw [Nat.succ_eq_add_one, ← add_assoc, hc, ← add_zero (c m), sub_eq_add_neg]
-      refine' ih.add _; symm
-      rw [SModEq.zero, Ideal.neg_mem_iff]
-      refine' Ideal.mul_mem_right _ _ (Ideal.pow_le_pow _ (hfcI _))
-      rw [add_assoc]; exact le_self_add
-    -- hence the sequence converges to some limit point `a`, which is the `a` we are looking for
-    obtain ⟨a, ha⟩ := IsPrecomplete.prec' c aux
-    refine' ⟨a, _, _⟩
-    · show f.is_root a
-      suffices ∀ n, f.eval a ≡ 0 [SMOD (I ^ n • ⊤ : Ideal R)] by exact IsHausdorff.haus' _ this
-      intro n; specialize ha n
-      rw [← Ideal.one_eq_top, Ideal.smul_eq_mul, mul_one] at ha ⊢
-      refine' (ha.symm.eval f).trans _
-      rw [SModEq.zero]
-      exact Ideal.pow_le_pow le_self_add (hfcI _)
-    · show a - a₀ ∈ I
-      specialize ha 1
-      rw [hc, pow_one, ← Ideal.one_eq_top, Ideal.smul_eq_mul, mul_one, sub_eq_add_neg] at ha 
-      rw [← SModEq.sub_mem, ← add_zero a₀]
-      refine' ha.symm.trans (smodeq.rfl.add _)
-      rw [SModEq.zero, Ideal.neg_mem_iff]
-      exact Ideal.mul_mem_right _ _ h₁
 #align is_adic_complete.henselian_ring IsAdicComplete.henselianRing
 -/
 
+-- we define a sequence `c n` by starting at `a₀` and then continually
+-- applying the function sending `b` to `b - f(b)/f'(b)` (Newton's method).
+-- Note that `f'.eval b` is a unit, because `b` has the same residue as `a₀` modulo `I`.
+-- we now spend some time determining properties of the sequence `c : ℕ → R`
+-- `hc_mod`: for every `n`, we have `c n ≡ a₀ [SMOD I]`
+-- `hf'c`  : for every `n`, `f'.eval (c n)` is a unit
+-- `hfcI`  : for every `n`, `f.eval (c n)` is contained in `I ^ (n+1)`
+-- we are now in the position to show that `c : ℕ → R` is a Cauchy sequence
+-- hence the sequence converges to some limit point `a`, which is the `a` we are looking for

61db041a

bump to nightly-2023-09-24-06

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

5655435f

Diff

@@ -3,9 +3,9 @@ Copyright (c) 2021 Johan Commelin. All rights reserved.
 Released under Apache 2.0 license as described in the file LICENSE.
 Authors: Johan Commelin
 -/
-import Mathbin.Data.Polynomial.Taylor
-import Mathbin.RingTheory.Ideal.LocalRing
-import Mathbin.LinearAlgebra.AdicCompletion
+import Data.Polynomial.Taylor
+import RingTheory.Ideal.LocalRing
+import LinearAlgebra.AdicCompletion
 
 #align_import ring_theory.henselian from "leanprover-community/mathlib"@"61db041ab8e4aaf8cb5c7dc10a7d4ff261997536"

61db041a

bump to nightly-2023-08-17-09

mathlib commit https://github.com/leanprover-community/mathlib/commit/32a7e535287f9c73f2e4d2aef306a39190f0b504

60285dcc

Diff

@@ -79,11 +79,12 @@ theorem isLocalRingHom_of_le_jacobson_bot {R : Type _} [CommRing R] (I : Ideal R
     obtain ⟨b, hb⟩ := h
     obtain ⟨b, rfl⟩ := Ideal.Quotient.mk_surjective b
     use Ideal.Quotient.mk _ b
-    rw [← (Ideal.Quotient.mk _).map_one, ← (Ideal.Quotient.mk _).map_mul, Ideal.Quotient.eq] at hb ⊢
+    rw [← (Ideal.Quotient.mk _).map_one, ← (Ideal.Quotient.mk _).map_hMul, Ideal.Quotient.eq] at hb
+      ⊢
     exact h hb
   obtain ⟨⟨x, y, h1, h2⟩, rfl : x = _⟩ := this
   obtain ⟨y, rfl⟩ := Ideal.Quotient.mk_surjective y
-  rw [← (Ideal.Quotient.mk _).map_mul, ← (Ideal.Quotient.mk _).map_one, Ideal.Quotient.eq,
+  rw [← (Ideal.Quotient.mk _).map_hMul, ← (Ideal.Quotient.mk _).map_one, Ideal.Quotient.eq,
     Ideal.mem_jacobson_bot] at h1 h2 
   specialize h1 1
   simp at h1

61db041a

bump to nightly-2023-07-20-09

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

9c56d0dd

Diff

@@ -2,16 +2,13 @@
 Copyright (c) 2021 Johan Commelin. All rights reserved.
 Released under Apache 2.0 license as described in the file LICENSE.
 Authors: Johan Commelin
-
-! This file was ported from Lean 3 source module ring_theory.henselian
-! leanprover-community/mathlib commit 61db041ab8e4aaf8cb5c7dc10a7d4ff261997536
-! Please do not edit these lines, except to modify the commit id
-! if you have ported upstream changes.
 -/
 import Mathbin.Data.Polynomial.Taylor
 import Mathbin.RingTheory.Ideal.LocalRing
 import Mathbin.LinearAlgebra.AdicCompletion
 
+#align_import ring_theory.henselian from "leanprover-community/mathlib"@"61db041ab8e4aaf8cb5c7dc10a7d4ff261997536"
+
 /-!
 # Henselian rings

61db041a

bump to nightly-2023-06-13-21

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

829520ac

Diff

@@ -70,6 +70,7 @@ open scoped BigOperators Polynomial
 
 open LocalRing Polynomial Function
 
+#print isLocalRingHom_of_le_jacobson_bot /-
 theorem isLocalRingHom_of_le_jacobson_bot {R : Type _} [CommRing R] (I : Ideal R)
     (h : I ≤ Ideal.jacobson ⊥) : IsLocalRingHom (Ideal.Quotient.mk I) :=
   by
@@ -91,6 +92,7 @@ theorem isLocalRingHom_of_le_jacobson_bot {R : Type _} [CommRing R] (I : Ideal R
   simp at h1 
   exact h1.1
 #align is_local_ring_hom_of_le_jacobson_bot isLocalRingHom_of_le_jacobson_bot
+-/
 
 #print HenselianRing /-
 /-- A ring `R` is *Henselian* at an ideal `I` if the following condition holds:
@@ -135,6 +137,7 @@ instance (priority := 100) Field.henselian (K : Type _) [Field K] : HenselianLoc
 #align field.henselian Field.henselian
 -/
 
+#print HenselianLocalRing.TFAE /-
 theorem HenselianLocalRing.TFAE (R : Type u) [CommRing R] [LocalRing R] :
     TFAE
       [HenselianLocalRing R,
@@ -168,6 +171,7 @@ theorem HenselianLocalRing.TFAE (R : Type u) [CommRing R] [LocalRing R] :
         φ.mem_ker] at h₂ 
   tfae_finish
 #align henselian_local_ring.tfae HenselianLocalRing.TFAE
+-/
 
 instance (R : Type _) [CommRing R] [hR : HenselianLocalRing R] : HenselianRing R (maximalIdeal R)
     where

61db041a

bump to nightly-2023-06-04-18

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

3fb4268b

Diff

@@ -190,81 +190,81 @@ instance (priority := 100) IsAdicComplete.henselianRing (R : Type _) [CommRing R
   is_henselian := by
     intro f hf a₀ h₁ h₂
     classical
-      let f' := f.derivative
-      -- we define a sequence `c n` by starting at `a₀` and then continually
-      -- applying the function sending `b` to `b - f(b)/f'(b)` (Newton's method).
-      -- Note that `f'.eval b` is a unit, because `b` has the same residue as `a₀` modulo `I`.
-      let c : ℕ → R := fun n => Nat.recOn n a₀ fun _ b => b - f.eval b * Ring.inverse (f'.eval b)
-      have hc : ∀ n, c (n + 1) = c n - f.eval (c n) * Ring.inverse (f'.eval (c n)) := by intro n;
-        dsimp only [c, Nat.rec_add_one]; rfl
-      -- we now spend some time determining properties of the sequence `c : ℕ → R`
-      -- `hc_mod`: for every `n`, we have `c n ≡ a₀ [SMOD I]`
-      -- `hf'c`  : for every `n`, `f'.eval (c n)` is a unit
-      -- `hfcI`  : for every `n`, `f.eval (c n)` is contained in `I ^ (n+1)`
-      have hc_mod : ∀ n, c n ≡ a₀ [SMOD I] := by
-        intro n; induction' n with n ih; · rfl
-        rw [Nat.succ_eq_add_one, hc, sub_eq_add_neg, ← add_zero a₀]
-        refine' ih.add _
-        rw [SModEq.zero, Ideal.neg_mem_iff]
-        refine' I.mul_mem_right _ _
-        rw [← SModEq.zero] at h₁ ⊢
-        exact (ih.eval f).trans h₁
-      have hf'c : ∀ n, IsUnit (f'.eval (c n)) := by
-        intro n
-        haveI := isLocalRingHom_of_le_jacobson_bot I (IsAdicComplete.le_jacobson_bot I)
-        apply isUnit_of_map_unit (Ideal.Quotient.mk I)
-        convert h₂ using 1
-        exact smodeq.def.mp ((hc_mod n).eval _)
-      have hfcI : ∀ n, f.eval (c n) ∈ I ^ (n + 1) :=
-        by
-        intro n
-        induction' n with n ih; · simpa only [pow_one]
-        simp only [Nat.succ_eq_add_one]
-        rw [← taylor_eval_sub (c n), hc]
-        simp only [sub_eq_add_neg, add_neg_cancel_comm]
-        rw [eval_eq_sum, sum_over_range' _ _ _ (lt_add_of_pos_right _ zero_lt_two), ←
-          Finset.sum_range_add_sum_Ico _ (Nat.le_add_left _ _)]
-        swap; · intro i; rw [MulZeroClass.zero_mul]
-        refine' Ideal.add_mem _ _ _
-        · simp only [Finset.sum_range_succ, taylor_coeff_one, mul_one, pow_one, taylor_coeff_zero,
-            mul_neg, Finset.sum_singleton, Finset.range_one, pow_zero]
-          rw [mul_left_comm, Ring.mul_inverse_cancel _ (hf'c n), mul_one, add_neg_self]
-          exact Ideal.zero_mem _
-        · refine' Submodule.sum_mem _ _; simp only [Finset.mem_Ico]
-          rintro i ⟨h2i, hi⟩
-          have aux : n + 2 ≤ i * (n + 1) := by trans 2 * (n + 1) <;> nlinarith only [h2i]
-          refine' Ideal.mul_mem_left _ _ (Ideal.pow_le_pow aux _)
-          rw [pow_mul']
-          refine' Ideal.pow_mem_pow ((Ideal.neg_mem_iff _).2 <| Ideal.mul_mem_right _ _ ih) _
-      -- we are now in the position to show that `c : ℕ → R` is a Cauchy sequence
-      have aux : ∀ m n, m ≤ n → c m ≡ c n [SMOD (I ^ m • ⊤ : Ideal R)] :=
-        by
-        intro m n hmn
-        rw [← Ideal.one_eq_top, Ideal.smul_eq_mul, mul_one]
-        obtain ⟨k, rfl⟩ := Nat.exists_eq_add_of_le hmn; clear hmn
-        induction' k with k ih; · rw [add_zero]
-        rw [Nat.succ_eq_add_one, ← add_assoc, hc, ← add_zero (c m), sub_eq_add_neg]
-        refine' ih.add _; symm
-        rw [SModEq.zero, Ideal.neg_mem_iff]
-        refine' Ideal.mul_mem_right _ _ (Ideal.pow_le_pow _ (hfcI _))
-        rw [add_assoc]; exact le_self_add
-      -- hence the sequence converges to some limit point `a`, which is the `a` we are looking for
-      obtain ⟨a, ha⟩ := IsPrecomplete.prec' c aux
-      refine' ⟨a, _, _⟩
-      · show f.is_root a
-        suffices ∀ n, f.eval a ≡ 0 [SMOD (I ^ n • ⊤ : Ideal R)] by exact IsHausdorff.haus' _ this
-        intro n; specialize ha n
-        rw [← Ideal.one_eq_top, Ideal.smul_eq_mul, mul_one] at ha ⊢
-        refine' (ha.symm.eval f).trans _
-        rw [SModEq.zero]
-        exact Ideal.pow_le_pow le_self_add (hfcI _)
-      · show a - a₀ ∈ I
-        specialize ha 1
-        rw [hc, pow_one, ← Ideal.one_eq_top, Ideal.smul_eq_mul, mul_one, sub_eq_add_neg] at ha 
-        rw [← SModEq.sub_mem, ← add_zero a₀]
-        refine' ha.symm.trans (smodeq.rfl.add _)
-        rw [SModEq.zero, Ideal.neg_mem_iff]
-        exact Ideal.mul_mem_right _ _ h₁
+    let f' := f.derivative
+    -- we define a sequence `c n` by starting at `a₀` and then continually
+    -- applying the function sending `b` to `b - f(b)/f'(b)` (Newton's method).
+    -- Note that `f'.eval b` is a unit, because `b` has the same residue as `a₀` modulo `I`.
+    let c : ℕ → R := fun n => Nat.recOn n a₀ fun _ b => b - f.eval b * Ring.inverse (f'.eval b)
+    have hc : ∀ n, c (n + 1) = c n - f.eval (c n) * Ring.inverse (f'.eval (c n)) := by intro n;
+      dsimp only [c, Nat.rec_add_one]; rfl
+    -- we now spend some time determining properties of the sequence `c : ℕ → R`
+    -- `hc_mod`: for every `n`, we have `c n ≡ a₀ [SMOD I]`
+    -- `hf'c`  : for every `n`, `f'.eval (c n)` is a unit
+    -- `hfcI`  : for every `n`, `f.eval (c n)` is contained in `I ^ (n+1)`
+    have hc_mod : ∀ n, c n ≡ a₀ [SMOD I] := by
+      intro n; induction' n with n ih; · rfl
+      rw [Nat.succ_eq_add_one, hc, sub_eq_add_neg, ← add_zero a₀]
+      refine' ih.add _
+      rw [SModEq.zero, Ideal.neg_mem_iff]
+      refine' I.mul_mem_right _ _
+      rw [← SModEq.zero] at h₁ ⊢
+      exact (ih.eval f).trans h₁
+    have hf'c : ∀ n, IsUnit (f'.eval (c n)) := by
+      intro n
+      haveI := isLocalRingHom_of_le_jacobson_bot I (IsAdicComplete.le_jacobson_bot I)
+      apply isUnit_of_map_unit (Ideal.Quotient.mk I)
+      convert h₂ using 1
+      exact smodeq.def.mp ((hc_mod n).eval _)
+    have hfcI : ∀ n, f.eval (c n) ∈ I ^ (n + 1) :=
+      by
+      intro n
+      induction' n with n ih; · simpa only [pow_one]
+      simp only [Nat.succ_eq_add_one]
+      rw [← taylor_eval_sub (c n), hc]
+      simp only [sub_eq_add_neg, add_neg_cancel_comm]
+      rw [eval_eq_sum, sum_over_range' _ _ _ (lt_add_of_pos_right _ zero_lt_two), ←
+        Finset.sum_range_add_sum_Ico _ (Nat.le_add_left _ _)]
+      swap; · intro i; rw [MulZeroClass.zero_mul]
+      refine' Ideal.add_mem _ _ _
+      · simp only [Finset.sum_range_succ, taylor_coeff_one, mul_one, pow_one, taylor_coeff_zero,
+          mul_neg, Finset.sum_singleton, Finset.range_one, pow_zero]
+        rw [mul_left_comm, Ring.mul_inverse_cancel _ (hf'c n), mul_one, add_neg_self]
+        exact Ideal.zero_mem _
+      · refine' Submodule.sum_mem _ _; simp only [Finset.mem_Ico]
+        rintro i ⟨h2i, hi⟩
+        have aux : n + 2 ≤ i * (n + 1) := by trans 2 * (n + 1) <;> nlinarith only [h2i]
+        refine' Ideal.mul_mem_left _ _ (Ideal.pow_le_pow aux _)
+        rw [pow_mul']
+        refine' Ideal.pow_mem_pow ((Ideal.neg_mem_iff _).2 <| Ideal.mul_mem_right _ _ ih) _
+    -- we are now in the position to show that `c : ℕ → R` is a Cauchy sequence
+    have aux : ∀ m n, m ≤ n → c m ≡ c n [SMOD (I ^ m • ⊤ : Ideal R)] :=
+      by
+      intro m n hmn
+      rw [← Ideal.one_eq_top, Ideal.smul_eq_mul, mul_one]
+      obtain ⟨k, rfl⟩ := Nat.exists_eq_add_of_le hmn; clear hmn
+      induction' k with k ih; · rw [add_zero]
+      rw [Nat.succ_eq_add_one, ← add_assoc, hc, ← add_zero (c m), sub_eq_add_neg]
+      refine' ih.add _; symm
+      rw [SModEq.zero, Ideal.neg_mem_iff]
+      refine' Ideal.mul_mem_right _ _ (Ideal.pow_le_pow _ (hfcI _))
+      rw [add_assoc]; exact le_self_add
+    -- hence the sequence converges to some limit point `a`, which is the `a` we are looking for
+    obtain ⟨a, ha⟩ := IsPrecomplete.prec' c aux
+    refine' ⟨a, _, _⟩
+    · show f.is_root a
+      suffices ∀ n, f.eval a ≡ 0 [SMOD (I ^ n • ⊤ : Ideal R)] by exact IsHausdorff.haus' _ this
+      intro n; specialize ha n
+      rw [← Ideal.one_eq_top, Ideal.smul_eq_mul, mul_one] at ha ⊢
+      refine' (ha.symm.eval f).trans _
+      rw [SModEq.zero]
+      exact Ideal.pow_le_pow le_self_add (hfcI _)
+    · show a - a₀ ∈ I
+      specialize ha 1
+      rw [hc, pow_one, ← Ideal.one_eq_top, Ideal.smul_eq_mul, mul_one, sub_eq_add_neg] at ha 
+      rw [← SModEq.sub_mem, ← add_zero a₀]
+      refine' ha.symm.trans (smodeq.rfl.add _)
+      rw [SModEq.zero, Ideal.neg_mem_iff]
+      exact Ideal.mul_mem_right _ _ h₁
 #align is_adic_complete.henselian_ring IsAdicComplete.henselianRing
 -/

61db041a

bump to nightly-2023-06-01-16

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

b9c87c70

Diff

@@ -81,14 +81,14 @@ theorem isLocalRingHom_of_le_jacobson_bot {R : Type _} [CommRing R] (I : Ideal R
     obtain ⟨b, hb⟩ := h
     obtain ⟨b, rfl⟩ := Ideal.Quotient.mk_surjective b
     use Ideal.Quotient.mk _ b
-    rw [← (Ideal.Quotient.mk _).map_one, ← (Ideal.Quotient.mk _).map_mul, Ideal.Quotient.eq] at hb⊢
+    rw [← (Ideal.Quotient.mk _).map_one, ← (Ideal.Quotient.mk _).map_mul, Ideal.Quotient.eq] at hb ⊢
     exact h hb
   obtain ⟨⟨x, y, h1, h2⟩, rfl : x = _⟩ := this
   obtain ⟨y, rfl⟩ := Ideal.Quotient.mk_surjective y
   rw [← (Ideal.Quotient.mk _).map_mul, ← (Ideal.Quotient.mk _).map_one, Ideal.Quotient.eq,
-    Ideal.mem_jacobson_bot] at h1 h2
+    Ideal.mem_jacobson_bot] at h1 h2 
   specialize h1 1
-  simp at h1
+  simp at h1 
   exact h1.1
 #align is_local_ring_hom_of_le_jacobson_bot isLocalRingHom_of_le_jacobson_bot
 
@@ -151,21 +151,21 @@ theorem HenselianLocalRing.TFAE (R : Type u) [CommRing R] [LocalRing R] :
     specialize H f hf (residue R a₀)
     have aux := flip mem_nonunits_iff.mp h₂
     simp only [aeval_def, residue_field.algebra_map_eq, eval₂_at_apply, ←
-      Ideal.Quotient.eq_zero_iff_mem, ← LocalRing.mem_maximalIdeal] at H h₁ aux
+      Ideal.Quotient.eq_zero_iff_mem, ← LocalRing.mem_maximalIdeal] at H h₁ aux 
     obtain ⟨a, ha₁, ha₂⟩ := H h₁ aux
     refine' ⟨a, ha₁, _⟩
     rw [← Ideal.Quotient.eq_zero_iff_mem]
-    rwa [← sub_eq_zero, ← RingHom.map_sub] at ha₂
+    rwa [← sub_eq_zero, ← RingHom.map_sub] at ha₂ 
   tfae_have _1_3 : 1 → 3
   · intro hR K _K φ hφ f hf a₀ h₁ h₂
     obtain ⟨a₀, rfl⟩ := hφ a₀
     have H := HenselianLocalRing.is_henselian f hf a₀
-    simp only [← ker_eq_maximal_ideal φ hφ, eval₂_at_apply, φ.mem_ker] at H h₁ h₂
+    simp only [← ker_eq_maximal_ideal φ hφ, eval₂_at_apply, φ.mem_ker] at H h₁ h₂ 
     obtain ⟨a, ha₁, ha₂⟩ := H h₁ _
-    · refine' ⟨a, ha₁, _⟩; rwa [φ.map_sub, sub_eq_zero] at ha₂
+    · refine' ⟨a, ha₁, _⟩; rwa [φ.map_sub, sub_eq_zero] at ha₂ 
     · contrapose! h₂
       rwa [← mem_nonunits_iff, ← LocalRing.mem_maximalIdeal, ← LocalRing.ker_eq_maximalIdeal φ hφ,
-        φ.mem_ker] at h₂
+        φ.mem_ker] at h₂ 
   tfae_finish
 #align henselian_local_ring.tfae HenselianLocalRing.TFAE
 
@@ -176,7 +176,7 @@ instance (R : Type _) [CommRing R] [hR : HenselianLocalRing R] : HenselianRing R
     intro f hf a₀ h₁ h₂
     refine' HenselianLocalRing.is_henselian f hf a₀ h₁ _
     contrapose! h₂
-    rw [← mem_nonunits_iff, ← LocalRing.mem_maximalIdeal, ← Ideal.Quotient.eq_zero_iff_mem] at h₂
+    rw [← mem_nonunits_iff, ← LocalRing.mem_maximalIdeal, ← Ideal.Quotient.eq_zero_iff_mem] at h₂ 
     rw [h₂]
     exact not_isUnit_zero
 
@@ -207,7 +207,7 @@ instance (priority := 100) IsAdicComplete.henselianRing (R : Type _) [CommRing R
         refine' ih.add _
         rw [SModEq.zero, Ideal.neg_mem_iff]
         refine' I.mul_mem_right _ _
-        rw [← SModEq.zero] at h₁⊢
+        rw [← SModEq.zero] at h₁ ⊢
         exact (ih.eval f).trans h₁
       have hf'c : ∀ n, IsUnit (f'.eval (c n)) := by
         intro n
@@ -254,13 +254,13 @@ instance (priority := 100) IsAdicComplete.henselianRing (R : Type _) [CommRing R
       · show f.is_root a
         suffices ∀ n, f.eval a ≡ 0 [SMOD (I ^ n • ⊤ : Ideal R)] by exact IsHausdorff.haus' _ this
         intro n; specialize ha n
-        rw [← Ideal.one_eq_top, Ideal.smul_eq_mul, mul_one] at ha⊢
+        rw [← Ideal.one_eq_top, Ideal.smul_eq_mul, mul_one] at ha ⊢
         refine' (ha.symm.eval f).trans _
         rw [SModEq.zero]
         exact Ideal.pow_le_pow le_self_add (hfcI _)
       · show a - a₀ ∈ I
         specialize ha 1
-        rw [hc, pow_one, ← Ideal.one_eq_top, Ideal.smul_eq_mul, mul_one, sub_eq_add_neg] at ha
+        rw [hc, pow_one, ← Ideal.one_eq_top, Ideal.smul_eq_mul, mul_one, sub_eq_add_neg] at ha 
         rw [← SModEq.sub_mem, ← add_zero a₀]
         refine' ha.symm.trans (smodeq.rfl.add _)
         rw [SModEq.zero, Ideal.neg_mem_iff]

61db041a

bump to nightly-2023-06-01-04

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

4d9eaa85

Diff

@@ -135,7 +135,6 @@ instance (priority := 100) Field.henselian (K : Type _) [Field K] : HenselianLoc
 #align field.henselian Field.henselian
 -/
 
-#print HenselianLocalRing.TFAE /-
 theorem HenselianLocalRing.TFAE (R : Type u) [CommRing R] [LocalRing R] :
     TFAE
       [HenselianLocalRing R,
@@ -169,7 +168,6 @@ theorem HenselianLocalRing.TFAE (R : Type u) [CommRing R] [LocalRing R] :
         φ.mem_ker] at h₂
   tfae_finish
 #align henselian_local_ring.tfae HenselianLocalRing.TFAE
--/
 
 instance (R : Type _) [CommRing R] [hR : HenselianLocalRing R] : HenselianRing R (maximalIdeal R)
     where

61db041a

bump to nightly-2023-05-28-18

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

8d353152

Diff

@@ -66,7 +66,7 @@ noncomputable section
 
 universe u v
 
-open BigOperators Polynomial
+open scoped BigOperators Polynomial
 
 open LocalRing Polynomial Function

61db041a

bump to nightly-2023-05-28-06

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

ba5d8b97

Diff

@@ -70,12 +70,6 @@ open BigOperators Polynomial
 
 open LocalRing Polynomial Function
 
-/- warning: is_local_ring_hom_of_le_jacobson_bot -> isLocalRingHom_of_le_jacobson_bot is a dubious translation:
-lean 3 declaration is
-  forall {R : Type.{u1}} [_inst_1 : CommRing.{u1} R] (I : Ideal.{u1} R (Ring.toSemiring.{u1} R (CommRing.toRing.{u1} R _inst_1))), (LE.le.{u1} (Ideal.{u1} R (Ring.toSemiring.{u1} R (CommRing.toRing.{u1} R _inst_1))) (Preorder.toHasLe.{u1} (Ideal.{u1} R (Ring.toSemiring.{u1} R (CommRing.toRing.{u1} R _inst_1))) (PartialOrder.toPreorder.{u1} (Ideal.{u1} R (Ring.toSemiring.{u1} R (CommRing.toRing.{u1} R _inst_1))) (CompleteSemilatticeInf.toPartialOrder.{u1} (Ideal.{u1} R (Ring.toSemiring.{u1} R (CommRing.toRing.{u1} R _inst_1))) (CompleteLattice.toCompleteSemilatticeInf.{u1} (Ideal.{u1} R (Ring.toSemiring.{u1} R (CommRing.toRing.{u1} R _inst_1))) (Submodule.completeLattice.{u1, u1} R R (Ring.toSemiring.{u1} R (CommRing.toRing.{u1} R _inst_1)) (NonUnitalNonAssocSemiring.toAddCommMonoid.{u1} R (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u1} R (Semiring.toNonAssocSemiring.{u1} R (Ring.toSemiring.{u1} R (CommRing.toRing.{u1} R _inst_1))))) (Semiring.toModule.{u1} R (Ring.toSemiring.{u1} R (CommRing.toRing.{u1} R _inst_1)))))))) I (Ideal.jacobson.{u1} R (CommRing.toRing.{u1} R _inst_1) (Bot.bot.{u1} (Ideal.{u1} R (Ring.toSemiring.{u1} R (CommRing.toRing.{u1} R _inst_1))) (Submodule.hasBot.{u1, u1} R R (Ring.toSemiring.{u1} R (CommRing.toRing.{u1} R _inst_1)) (NonUnitalNonAssocSemiring.toAddCommMonoid.{u1} R (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u1} R (Semiring.toNonAssocSemiring.{u1} R (Ring.toSemiring.{u1} R (CommRing.toRing.{u1} R _inst_1))))) (Semiring.toModule.{u1} R (Ring.toSemiring.{u1} R (CommRing.toRing.{u1} R _inst_1))))))) -> (IsLocalRingHom.{u1, u1} R (HasQuotient.Quotient.{u1, u1} R (Ideal.{u1} R (Ring.toSemiring.{u1} R (CommRing.toRing.{u1} R _inst_1))) (Ideal.hasQuotient.{u1} R _inst_1) I) (Ring.toSemiring.{u1} R (CommRing.toRing.{u1} R _inst_1)) (Ring.toSemiring.{u1} (HasQuotient.Quotient.{u1, u1} R (Ideal.{u1} R (Ring.toSemiring.{u1} R (CommRing.toRing.{u1} R _inst_1))) (Ideal.hasQuotient.{u1} R _inst_1) I) (CommRing.toRing.{u1} (HasQuotient.Quotient.{u1, u1} R (Ideal.{u1} R (Ring.toSemiring.{u1} R (CommRing.toRing.{u1} R _inst_1))) (Ideal.hasQuotient.{u1} R _inst_1) I) (Ideal.Quotient.commRing.{u1} R _inst_1 I))) (Ideal.Quotient.mk.{u1} R _inst_1 I))
-but is expected to have type
-  forall {R : Type.{u1}} [_inst_1 : CommRing.{u1} R] (I : Ideal.{u1} R (CommSemiring.toSemiring.{u1} R (CommRing.toCommSemiring.{u1} R _inst_1))), (LE.le.{u1} (Ideal.{u1} R (CommSemiring.toSemiring.{u1} R (CommRing.toCommSemiring.{u1} R _inst_1))) (Preorder.toLE.{u1} (Ideal.{u1} R (CommSemiring.toSemiring.{u1} R (CommRing.toCommSemiring.{u1} R _inst_1))) (PartialOrder.toPreorder.{u1} (Ideal.{u1} R (CommSemiring.toSemiring.{u1} R (CommRing.toCommSemiring.{u1} R _inst_1))) (OmegaCompletePartialOrder.toPartialOrder.{u1} (Ideal.{u1} R (CommSemiring.toSemiring.{u1} R (CommRing.toCommSemiring.{u1} R _inst_1))) (CompleteLattice.instOmegaCompletePartialOrder.{u1} (Ideal.{u1} R (CommSemiring.toSemiring.{u1} R (CommRing.toCommSemiring.{u1} R _inst_1))) (Submodule.completeLattice.{u1, u1} R R (CommSemiring.toSemiring.{u1} R (CommRing.toCommSemiring.{u1} R _inst_1)) (NonUnitalNonAssocSemiring.toAddCommMonoid.{u1} R (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u1} R (Semiring.toNonAssocSemiring.{u1} R (CommSemiring.toSemiring.{u1} R (CommRing.toCommSemiring.{u1} R _inst_1))))) (Semiring.toModule.{u1} R (CommSemiring.toSemiring.{u1} R (CommRing.toCommSemiring.{u1} R _inst_1)))))))) I (Ideal.jacobson.{u1} R (CommRing.toRing.{u1} R _inst_1) (Bot.bot.{u1} (Ideal.{u1} R (Ring.toSemiring.{u1} R (CommRing.toRing.{u1} R _inst_1))) (Submodule.instBotSubmodule.{u1, u1} R R (Ring.toSemiring.{u1} R (CommRing.toRing.{u1} R _inst_1)) (NonUnitalNonAssocSemiring.toAddCommMonoid.{u1} R (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u1} R (Semiring.toNonAssocSemiring.{u1} R (Ring.toSemiring.{u1} R (CommRing.toRing.{u1} R _inst_1))))) (Semiring.toModule.{u1} R (Ring.toSemiring.{u1} R (CommRing.toRing.{u1} R _inst_1))))))) -> (IsLocalRingHom.{u1, u1} R (HasQuotient.Quotient.{u1, u1} R (Ideal.{u1} R (CommSemiring.toSemiring.{u1} R (CommRing.toCommSemiring.{u1} R _inst_1))) (Ideal.instHasQuotientIdealToSemiringToCommSemiring.{u1} R _inst_1) I) (CommSemiring.toSemiring.{u1} R (CommRing.toCommSemiring.{u1} R _inst_1)) (CommSemiring.toSemiring.{u1} (HasQuotient.Quotient.{u1, u1} R (Ideal.{u1} R (CommSemiring.toSemiring.{u1} R (CommRing.toCommSemiring.{u1} R _inst_1))) (Ideal.instHasQuotientIdealToSemiringToCommSemiring.{u1} R _inst_1) I) (CommRing.toCommSemiring.{u1} (HasQuotient.Quotient.{u1, u1} R (Ideal.{u1} R (CommSemiring.toSemiring.{u1} R (CommRing.toCommSemiring.{u1} R _inst_1))) (Ideal.instHasQuotientIdealToSemiringToCommSemiring.{u1} R _inst_1) I) (Ideal.Quotient.commRing.{u1} R _inst_1 I))) (Ideal.Quotient.mk.{u1} R _inst_1 I))
-Case conversion may be inaccurate. Consider using '#align is_local_ring_hom_of_le_jacobson_bot isLocalRingHom_of_le_jacobson_botₓ'. -/
 theorem isLocalRingHom_of_le_jacobson_bot {R : Type _} [CommRing R] (I : Ideal R)
     (h : I ≤ Ideal.jacobson ⊥) : IsLocalRingHom (Ideal.Quotient.mk I) :=
   by

61db041a

bump to nightly-2023-05-28-04

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

6797a637

Diff

@@ -152,13 +152,9 @@ theorem HenselianLocalRing.TFAE (R : Type u) [CommRing R] [LocalRing R] :
             (h₁ : f.eval₂ φ a₀ = 0) (h₂ : f.derivative.eval₂ φ a₀ ≠ 0),
             ∃ a : R, f.IsRoot a ∧ φ a = a₀] :=
   by
-  tfae_have _3_2 : 3 → 2;
-  · intro H
-    exact H (residue R) Ideal.Quotient.mk_surjective
+  tfae_have _3_2 : 3 → 2; · intro H; exact H (residue R) Ideal.Quotient.mk_surjective
   tfae_have _2_1 : 2 → 1
-  · intro H
-    constructor
-    intro f hf a₀ h₁ h₂
+  · intro H; constructor; intro f hf a₀ h₁ h₂
     specialize H f hf (residue R a₀)
     have aux := flip mem_nonunits_iff.mp h₂
     simp only [aeval_def, residue_field.algebra_map_eq, eval₂_at_apply, ←
@@ -173,8 +169,7 @@ theorem HenselianLocalRing.TFAE (R : Type u) [CommRing R] [LocalRing R] :
     have H := HenselianLocalRing.is_henselian f hf a₀
     simp only [← ker_eq_maximal_ideal φ hφ, eval₂_at_apply, φ.mem_ker] at H h₁ h₂
     obtain ⟨a, ha₁, ha₂⟩ := H h₁ _
-    · refine' ⟨a, ha₁, _⟩
-      rwa [φ.map_sub, sub_eq_zero] at ha₂
+    · refine' ⟨a, ha₁, _⟩; rwa [φ.map_sub, sub_eq_zero] at ha₂
     · contrapose! h₂
       rwa [← mem_nonunits_iff, ← LocalRing.mem_maximalIdeal, ← LocalRing.ker_eq_maximalIdeal φ hφ,
         φ.mem_ker] at h₂
@@ -184,10 +179,7 @@ theorem HenselianLocalRing.TFAE (R : Type u) [CommRing R] [LocalRing R] :
 
 instance (R : Type _) [CommRing R] [hR : HenselianLocalRing R] : HenselianRing R (maximalIdeal R)
     where
-  jac := by
-    rw [Ideal.jacobson, le_sInf_iff]
-    rintro I ⟨-, hI⟩
-    exact (eq_maximal_ideal hI).ge
+  jac := by rw [Ideal.jacobson, le_sInf_iff]; rintro I ⟨-, hI⟩; exact (eq_maximal_ideal hI).ge
   is_henselian := by
     intro f hf a₀ h₁ h₂
     refine' HenselianLocalRing.is_henselian f hf a₀ h₁ _
@@ -211,19 +203,14 @@ instance (priority := 100) IsAdicComplete.henselianRing (R : Type _) [CommRing R
       -- applying the function sending `b` to `b - f(b)/f'(b)` (Newton's method).
       -- Note that `f'.eval b` is a unit, because `b` has the same residue as `a₀` modulo `I`.
       let c : ℕ → R := fun n => Nat.recOn n a₀ fun _ b => b - f.eval b * Ring.inverse (f'.eval b)
-      have hc : ∀ n, c (n + 1) = c n - f.eval (c n) * Ring.inverse (f'.eval (c n)) :=
-        by
-        intro n
-        dsimp only [c, Nat.rec_add_one]
-        rfl
+      have hc : ∀ n, c (n + 1) = c n - f.eval (c n) * Ring.inverse (f'.eval (c n)) := by intro n;
+        dsimp only [c, Nat.rec_add_one]; rfl
       -- we now spend some time determining properties of the sequence `c : ℕ → R`
       -- `hc_mod`: for every `n`, we have `c n ≡ a₀ [SMOD I]`
       -- `hf'c`  : for every `n`, `f'.eval (c n)` is a unit
       -- `hfcI`  : for every `n`, `f.eval (c n)` is contained in `I ^ (n+1)`
       have hc_mod : ∀ n, c n ≡ a₀ [SMOD I] := by
-        intro n
-        induction' n with n ih
-        · rfl
+        intro n; induction' n with n ih; · rfl
         rw [Nat.succ_eq_add_one, hc, sub_eq_add_neg, ← add_zero a₀]
         refine' ih.add _
         rw [SModEq.zero, Ideal.neg_mem_iff]
@@ -239,23 +226,19 @@ instance (priority := 100) IsAdicComplete.henselianRing (R : Type _) [CommRing R
       have hfcI : ∀ n, f.eval (c n) ∈ I ^ (n + 1) :=
         by
         intro n
-        induction' n with n ih
-        · simpa only [pow_one]
+        induction' n with n ih; · simpa only [pow_one]
         simp only [Nat.succ_eq_add_one]
         rw [← taylor_eval_sub (c n), hc]
         simp only [sub_eq_add_neg, add_neg_cancel_comm]
         rw [eval_eq_sum, sum_over_range' _ _ _ (lt_add_of_pos_right _ zero_lt_two), ←
           Finset.sum_range_add_sum_Ico _ (Nat.le_add_left _ _)]
-        swap
-        · intro i
-          rw [MulZeroClass.zero_mul]
+        swap; · intro i; rw [MulZeroClass.zero_mul]
         refine' Ideal.add_mem _ _ _
         · simp only [Finset.sum_range_succ, taylor_coeff_one, mul_one, pow_one, taylor_coeff_zero,
             mul_neg, Finset.sum_singleton, Finset.range_one, pow_zero]
           rw [mul_left_comm, Ring.mul_inverse_cancel _ (hf'c n), mul_one, add_neg_self]
           exact Ideal.zero_mem _
-        · refine' Submodule.sum_mem _ _
-          simp only [Finset.mem_Ico]
+        · refine' Submodule.sum_mem _ _; simp only [Finset.mem_Ico]
           rintro i ⟨h2i, hi⟩
           have aux : n + 2 ≤ i * (n + 1) := by trans 2 * (n + 1) <;> nlinarith only [h2i]
           refine' Ideal.mul_mem_left _ _ (Ideal.pow_le_pow aux _)
@@ -266,24 +249,19 @@ instance (priority := 100) IsAdicComplete.henselianRing (R : Type _) [CommRing R
         by
         intro m n hmn
         rw [← Ideal.one_eq_top, Ideal.smul_eq_mul, mul_one]
-        obtain ⟨k, rfl⟩ := Nat.exists_eq_add_of_le hmn
-        clear hmn
-        induction' k with k ih
-        · rw [add_zero]
+        obtain ⟨k, rfl⟩ := Nat.exists_eq_add_of_le hmn; clear hmn
+        induction' k with k ih; · rw [add_zero]
         rw [Nat.succ_eq_add_one, ← add_assoc, hc, ← add_zero (c m), sub_eq_add_neg]
-        refine' ih.add _
-        symm
+        refine' ih.add _; symm
         rw [SModEq.zero, Ideal.neg_mem_iff]
         refine' Ideal.mul_mem_right _ _ (Ideal.pow_le_pow _ (hfcI _))
-        rw [add_assoc]
-        exact le_self_add
+        rw [add_assoc]; exact le_self_add
       -- hence the sequence converges to some limit point `a`, which is the `a` we are looking for
       obtain ⟨a, ha⟩ := IsPrecomplete.prec' c aux
       refine' ⟨a, _, _⟩
       · show f.is_root a
         suffices ∀ n, f.eval a ≡ 0 [SMOD (I ^ n • ⊤ : Ideal R)] by exact IsHausdorff.haus' _ this
-        intro n
-        specialize ha n
+        intro n; specialize ha n
         rw [← Ideal.one_eq_top, Ideal.smul_eq_mul, mul_one] at ha⊢
         refine' (ha.symm.eval f).trans _
         rw [SModEq.zero]

61db041a

bump to nightly-2023-05-25-04

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

2175c3c2

Diff

@@ -4,7 +4,7 @@ Released under Apache 2.0 license as described in the file LICENSE.
 Authors: Johan Commelin
 
 ! This file was ported from Lean 3 source module ring_theory.henselian
-! leanprover-community/mathlib commit d1accf4f9cddb3666c6e8e4da0ac2d19c4ed73f0
+! leanprover-community/mathlib commit 61db041ab8e4aaf8cb5c7dc10a7d4ff261997536
 ! Please do not edit these lines, except to modify the commit id
 ! if you have ported upstream changes.
 -/
@@ -15,6 +15,9 @@ import Mathbin.LinearAlgebra.AdicCompletion
 /-!
 # Henselian rings
 
+> THIS FILE IS SYNCHRONIZED WITH MATHLIB4.
+> Any changes to this file require a corresponding PR to mathlib4.
+
 In this file we set up the basic theory of Henselian (local) rings.
 A ring `R` is *Henselian* at an ideal `I` if the following conditions hold:
 * `I` is contained in the Jacobson radical of `R`

d1accf4f

bump to nightly-2023-05-23-12

mathlib commit https://github.com/leanprover-community/mathlib/commit/75e7fca56381d056096ce5d05e938f63a6567828

52e3d5e8

Diff

@@ -67,6 +67,12 @@ open BigOperators Polynomial
 
 open LocalRing Polynomial Function
 
+/- warning: is_local_ring_hom_of_le_jacobson_bot -> isLocalRingHom_of_le_jacobson_bot is a dubious translation:
+lean 3 declaration is
+  forall {R : Type.{u1}} [_inst_1 : CommRing.{u1} R] (I : Ideal.{u1} R (Ring.toSemiring.{u1} R (CommRing.toRing.{u1} R _inst_1))), (LE.le.{u1} (Ideal.{u1} R (Ring.toSemiring.{u1} R (CommRing.toRing.{u1} R _inst_1))) (Preorder.toHasLe.{u1} (Ideal.{u1} R (Ring.toSemiring.{u1} R (CommRing.toRing.{u1} R _inst_1))) (PartialOrder.toPreorder.{u1} (Ideal.{u1} R (Ring.toSemiring.{u1} R (CommRing.toRing.{u1} R _inst_1))) (CompleteSemilatticeInf.toPartialOrder.{u1} (Ideal.{u1} R (Ring.toSemiring.{u1} R (CommRing.toRing.{u1} R _inst_1))) (CompleteLattice.toCompleteSemilatticeInf.{u1} (Ideal.{u1} R (Ring.toSemiring.{u1} R (CommRing.toRing.{u1} R _inst_1))) (Submodule.completeLattice.{u1, u1} R R (Ring.toSemiring.{u1} R (CommRing.toRing.{u1} R _inst_1)) (NonUnitalNonAssocSemiring.toAddCommMonoid.{u1} R (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u1} R (Semiring.toNonAssocSemiring.{u1} R (Ring.toSemiring.{u1} R (CommRing.toRing.{u1} R _inst_1))))) (Semiring.toModule.{u1} R (Ring.toSemiring.{u1} R (CommRing.toRing.{u1} R _inst_1)))))))) I (Ideal.jacobson.{u1} R (CommRing.toRing.{u1} R _inst_1) (Bot.bot.{u1} (Ideal.{u1} R (Ring.toSemiring.{u1} R (CommRing.toRing.{u1} R _inst_1))) (Submodule.hasBot.{u1, u1} R R (Ring.toSemiring.{u1} R (CommRing.toRing.{u1} R _inst_1)) (NonUnitalNonAssocSemiring.toAddCommMonoid.{u1} R (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u1} R (Semiring.toNonAssocSemiring.{u1} R (Ring.toSemiring.{u1} R (CommRing.toRing.{u1} R _inst_1))))) (Semiring.toModule.{u1} R (Ring.toSemiring.{u1} R (CommRing.toRing.{u1} R _inst_1))))))) -> (IsLocalRingHom.{u1, u1} R (HasQuotient.Quotient.{u1, u1} R (Ideal.{u1} R (Ring.toSemiring.{u1} R (CommRing.toRing.{u1} R _inst_1))) (Ideal.hasQuotient.{u1} R _inst_1) I) (Ring.toSemiring.{u1} R (CommRing.toRing.{u1} R _inst_1)) (Ring.toSemiring.{u1} (HasQuotient.Quotient.{u1, u1} R (Ideal.{u1} R (Ring.toSemiring.{u1} R (CommRing.toRing.{u1} R _inst_1))) (Ideal.hasQuotient.{u1} R _inst_1) I) (CommRing.toRing.{u1} (HasQuotient.Quotient.{u1, u1} R (Ideal.{u1} R (Ring.toSemiring.{u1} R (CommRing.toRing.{u1} R _inst_1))) (Ideal.hasQuotient.{u1} R _inst_1) I) (Ideal.Quotient.commRing.{u1} R _inst_1 I))) (Ideal.Quotient.mk.{u1} R _inst_1 I))
+but is expected to have type
+  forall {R : Type.{u1}} [_inst_1 : CommRing.{u1} R] (I : Ideal.{u1} R (CommSemiring.toSemiring.{u1} R (CommRing.toCommSemiring.{u1} R _inst_1))), (LE.le.{u1} (Ideal.{u1} R (CommSemiring.toSemiring.{u1} R (CommRing.toCommSemiring.{u1} R _inst_1))) (Preorder.toLE.{u1} (Ideal.{u1} R (CommSemiring.toSemiring.{u1} R (CommRing.toCommSemiring.{u1} R _inst_1))) (PartialOrder.toPreorder.{u1} (Ideal.{u1} R (CommSemiring.toSemiring.{u1} R (CommRing.toCommSemiring.{u1} R _inst_1))) (OmegaCompletePartialOrder.toPartialOrder.{u1} (Ideal.{u1} R (CommSemiring.toSemiring.{u1} R (CommRing.toCommSemiring.{u1} R _inst_1))) (CompleteLattice.instOmegaCompletePartialOrder.{u1} (Ideal.{u1} R (CommSemiring.toSemiring.{u1} R (CommRing.toCommSemiring.{u1} R _inst_1))) (Submodule.completeLattice.{u1, u1} R R (CommSemiring.toSemiring.{u1} R (CommRing.toCommSemiring.{u1} R _inst_1)) (NonUnitalNonAssocSemiring.toAddCommMonoid.{u1} R (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u1} R (Semiring.toNonAssocSemiring.{u1} R (CommSemiring.toSemiring.{u1} R (CommRing.toCommSemiring.{u1} R _inst_1))))) (Semiring.toModule.{u1} R (CommSemiring.toSemiring.{u1} R (CommRing.toCommSemiring.{u1} R _inst_1)))))))) I (Ideal.jacobson.{u1} R (CommRing.toRing.{u1} R _inst_1) (Bot.bot.{u1} (Ideal.{u1} R (Ring.toSemiring.{u1} R (CommRing.toRing.{u1} R _inst_1))) (Submodule.instBotSubmodule.{u1, u1} R R (Ring.toSemiring.{u1} R (CommRing.toRing.{u1} R _inst_1)) (NonUnitalNonAssocSemiring.toAddCommMonoid.{u1} R (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u1} R (Semiring.toNonAssocSemiring.{u1} R (Ring.toSemiring.{u1} R (CommRing.toRing.{u1} R _inst_1))))) (Semiring.toModule.{u1} R (Ring.toSemiring.{u1} R (CommRing.toRing.{u1} R _inst_1))))))) -> (IsLocalRingHom.{u1, u1} R (HasQuotient.Quotient.{u1, u1} R (Ideal.{u1} R (CommSemiring.toSemiring.{u1} R (CommRing.toCommSemiring.{u1} R _inst_1))) (Ideal.instHasQuotientIdealToSemiringToCommSemiring.{u1} R _inst_1) I) (CommSemiring.toSemiring.{u1} R (CommRing.toCommSemiring.{u1} R _inst_1)) (CommSemiring.toSemiring.{u1} (HasQuotient.Quotient.{u1, u1} R (Ideal.{u1} R (CommSemiring.toSemiring.{u1} R (CommRing.toCommSemiring.{u1} R _inst_1))) (Ideal.instHasQuotientIdealToSemiringToCommSemiring.{u1} R _inst_1) I) (CommRing.toCommSemiring.{u1} (HasQuotient.Quotient.{u1, u1} R (Ideal.{u1} R (CommSemiring.toSemiring.{u1} R (CommRing.toCommSemiring.{u1} R _inst_1))) (Ideal.instHasQuotientIdealToSemiringToCommSemiring.{u1} R _inst_1) I) (Ideal.Quotient.commRing.{u1} R _inst_1 I))) (Ideal.Quotient.mk.{u1} R _inst_1 I))
+Case conversion may be inaccurate. Consider using '#align is_local_ring_hom_of_le_jacobson_bot isLocalRingHom_of_le_jacobson_botₓ'. -/
 theorem isLocalRingHom_of_le_jacobson_bot {R : Type _} [CommRing R] (I : Ideal R)
     (h : I ≤ Ideal.jacobson ⊥) : IsLocalRingHom (Ideal.Quotient.mk I) :=
   by
@@ -89,6 +95,7 @@ theorem isLocalRingHom_of_le_jacobson_bot {R : Type _} [CommRing R] (I : Ideal R
   exact h1.1
 #align is_local_ring_hom_of_le_jacobson_bot isLocalRingHom_of_le_jacobson_bot
 
+#print HenselianRing /-
 /-- A ring `R` is *Henselian* at an ideal `I` if the following condition holds:
 for every polynomial `f` over `R`, with a *simple* root `a₀` over the quotient ring `R/I`,
 there exists a lift `a : R` of `a₀` that is a root of `f`.
@@ -103,7 +110,9 @@ class HenselianRing (R : Type _) [CommRing R] (I : Ideal R) : Prop where
     ∀ (f : R[X]) (hf : f.Monic) (a₀ : R) (h₁ : f.eval a₀ ∈ I)
       (h₂ : IsUnit (Ideal.Quotient.mk I (f.derivative.eval a₀))), ∃ a : R, f.IsRoot a ∧ a - a₀ ∈ I
 #align henselian_ring HenselianRing
+-/
 
+#print HenselianLocalRing /-
 /-- A local ring `R` is *Henselian* if the following condition holds:
 for every polynomial `f` over `R`, with a *simple* root `a₀` over the residue field,
 there exists a lift `a : R` of `a₀` that is a root of `f`.
@@ -117,7 +126,9 @@ class HenselianLocalRing (R : Type _) [CommRing R] extends LocalRing R : Prop wh
     ∀ (f : R[X]) (hf : f.Monic) (a₀ : R) (h₁ : f.eval a₀ ∈ maximalIdeal R)
       (h₂ : IsUnit (f.derivative.eval a₀)), ∃ a : R, f.IsRoot a ∧ a - a₀ ∈ maximalIdeal R
 #align henselian_local_ring HenselianLocalRing
+-/
 
+#print Field.henselian /-
 -- see Note [lower instance priority]
 instance (priority := 100) Field.henselian (K : Type _) [Field K] : HenselianLocalRing K
     where is_henselian f hf a₀ h₁ h₂ :=
@@ -125,8 +136,10 @@ instance (priority := 100) Field.henselian (K : Type _) [Field K] : HenselianLoc
     refine' ⟨a₀, _, _⟩ <;> rwa [(maximal_ideal K).eq_bot_of_prime, Ideal.mem_bot] at *
     rw [sub_self]
 #align field.henselian Field.henselian
+-/
 
-theorem HenselianLocalRing.tFAE (R : Type u) [CommRing R] [LocalRing R] :
+#print HenselianLocalRing.TFAE /-
+theorem HenselianLocalRing.TFAE (R : Type u) [CommRing R] [LocalRing R] :
     TFAE
       [HenselianLocalRing R,
         ∀ (f : R[X]) (hf : f.Monic) (a₀ : ResidueField R) (h₁ : aeval a₀ f = 0)
@@ -163,7 +176,8 @@ theorem HenselianLocalRing.tFAE (R : Type u) [CommRing R] [LocalRing R] :
       rwa [← mem_nonunits_iff, ← LocalRing.mem_maximalIdeal, ← LocalRing.ker_eq_maximalIdeal φ hφ,
         φ.mem_ker] at h₂
   tfae_finish
-#align henselian_local_ring.tfae HenselianLocalRing.tFAE
+#align henselian_local_ring.tfae HenselianLocalRing.TFAE
+-/
 
 instance (R : Type _) [CommRing R] [hR : HenselianLocalRing R] : HenselianRing R (maximalIdeal R)
     where
@@ -179,6 +193,7 @@ instance (R : Type _) [CommRing R] [hR : HenselianLocalRing R] : HenselianRing R
     rw [h₂]
     exact not_isUnit_zero
 
+#print IsAdicComplete.henselianRing /-
 -- see Note [lower instance priority]
 /-- A ring `R` that is `I`-adically complete is Henselian at `I`. -/
 instance (priority := 100) IsAdicComplete.henselianRing (R : Type _) [CommRing R] (I : Ideal R)
@@ -278,4 +293,5 @@ instance (priority := 100) IsAdicComplete.henselianRing (R : Type _) [CommRing R
         rw [SModEq.zero, Ideal.neg_mem_iff]
         exact Ideal.mul_mem_right _ _ h₁
 #align is_adic_complete.henselian_ring IsAdicComplete.henselianRing
+-/

d1accf4f

bump to nightly-2023-05-14-08

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

d31da313

Diff

@@ -168,7 +168,7 @@ theorem HenselianLocalRing.tFAE (R : Type u) [CommRing R] [LocalRing R] :
 instance (R : Type _) [CommRing R] [hR : HenselianLocalRing R] : HenselianRing R (maximalIdeal R)
     where
   jac := by
-    rw [Ideal.jacobson, le_infₛ_iff]
+    rw [Ideal.jacobson, le_sInf_iff]
     rintro I ⟨-, hI⟩
     exact (eq_maximal_ideal hI).ge
   is_henselian := by

d1accf4f

bump to nightly-2023-03-13-18

mathlib commit https://github.com/leanprover-community/mathlib/commit/2af0836443b4cfb5feda0df0051acdb398304931

66e1e587

Diff

@@ -208,9 +208,9 @@ instance (priority := 100) IsAdicComplete.henselianRing (R : Type _) [CommRing R
         · rfl
         rw [Nat.succ_eq_add_one, hc, sub_eq_add_neg, ← add_zero a₀]
         refine' ih.add _
-        rw [Smodeq.zero, Ideal.neg_mem_iff]
+        rw [SModEq.zero, Ideal.neg_mem_iff]
         refine' I.mul_mem_right _ _
-        rw [← Smodeq.zero] at h₁⊢
+        rw [← SModEq.zero] at h₁⊢
         exact (ih.eval f).trans h₁
       have hf'c : ∀ n, IsUnit (f'.eval (c n)) := by
         intro n
@@ -255,7 +255,7 @@ instance (priority := 100) IsAdicComplete.henselianRing (R : Type _) [CommRing R
         rw [Nat.succ_eq_add_one, ← add_assoc, hc, ← add_zero (c m), sub_eq_add_neg]
         refine' ih.add _
         symm
-        rw [Smodeq.zero, Ideal.neg_mem_iff]
+        rw [SModEq.zero, Ideal.neg_mem_iff]
         refine' Ideal.mul_mem_right _ _ (Ideal.pow_le_pow _ (hfcI _))
         rw [add_assoc]
         exact le_self_add
@@ -268,14 +268,14 @@ instance (priority := 100) IsAdicComplete.henselianRing (R : Type _) [CommRing R
         specialize ha n
         rw [← Ideal.one_eq_top, Ideal.smul_eq_mul, mul_one] at ha⊢
         refine' (ha.symm.eval f).trans _
-        rw [Smodeq.zero]
+        rw [SModEq.zero]
         exact Ideal.pow_le_pow le_self_add (hfcI _)
       · show a - a₀ ∈ I
         specialize ha 1
         rw [hc, pow_one, ← Ideal.one_eq_top, Ideal.smul_eq_mul, mul_one, sub_eq_add_neg] at ha
-        rw [← Smodeq.sub_mem, ← add_zero a₀]
+        rw [← SModEq.sub_mem, ← add_zero a₀]
         refine' ha.symm.trans (smodeq.rfl.add _)
-        rw [Smodeq.zero, Ideal.neg_mem_iff]
+        rw [SModEq.zero, Ideal.neg_mem_iff]
         exact Ideal.mul_mem_right _ _ h₁
 #align is_adic_complete.henselian_ring IsAdicComplete.henselianRing

d1accf4f

bump to nightly-2023-03-11-16

mathlib commit https://github.com/leanprover-community/mathlib/commit/3180fab693e2cee3bff62675571264cb8778b212

cd44fb92

Diff

@@ -230,7 +230,7 @@ instance (priority := 100) IsAdicComplete.henselianRing (R : Type _) [CommRing R
           Finset.sum_range_add_sum_Ico _ (Nat.le_add_left _ _)]
         swap
         · intro i
-          rw [zero_mul]
+          rw [MulZeroClass.zero_mul]
         refine' Ideal.add_mem _ _ _
         · simp only [Finset.sum_range_succ, taylor_coeff_one, mul_one, pow_one, taylor_coeff_zero,
             mul_neg, Finset.sum_singleton, Finset.range_one, pow_zero]

d1accf4f

bump to nightly-2023-02-21-16

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

1107b979

Changes in mathlib4

mathlib3

mathlib4

d1accf4f

chore(AdicCompletion): move to RingTheory and make folder (#12511)

Move AdicCompletion from LinearAlgebra into its own folder in RingTheory as it seems to fit better there.

283ea7e3

Diff

@@ -5,7 +5,7 @@ Authors: Johan Commelin
 -/
 import Mathlib.Algebra.Polynomial.Taylor
 import Mathlib.RingTheory.Ideal.LocalRing
-import Mathlib.LinearAlgebra.AdicCompletion
+import Mathlib.RingTheory.AdicCompletion.Basic
 
 #align_import ring_theory.henselian from "leanprover-community/mathlib"@"d1accf4f9cddb3666c6e8e4da0ac2d19c4ed73f0"

d1accf4f

chore: rename IsRoot.definition back to IsRoot.def (#11999)

Co-authored-by: Scott Morrison <scott.morrison@gmail.com>

1f25ef62

Diff

@@ -204,7 +204,7 @@ instance (priority := 100) IsAdicComplete.henselianRing (R : Type*) [CommRing R]
         haveI := isLocalRingHom_of_le_jacobson_bot I (IsAdicComplete.le_jacobson_bot I)
         apply isUnit_of_map_unit (Ideal.Quotient.mk I)
         convert h₂ using 1
-        exact SModEq.def'.mp ((hc_mod n).eval _)
+        exact SModEq.def.mp ((hc_mod n).eval _)
       have hfcI : ∀ n, f.eval (c n) ∈ I ^ (n + 1) := by
         intro n
         induction' n with n ih

d1accf4f

move(Polynomial): Move out of Data (#11751)

Polynomial and MvPolynomial are algebraic objects, hence should be under Algebra (or at least not under Data)

56e439ec

Diff

@@ -3,7 +3,7 @@ Copyright (c) 2021 Johan Commelin. All rights reserved.
 Released under Apache 2.0 license as described in the file LICENSE.
 Authors: Johan Commelin
 -/
-import Mathlib.Data.Polynomial.Taylor
+import Mathlib.Algebra.Polynomial.Taylor
 import Mathlib.RingTheory.Ideal.LocalRing
 import Mathlib.LinearAlgebra.AdicCompletion

d1accf4f

chore: rename away from 'def' (#11548)

This will become an error in 2024-03-16 nightly, possibly not permanently.

Co-authored-by: Scott Morrison <scott@tqft.net>

b505e8e9

Diff

@@ -204,7 +204,7 @@ instance (priority := 100) IsAdicComplete.henselianRing (R : Type*) [CommRing R]
         haveI := isLocalRingHom_of_le_jacobson_bot I (IsAdicComplete.le_jacobson_bot I)
         apply isUnit_of_map_unit (Ideal.Quotient.mk I)
         convert h₂ using 1
-        exact SModEq.def.mp ((hc_mod n).eval _)
+        exact SModEq.def'.mp ((hc_mod n).eval _)
       have hfcI : ∀ n, f.eval (c n) ∈ I ^ (n + 1) := by
         intro n
         induction' n with n ih

d1accf4f

chore: more backporting of simp changes from #10995 (#11001)

Co-authored-by: Patrick Massot <patrickmassot@free.fr> Co-authored-by: Scott Morrison <scott.morrison@gmail.com>

d9589c14

Diff

@@ -184,7 +184,7 @@ instance (priority := 100) IsAdicComplete.henselianRing (R : Type*) [CommRing R]
       let c : ℕ → R := fun n => Nat.recOn n a₀ fun _ b => b - f.eval b * Ring.inverse (f'.eval b)
       have hc : ∀ n, c (n + 1) = c n - f.eval (c n) * Ring.inverse (f'.eval (c n)) := by
         intro n
-        simp only [Nat.rec_add_one]
+        simp only [c, Nat.rec_add_one]
       -- we now spend some time determining properties of the sequence `c : ℕ → R`
       -- `hc_mod`: for every `n`, we have `c n ≡ a₀ [SMOD I]`
       -- `hf'c`  : for every `n`, `f'.eval (c n)` is a unit

d1accf4f

chore: remove terminal, terminal refines (#10762)

I replaced a few "terminal" refine/refine's with exact.

The strategy was very simple-minded: essentially any refine whose following line had smaller indentation got replaced by exact and then I cleaned up the mess.

This PR certainly leaves some further terminal refines, but maybe the current change is beneficial.

ea36aa7d

Diff

@@ -228,7 +228,7 @@ instance (priority := 100) IsAdicComplete.henselianRing (R : Type*) [CommRing R]
           have aux : n + 2 ≤ i * (n + 1) := by trans 2 * (n + 1) <;> nlinarith only [h2i]
           refine' Ideal.mul_mem_left _ _ (Ideal.pow_le_pow_right aux _)
           rw [pow_mul']
-          refine' Ideal.pow_mem_pow ((Ideal.neg_mem_iff _).2 <| Ideal.mul_mem_right _ _ ih) _
+          exact Ideal.pow_mem_pow ((Ideal.neg_mem_iff _).2 <| Ideal.mul_mem_right _ _ ih) _
       -- we are now in the position to show that `c : ℕ → R` is a Cauchy sequence
       have aux : ∀ m n, m ≤ n → c m ≡ c n [SMOD (I ^ m • ⊤ : Ideal R)] := by
         intro m n hmn

d1accf4f

chore(*): golf, mostly dropping unused haves (#9292)

aede3305

Diff

@@ -121,16 +121,15 @@ instance (priority := 100) Field.henselian (K : Type*) [Field K] : HenselianLoca
 theorem HenselianLocalRing.TFAE (R : Type u) [CommRing R] [LocalRing R] :
     TFAE
       [HenselianLocalRing R,
-        ∀ (f : R[X]) (_ : f.Monic) (a₀ : ResidueField R) (_ : aeval a₀ f = 0)
-          (_ : aeval a₀ (derivative f) ≠ 0), ∃ a : R, f.IsRoot a ∧ residue R a = a₀,
+        ∀ f : R[X], f.Monic → ∀ a₀ : ResidueField R, aeval a₀ f = 0 →
+          aeval a₀ (derivative f) ≠ 0 → ∃ a : R, f.IsRoot a ∧ residue R a = a₀,
         ∀ {K : Type u} [Field K],
-          ∀ (φ : R →+* K) (_ : Surjective φ) (f : R[X]) (_ : f.Monic) (a₀ : K)
-            (_ : f.eval₂ φ a₀ = 0) (_ : f.derivative.eval₂ φ a₀ ≠ 0),
-            ∃ a : R, f.IsRoot a ∧ φ a = a₀] := by
-  tfae_have _3_2 : 3 → 2;
+          ∀ (φ : R →+* K), Surjective φ → ∀ f : R[X], f.Monic → ∀ a₀ : K,
+            f.eval₂ φ a₀ = 0 → f.derivative.eval₂ φ a₀ ≠ 0 → ∃ a : R, f.IsRoot a ∧ φ a = a₀] := by
+  tfae_have 3 → 2
   · intro H
     exact H (residue R) Ideal.Quotient.mk_surjective
-  tfae_have _2_1 : 2 → 1
+  tfae_have 2 → 1
   · intro H
     constructor
     intro f hf a₀ h₁ h₂
@@ -142,7 +141,7 @@ theorem HenselianLocalRing.TFAE (R : Type u) [CommRing R] [LocalRing R] :
     refine' ⟨a, ha₁, _⟩
     rw [← Ideal.Quotient.eq_zero_iff_mem]
     rwa [← sub_eq_zero, ← RingHom.map_sub] at ha₂
-  tfae_have _1_3 : 1 → 3
+  tfae_have 1 → 3
   · intro hR K _K φ hφ f hf a₀ h₁ h₂
     obtain ⟨a₀, rfl⟩ := hφ a₀
     have H := HenselianLocalRing.is_henselian f hf a₀

d1accf4f

chore: Rename pow monotonicity lemmas (#9095)

The names for lemmas about monotonicity of (a ^ ·) and (· ^ n) were a mess. This PR tidies up everything related by following the naming convention for (a * ·) and (· * b). Namely, (a ^ ·) is pow_right and (· ^ n) is pow_left in lemma names. All lemma renames follow the corresponding multiplication lemma names closely.

Renames

`Algebra.GroupPower.Order`

pow_mono → pow_right_mono
pow_le_pow → pow_le_pow_right
pow_le_pow_of_le_left → pow_le_pow_left
pow_lt_pow_of_lt_left → pow_lt_pow_left
strictMonoOn_pow → pow_left_strictMonoOn
pow_strictMono_right → pow_right_strictMono
pow_lt_pow → pow_lt_pow_right
pow_lt_pow_iff → pow_lt_pow_iff_right
pow_le_pow_iff → pow_le_pow_iff_right
self_lt_pow → lt_self_pow
strictAnti_pow → pow_right_strictAnti
pow_lt_pow_iff_of_lt_one → pow_lt_pow_iff_right_of_lt_one
pow_lt_pow_of_lt_one → pow_lt_pow_right_of_lt_one
lt_of_pow_lt_pow → lt_of_pow_lt_pow_left
le_of_pow_le_pow → le_of_pow_le_pow_left
pow_lt_pow₀ → pow_lt_pow_right₀

`Algebra.GroupPower.CovariantClass`

pow_le_pow_of_le_left' → pow_le_pow_left'
nsmul_le_nsmul_of_le_right → nsmul_le_nsmul_right
pow_lt_pow' → pow_lt_pow_right'
nsmul_lt_nsmul → nsmul_lt_nsmul_left
pow_strictMono_left → pow_right_strictMono'
nsmul_strictMono_right → nsmul_left_strictMono
StrictMono.pow_right' → StrictMono.pow_const
StrictMono.nsmul_left → StrictMono.const_nsmul
pow_strictMono_right' → pow_left_strictMono
nsmul_strictMono_left → nsmul_right_strictMono
Monotone.pow_right → Monotone.pow_const
Monotone.nsmul_left → Monotone.const_nsmul
lt_of_pow_lt_pow' → lt_of_pow_lt_pow_left'
lt_of_nsmul_lt_nsmul → lt_of_nsmul_lt_nsmul_right
pow_le_pow' → pow_le_pow_right'
nsmul_le_nsmul → nsmul_le_nsmul_left
pow_le_pow_of_le_one' → pow_le_pow_right_of_le_one'
nsmul_le_nsmul_of_nonpos → nsmul_le_nsmul_left_of_nonpos
le_of_pow_le_pow' → le_of_pow_le_pow_left'
le_of_nsmul_le_nsmul' → le_of_nsmul_le_nsmul_right'
pow_le_pow_iff' → pow_le_pow_iff_right'
nsmul_le_nsmul_iff → nsmul_le_nsmul_iff_left
pow_lt_pow_iff' → pow_lt_pow_iff_right'
nsmul_lt_nsmul_iff → nsmul_lt_nsmul_iff_left

`Data.Nat.Pow`

Nat.pow_lt_pow_of_lt_left → Nat.pow_lt_pow_left
Nat.pow_le_iff_le_left → Nat.pow_le_pow_iff_left
Nat.pow_lt_iff_lt_left → Nat.pow_lt_pow_iff_left

Lemmas added

pow_le_pow_iff_left
pow_lt_pow_iff_left
pow_right_injective
pow_right_inj
Nat.pow_le_pow_left to have the correct name since Nat.pow_le_pow_of_le_left is in Std.
Nat.pow_le_pow_right to have the correct name since Nat.pow_le_pow_of_le_right is in Std.

Lemmas removed

self_le_pow was a duplicate of le_self_pow.
Nat.pow_lt_pow_of_lt_right is defeq to pow_lt_pow_right.
Nat.pow_right_strictMono is defeq to pow_right_strictMono.
Nat.pow_le_iff_le_right is defeq to pow_le_pow_iff_right.
Nat.pow_lt_iff_lt_right is defeq to pow_lt_pow_iff_right.

Other changes

A bunch of proofs have been golfed.
Some lemma assumptions have been turned from 0 < n or 1 ≤ n to n ≠ 0.
A few Nat lemmas have been protected.
One docstring has been fixed.

d61c95e1

Diff

@@ -227,7 +227,7 @@ instance (priority := 100) IsAdicComplete.henselianRing (R : Type*) [CommRing R]
           simp only [Finset.mem_Ico]
           rintro i ⟨h2i, _⟩
           have aux : n + 2 ≤ i * (n + 1) := by trans 2 * (n + 1) <;> nlinarith only [h2i]
-          refine' Ideal.mul_mem_left _ _ (Ideal.pow_le_pow aux _)
+          refine' Ideal.mul_mem_left _ _ (Ideal.pow_le_pow_right aux _)
           rw [pow_mul']
           refine' Ideal.pow_mem_pow ((Ideal.neg_mem_iff _).2 <| Ideal.mul_mem_right _ _ ih) _
       -- we are now in the position to show that `c : ℕ → R` is a Cauchy sequence
@@ -242,7 +242,7 @@ instance (priority := 100) IsAdicComplete.henselianRing (R : Type*) [CommRing R]
         refine' ih.add _
         symm
         rw [SModEq.zero, Ideal.neg_mem_iff]
-        refine' Ideal.mul_mem_right _ _ (Ideal.pow_le_pow _ (hfcI _))
+        refine' Ideal.mul_mem_right _ _ (Ideal.pow_le_pow_right _ (hfcI _))
         rw [add_assoc]
         exact le_self_add
       -- hence the sequence converges to some limit point `a`, which is the `a` we are looking for
@@ -255,7 +255,7 @@ instance (priority := 100) IsAdicComplete.henselianRing (R : Type*) [CommRing R]
         rw [← Ideal.one_eq_top, Ideal.smul_eq_mul, mul_one] at ha ⊢
         refine' (ha.symm.eval f).trans _
         rw [SModEq.zero]
-        exact Ideal.pow_le_pow le_self_add (hfcI _)
+        exact Ideal.pow_le_pow_right le_self_add (hfcI _)
       · show a - a₀ ∈ I
         specialize ha 1
         rw [hc, pow_one, ← Ideal.one_eq_top, Ideal.smul_eq_mul, mul_one, sub_eq_add_neg] at ha

d1accf4f

chore: Remove nonterminal simp at (#7795)

Removes nonterminal uses of simp at. Replaces most of these with instances of simp? ... says.

Co-authored-by: Scott Morrison <scott.morrison@gmail.com> Co-authored-by: Mario Carneiro <di.gama@gmail.com>

4160b2aa

Diff

@@ -78,7 +78,7 @@ theorem isLocalRingHom_of_le_jacobson_bot {R : Type*} [CommRing R] (I : Ideal R)
   rw [← (Ideal.Quotient.mk _).map_mul, ← (Ideal.Quotient.mk _).map_one, Ideal.Quotient.eq,
     Ideal.mem_jacobson_bot] at h1 h2
   specialize h1 1
-  simp at h1
+  simp? at h1 says simp only [mul_one, sub_add_cancel, IsUnit.mul_iff] at h1
   exact h1.1
 #align is_local_ring_hom_of_le_jacobson_bot isLocalRingHom_of_le_jacobson_bot

d1accf4f

chore: cleanup some spaces (#7484)

Purely cosmetic PR.

c93575a3

Diff

@@ -122,7 +122,7 @@ theorem HenselianLocalRing.TFAE (R : Type u) [CommRing R] [LocalRing R] :
     TFAE
       [HenselianLocalRing R,
         ∀ (f : R[X]) (_ : f.Monic) (a₀ : ResidueField R) (_ : aeval a₀ f = 0)
-          (_ : aeval a₀ (derivative f )≠ 0), ∃ a : R, f.IsRoot a ∧ residue R a = a₀,
+          (_ : aeval a₀ (derivative f) ≠ 0), ∃ a : R, f.IsRoot a ∧ residue R a = a₀,
         ∀ {K : Type u} [Field K],
           ∀ (φ : R →+* K) (_ : Surjective φ) (f : R[X]) (_ : f.Monic) (a₀ : K)
             (_ : f.eval₂ φ a₀ = 0) (_ : f.derivative.eval₂ φ a₀ ≠ 0),

d1accf4f

chore: drop MulZeroClass. in mul_zero/zero_mul (#6682)

Search&replace MulZeroClass.mul_zero -> mul_zero, MulZeroClass.zero_mul -> zero_mul.

These were introduced by Mathport, as the full name of mul_zero is actually MulZeroClass.mul_zero (it's exported with the short name).

277dea95

Diff

@@ -216,7 +216,7 @@ instance (priority := 100) IsAdicComplete.henselianRing (R : Type*) [CommRing R]
           Finset.sum_range_add_sum_Ico _ (Nat.le_add_left _ _)]
         swap
         · intro i
-          rw [MulZeroClass.zero_mul]
+          rw [zero_mul]
         refine' Ideal.add_mem _ _ _
         · erw [Finset.sum_range_succ]
           rw [Finset.range_one, Finset.sum_singleton,

d1accf4f

chore: banish Type _ and Sort _ (#6499)

We remove all possible occurences of Type _ and Sort _ in favor of Type* and Sort*.

This has nice performance benefits.

32de3f67

Diff

@@ -62,7 +62,7 @@ universe u v
 
 open BigOperators Polynomial LocalRing Polynomial Function List
 
-theorem isLocalRingHom_of_le_jacobson_bot {R : Type _} [CommRing R] (I : Ideal R)
+theorem isLocalRingHom_of_le_jacobson_bot {R : Type*} [CommRing R] (I : Ideal R)
     (h : I ≤ Ideal.jacobson ⊥) : IsLocalRingHom (Ideal.Quotient.mk I) := by
   constructor
   intro a h
@@ -90,7 +90,7 @@ there exists a lift `a : R` of `a₀` that is a root of `f`.
 unit. Warning: if `R/I` is not a field then it is not enough to assume that `g` has a factorization
 into monic linear factors in which `X - b` shows up only once; for example `1` is not a simple root
 of `X^2-1` over `ℤ/4ℤ`.) -/
-class HenselianRing (R : Type _) [CommRing R] (I : Ideal R) : Prop where
+class HenselianRing (R : Type*) [CommRing R] (I : Ideal R) : Prop where
   jac : I ≤ Ideal.jacobson ⊥
   is_henselian :
     ∀ (f : R[X]) (_ : f.Monic) (a₀ : R) (_ : f.eval a₀ ∈ I)
@@ -105,14 +105,14 @@ there exists a lift `a : R` of `a₀` that is a root of `f`.
 
 In other words, `R` is local Henselian if it is Henselian at the ideal `I`,
 in the sense of `HenselianRing`. -/
-class HenselianLocalRing (R : Type _) [CommRing R] extends LocalRing R : Prop where
+class HenselianLocalRing (R : Type*) [CommRing R] extends LocalRing R : Prop where
   is_henselian :
     ∀ (f : R[X]) (_ : f.Monic) (a₀ : R) (_ : f.eval a₀ ∈ maximalIdeal R)
       (_ : IsUnit (f.derivative.eval a₀)), ∃ a : R, f.IsRoot a ∧ a - a₀ ∈ maximalIdeal R
 #align henselian_local_ring HenselianLocalRing
 
 -- see Note [lower instance priority]
-instance (priority := 100) Field.henselian (K : Type _) [Field K] : HenselianLocalRing K where
+instance (priority := 100) Field.henselian (K : Type*) [Field K] : HenselianLocalRing K where
   is_henselian f _ a₀ h₁ _ := by
     simp only [(maximalIdeal K).eq_bot_of_prime, Ideal.mem_bot] at h₁ ⊢
     exact ⟨a₀, h₁, sub_self _⟩
@@ -156,7 +156,7 @@ theorem HenselianLocalRing.TFAE (R : Type u) [CommRing R] [LocalRing R] :
   tfae_finish
 #align henselian_local_ring.tfae HenselianLocalRing.TFAE
 
-instance (R : Type _) [CommRing R] [hR : HenselianLocalRing R] : HenselianRing R (maximalIdeal R)
+instance (R : Type*) [CommRing R] [hR : HenselianLocalRing R] : HenselianRing R (maximalIdeal R)
     where
   jac := by
     rw [Ideal.jacobson, le_sInf_iff]
@@ -172,7 +172,7 @@ instance (R : Type _) [CommRing R] [hR : HenselianLocalRing R] : HenselianRing R
 
 -- see Note [lower instance priority]
 /-- A ring `R` that is `I`-adically complete is Henselian at `I`. -/
-instance (priority := 100) IsAdicComplete.henselianRing (R : Type _) [CommRing R] (I : Ideal R)
+instance (priority := 100) IsAdicComplete.henselianRing (R : Type*) [CommRing R] (I : Ideal R)
     [IsAdicComplete I R] : HenselianRing R I where
   jac := IsAdicComplete.le_jacobson_bot _
   is_henselian := by

d1accf4f

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,16 +2,13 @@
 Copyright (c) 2021 Johan Commelin. All rights reserved.
 Released under Apache 2.0 license as described in the file LICENSE.
 Authors: Johan Commelin
-
-! This file was ported from Lean 3 source module ring_theory.henselian
-! leanprover-community/mathlib commit d1accf4f9cddb3666c6e8e4da0ac2d19c4ed73f0
-! Please do not edit these lines, except to modify the commit id
-! if you have ported upstream changes.
 -/
 import Mathlib.Data.Polynomial.Taylor
 import Mathlib.RingTheory.Ideal.LocalRing
 import Mathlib.LinearAlgebra.AdicCompletion
 
+#align_import ring_theory.henselian from "leanprover-community/mathlib"@"d1accf4f9cddb3666c6e8e4da0ac2d19c4ed73f0"
+
 /-!
 # Henselian rings

d1accf4f

chore: clean up spacing around at and goals (#5387)

Changes are of the form

some_tactic at h⊢ -> some_tactic at h ⊢
some_tactic at h -> some_tactic at h

2a870323

Diff

@@ -74,7 +74,7 @@ theorem isLocalRingHom_of_le_jacobson_bot {R : Type _} [CommRing R] (I : Ideal R
     obtain ⟨b, hb⟩ := h
     obtain ⟨b, rfl⟩ := Ideal.Quotient.mk_surjective b
     use Ideal.Quotient.mk _ b
-    rw [← (Ideal.Quotient.mk _).map_one, ← (Ideal.Quotient.mk _).map_mul, Ideal.Quotient.eq] at hb⊢
+    rw [← (Ideal.Quotient.mk _).map_one, ← (Ideal.Quotient.mk _).map_mul, Ideal.Quotient.eq] at hb ⊢
     exact h hb
   obtain ⟨⟨x, y, h1, h2⟩, rfl : x = _⟩ := this
   obtain ⟨y, rfl⟩ := Ideal.Quotient.mk_surjective y
@@ -201,7 +201,7 @@ instance (priority := 100) IsAdicComplete.henselianRing (R : Type _) [CommRing R
         refine' ih.add _
         rw [SModEq.zero, Ideal.neg_mem_iff]
         refine' I.mul_mem_right _ _
-        rw [← SModEq.zero] at h₁⊢
+        rw [← SModEq.zero] at h₁ ⊢
         exact (ih.eval f).trans h₁
       have hf'c : ∀ n, IsUnit (f'.eval (c n)) := by
         intro n
@@ -255,7 +255,7 @@ instance (priority := 100) IsAdicComplete.henselianRing (R : Type _) [CommRing R
         suffices ∀ n, f.eval a ≡ 0 [SMOD (I ^ n • ⊤ : Ideal R)] by exact IsHausdorff.haus' _ this
         intro n
         specialize ha n
-        rw [← Ideal.one_eq_top, Ideal.smul_eq_mul, mul_one] at ha⊢
+        rw [← Ideal.one_eq_top, Ideal.smul_eq_mul, mul_one] at ha ⊢
         refine' (ha.symm.eval f).trans _
         rw [SModEq.zero]
         exact Ideal.pow_le_pow le_self_add (hfcI _)

d1accf4f

feat: port RingTheory.Henselian (#4260)

91d9c139

`ring_theory.henselian` ⟷ `Mathlib.RingTheory.Henselian`

Changes since the initial port

Changes in mathlib3

Changes in mathlib3port

Changes in mathlib4

Renames

`Algebra.GroupPower.Order`

`Algebra.GroupPower.CovariantClass`

`Data.Nat.Pow`

Lemmas added

Lemmas removed

Other changes

Dependencies 8 + 551

ring_theory.henselian ⟷ Mathlib.RingTheory.Henselian

Changes since the initial port

Changes in mathlib3

Changes in mathlib3port

Changes in mathlib4

Renames

Algebra.GroupPower.Order

Algebra.GroupPower.CovariantClass

Data.Nat.Pow

Lemmas added

Lemmas removed

Other changes

Dependencies 8 + 551

`ring_theory.henselian` ⟷ `Mathlib.RingTheory.Henselian`

`Algebra.GroupPower.Order`

`Algebra.GroupPower.CovariantClass`

`Data.Nat.Pow`