order.filter.germ ⟷ Mathlib.Order.Filter.Germ

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

@@ -604,11 +604,11 @@ section Ring
 
 variable {R : Type _}
 
-#print Filter.Germ.nontrivial /-
-instance nontrivial [Nontrivial R] [NeBot l] : Nontrivial (Germ l R) :=
+#print Filter.Germ.instNontrivial /-
+instance instNontrivial [Nontrivial R] [NeBot l] : Nontrivial (Germ l R) :=
   let ⟨x, y, h⟩ := exists_pair_ne R
   ⟨⟨↑x, ↑y, mt const_inj.1 h⟩⟩
-#align filter.germ.nontrivial Filter.Germ.nontrivial
+#align filter.germ.nontrivial Filter.Germ.instNontrivial
 -/
 
 instance [MulZeroClass R] : MulZeroClass (Germ l R)
@@ -679,14 +679,14 @@ instance [Monoid M] [MulAction M β] : MulAction M (Germ l β)
   one_smul f := inductionOn f fun f => by norm_cast; simp only [one_smul]
   hMul_smul c₁ c₂ f := inductionOn f fun f => by norm_cast; simp only [mul_smul]
 
-#print Filter.Germ.mulAction' /-
+#print Filter.Germ.instMulAction' /-
 @[to_additive]
-instance mulAction' [Monoid M] [MulAction M β] : MulAction (Germ l M) (Germ l β)
+instance instMulAction' [Monoid M] [MulAction M β] : MulAction (Germ l M) (Germ l β)
     where
   one_smul f := inductionOn f fun f => by simp only [← coe_one, ← coe_smul', one_smul]
   hMul_smul c₁ c₂ f := inductionOn₃ c₁ c₂ f fun c₁ c₂ f => by norm_cast; simp only [mul_smul]
-#align filter.germ.mul_action' Filter.Germ.mulAction'
-#align filter.germ.add_action' Filter.Germ.addAction'
+#align filter.germ.mul_action' Filter.Germ.instMulAction'
+#align filter.germ.add_action' Filter.Germ.instAddAction'
 -/
 
 instance [Monoid M] [AddMonoid N] [DistribMulAction M N] : DistribMulAction M (Germ l N)
@@ -694,13 +694,13 @@ instance [Monoid M] [AddMonoid N] [DistribMulAction M N] : DistribMulAction M (G
   smul_add c f g := inductionOn₂ f g fun f g => by norm_cast; simp only [smul_add]
   smul_zero c := by simp only [← coe_zero, ← coe_smul, smul_zero]
 
-#print Filter.Germ.distribMulAction' /-
-instance distribMulAction' [Monoid M] [AddMonoid N] [DistribMulAction M N] :
+#print Filter.Germ.instDistribMulAction' /-
+instance instDistribMulAction' [Monoid M] [AddMonoid N] [DistribMulAction M N] :
     DistribMulAction (Germ l M) (Germ l N)
     where
   smul_add c f g := inductionOn₃ c f g fun c f g => by norm_cast; simp only [smul_add]
   smul_zero c := inductionOn c fun c => by simp only [← coe_zero, ← coe_smul', smul_zero]
-#align filter.germ.distrib_mul_action' Filter.Germ.distribMulAction'
+#align filter.germ.distrib_mul_action' Filter.Germ.instDistribMulAction'
 -/
 
 instance [Semiring R] [AddCommMonoid M] [Module R M] : Module R (Germ l M)
@@ -708,12 +708,12 @@ instance [Semiring R] [AddCommMonoid M] [Module R M] : Module R (Germ l M)
   add_smul c₁ c₂ f := inductionOn f fun f => by norm_cast; simp only [add_smul]
   zero_smul f := inductionOn f fun f => by norm_cast; simp only [zero_smul, coe_zero]
 
-#print Filter.Germ.module' /-
-instance module' [Semiring R] [AddCommMonoid M] [Module R M] : Module (Germ l R) (Germ l M)
+#print Filter.Germ.instModule' /-
+instance instModule' [Semiring R] [AddCommMonoid M] [Module R M] : Module (Germ l R) (Germ l M)
     where
   add_smul c₁ c₂ f := inductionOn₃ c₁ c₂ f fun c₁ c₂ f => by norm_cast; simp only [add_smul]
   zero_smul f := inductionOn f fun f => by simp only [← coe_zero, ← coe_smul', zero_smul]
-#align filter.germ.module' Filter.Germ.module'
+#align filter.germ.module' Filter.Germ.instModule'
 -/
 
 end Module

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

@@ -3,8 +3,8 @@ Copyright (c) 2020 Yury G. Kudryashov. All rights reserved.
 Released under Apache 2.0 license as described in the file LICENSE.
 Authors: Yury G. Kudryashov, Abhimanyu Pallavi Sudhir
 -/
-import Mathbin.Order.Filter.Basic
-import Mathbin.Algebra.Module.Pi
+import Order.Filter.Basic
+import Algebra.Module.Pi
 
 #align_import order.filter.germ from "leanprover-community/mathlib"@"e97cf15cd1aec9bd5c193b2ffac5a6dc9118912b"
 

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

@@ -208,7 +208,7 @@ theorem coe_eq : (f : Germ l β) = g ↔ f =ᶠ[l] g :=
 #align filter.germ.coe_eq Filter.Germ.coe_eq
 -/
 
-alias coe_eq ↔ _ _root_.filter.eventually_eq.germ_eq
+alias ⟨_, _root_.filter.eventually_eq.germ_eq⟩ := coe_eq
 #align filter.eventually_eq.germ_eq Filter.EventuallyEq.germ_eq
 
 #print Filter.Germ.map /-
@@ -269,7 +269,7 @@ theorem coe_tendsto {f : α → β} {lb : Filter β} : (f : Germ l β).Tendsto l
 #align filter.germ.coe_tendsto Filter.Germ.coe_tendsto
 -/
 
-alias coe_tendsto ↔ _ _root_.filter.tendsto.germ_tendsto
+alias ⟨_, _root_.filter.tendsto.germ_tendsto⟩ := coe_tendsto
 #align filter.tendsto.germ_tendsto Filter.Tendsto.germ_tendsto
 
 #print Filter.Germ.compTendsto' /-

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

@@ -453,7 +453,7 @@ instance [CommSemigroup M] : CommSemigroup (Germ l M) :=
 instance [LeftCancelSemigroup M] : LeftCancelSemigroup (Germ l M) :=
   { Germ.semigroup with
     mul := (· * ·)
-    mul_left_cancel := fun f₁ f₂ f₃ =>
+    hMul_left_cancel := fun f₁ f₂ f₃ =>
       inductionOn₃ f₁ f₂ f₃ fun f₁ f₂ f₃ H =>
         coe_eq.2 ((coe_eq.1 H).mono fun x => mul_left_cancel) }
 
@@ -461,7 +461,7 @@ instance [LeftCancelSemigroup M] : LeftCancelSemigroup (Germ l M) :=
 instance [RightCancelSemigroup M] : RightCancelSemigroup (Germ l M) :=
   { Germ.semigroup with
     mul := (· * ·)
-    mul_right_cancel := fun f₁ f₂ f₃ =>
+    hMul_right_cancel := fun f₁ f₂ f₃ =>
       inductionOn₃ f₁ f₂ f₃ fun f₁ f₂ f₃ H =>
         coe_eq.2 <| (coe_eq.1 H).mono fun x => mul_right_cancel }
 
@@ -589,7 +589,7 @@ instance [Group G] : Group (Germ l G) :=
   { Germ.divInvMonoid with
     mul := (· * ·)
     one := 1
-    mul_left_inv := by rintro ⟨f⟩; exact congr_arg (Quot.mk _) (mul_left_inv f) }
+    hMul_left_inv := by rintro ⟨f⟩; exact congr_arg (Quot.mk _) (mul_left_inv f) }
 
 @[to_additive]
 instance [CommGroup G] : CommGroup (Germ l G) :=
@@ -677,14 +677,14 @@ theorem coe_smul' [SMul M β] (c : α → M) (f : α → β) : ↑(c • f) = (c
 instance [Monoid M] [MulAction M β] : MulAction M (Germ l β)
     where
   one_smul f := inductionOn f fun f => by norm_cast; simp only [one_smul]
-  mul_smul c₁ c₂ f := inductionOn f fun f => by norm_cast; simp only [mul_smul]
+  hMul_smul c₁ c₂ f := inductionOn f fun f => by norm_cast; simp only [mul_smul]
 
 #print Filter.Germ.mulAction' /-
 @[to_additive]
 instance mulAction' [Monoid M] [MulAction M β] : MulAction (Germ l M) (Germ l β)
     where
   one_smul f := inductionOn f fun f => by simp only [← coe_one, ← coe_smul', one_smul]
-  mul_smul c₁ c₂ f := inductionOn₃ c₁ c₂ f fun c₁ c₂ f => by norm_cast; simp only [mul_smul]
+  hMul_smul c₁ c₂ f := inductionOn₃ c₁ c₂ f fun c₁ c₂ f => by norm_cast; simp only [mul_smul]
 #align filter.germ.mul_action' Filter.Germ.mulAction'
 #align filter.germ.add_action' Filter.Germ.addAction'
 -/

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

@@ -657,12 +657,12 @@ section Module
 
 variable {M N R : Type _}
 
-#print Filter.Germ.hasSmul' /-
+#print Filter.Germ.instSMul' /-
 @[to_additive]
-instance hasSmul' [SMul M β] : SMul (Germ l M) (Germ l β) :=
+instance instSMul' [SMul M β] : SMul (Germ l M) (Germ l β) :=
   ⟨map₂ (· • ·)⟩
-#align filter.germ.has_smul' Filter.Germ.hasSmul'
-#align filter.germ.has_vadd' Filter.Germ.hasVadd'
+#align filter.germ.has_smul' Filter.Germ.instSMul'
+#align filter.germ.has_vadd' Filter.Germ.instVAdd'
 -/
 
 #print Filter.Germ.coe_smul' /-

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

@@ -2,15 +2,12 @@
 Copyright (c) 2020 Yury G. Kudryashov. All rights reserved.
 Released under Apache 2.0 license as described in the file LICENSE.
 Authors: Yury G. Kudryashov, Abhimanyu Pallavi Sudhir
-
-! This file was ported from Lean 3 source module order.filter.germ
-! leanprover-community/mathlib commit e97cf15cd1aec9bd5c193b2ffac5a6dc9118912b
-! Please do not edit these lines, except to modify the commit id
-! if you have ported upstream changes.
 -/
 import Mathbin.Order.Filter.Basic
 import Mathbin.Algebra.Module.Pi
 
+#align_import order.filter.germ from "leanprover-community/mathlib"@"e97cf15cd1aec9bd5c193b2ffac5a6dc9118912b"
+
 /-!
 # Germ of a function at a filter
 

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

@@ -64,18 +64,24 @@ namespace Filter
 
 variable {α β γ δ : Type _} {l : Filter α} {f g h : α → β}
 
+#print Filter.const_eventuallyEq' /-
 theorem const_eventuallyEq' [NeBot l] {a b : β} : (∀ᶠ x in l, a = b) ↔ a = b :=
   eventually_const
 #align filter.const_eventually_eq' Filter.const_eventuallyEq'
+-/
 
+#print Filter.const_eventuallyEq /-
 theorem const_eventuallyEq [NeBot l] {a b : β} : ((fun _ => a) =ᶠ[l] fun _ => b) ↔ a = b :=
   @const_eventuallyEq' _ _ _ _ a b
 #align filter.const_eventually_eq Filter.const_eventuallyEq
+-/
 
+#print Filter.EventuallyEq.comp_tendsto /-
 theorem EventuallyEq.comp_tendsto {f' : α → β} (H : f =ᶠ[l] f') {g : γ → α} {lc : Filter γ}
     (hg : Tendsto g lc l) : f ∘ g =ᶠ[lc] f' ∘ g :=
   hg.Eventually H
 #align filter.eventually_eq.comp_tendsto Filter.EventuallyEq.comp_tendsto
+-/
 
 #print Filter.germSetoid /-
 /-- Setoid used to define the space of germs. -/
@@ -134,33 +140,43 @@ instance : CoeTC (α → β) (Germ l β) :=
 instance : HasLiftT β (Germ l β) :=
   ⟨fun c => ↑fun x : α => c⟩
 
+#print Filter.Germ.quot_mk_eq_coe /-
 @[simp]
 theorem quot_mk_eq_coe (l : Filter α) (f : α → β) : Quot.mk _ f = (f : Germ l β) :=
   rfl
 #align filter.germ.quot_mk_eq_coe Filter.Germ.quot_mk_eq_coe
+-/
 
+#print Filter.Germ.mk'_eq_coe /-
 @[simp]
 theorem mk'_eq_coe (l : Filter α) (f : α → β) : Quotient.mk'' f = (f : Germ l β) :=
   rfl
 #align filter.germ.mk'_eq_coe Filter.Germ.mk'_eq_coe
+-/
 
+#print Filter.Germ.inductionOn /-
 @[elab_as_elim]
 theorem inductionOn (f : Germ l β) {p : Germ l β → Prop} (h : ∀ f : α → β, p f) : p f :=
   Quotient.inductionOn' f h
 #align filter.germ.induction_on Filter.Germ.inductionOn
+-/
 
+#print Filter.Germ.inductionOn₂ /-
 @[elab_as_elim]
 theorem inductionOn₂ (f : Germ l β) (g : Germ l γ) {p : Germ l β → Germ l γ → Prop}
     (h : ∀ (f : α → β) (g : α → γ), p f g) : p f g :=
   Quotient.inductionOn₂' f g h
 #align filter.germ.induction_on₂ Filter.Germ.inductionOn₂
+-/
 
+#print Filter.Germ.inductionOn₃ /-
 @[elab_as_elim]
 theorem inductionOn₃ (f : Germ l β) (g : Germ l γ) (h : Germ l δ)
     {p : Germ l β → Germ l γ → Germ l δ → Prop}
     (H : ∀ (f : α → β) (g : α → γ) (h : α → δ), p f g h) : p f g h :=
   Quotient.inductionOn₃' f g h H
 #align filter.germ.induction_on₃ Filter.Germ.inductionOn₃
+-/
 
 #print Filter.Germ.map' /-
 /-- Given a map `F : (α → β) → (γ → δ)` that sends functions eventually equal at `l` to functions
@@ -180,16 +196,20 @@ def liftOn {γ : Sort _} (f : Germ l β) (F : (α → β) → γ) (hF : (l.Event
 #align filter.germ.lift_on Filter.Germ.liftOn
 -/
 
+#print Filter.Germ.map'_coe /-
 @[simp]
 theorem map'_coe {lc : Filter γ} (F : (α → β) → γ → δ) (hF : (l.EventuallyEq ⇒ lc.EventuallyEq) F F)
     (f : α → β) : map' F hF f = F f :=
   rfl
 #align filter.germ.map'_coe Filter.Germ.map'_coe
+-/
 
+#print Filter.Germ.coe_eq /-
 @[simp, norm_cast]
 theorem coe_eq : (f : Germ l β) = g ↔ f =ᶠ[l] g :=
   Quotient.eq''
 #align filter.germ.coe_eq Filter.Germ.coe_eq
+-/
 
 alias coe_eq ↔ _ _root_.filter.eventually_eq.germ_eq
 #align filter.eventually_eq.germ_eq Filter.EventuallyEq.germ_eq
@@ -201,19 +221,25 @@ def map (op : β → γ) : Germ l β → Germ l γ :=
 #align filter.germ.map Filter.Germ.map
 -/
 
+#print Filter.Germ.map_coe /-
 @[simp]
 theorem map_coe (op : β → γ) (f : α → β) : map op (f : Germ l β) = op ∘ f :=
   rfl
 #align filter.germ.map_coe Filter.Germ.map_coe
+-/
 
+#print Filter.Germ.map_id /-
 @[simp]
 theorem map_id : map id = (id : Germ l β → Germ l β) := by ext ⟨f⟩; rfl
 #align filter.germ.map_id Filter.Germ.map_id
+-/
 
+#print Filter.Germ.map_map /-
 theorem map_map (op₁ : γ → δ) (op₂ : β → γ) (f : Germ l β) :
     map op₁ (map op₂ f) = map (op₁ ∘ op₂) f :=
   inductionOn f fun f => rfl
 #align filter.germ.map_map Filter.Germ.map_map
+-/
 
 #print Filter.Germ.map₂ /-
 /-- Lift a binary function `β → γ → δ` to a function `germ l β → germ l γ → germ l δ`. -/
@@ -223,11 +249,13 @@ def map₂ (op : β → γ → δ) : Germ l β → Germ l γ → Germ l δ :=
 #align filter.germ.map₂ Filter.Germ.map₂
 -/
 
+#print Filter.Germ.map₂_coe /-
 @[simp]
 theorem map₂_coe (op : β → γ → δ) (f : α → β) (g : α → γ) :
     map₂ op (f : Germ l β) g = fun x => op (f x) (g x) :=
   rfl
 #align filter.germ.map₂_coe Filter.Germ.map₂_coe
+-/
 
 #print Filter.Germ.Tendsto /-
 /-- A germ at `l` of maps from `α` to `β` tends to `lb : filter β` if it is represented by a map
@@ -256,11 +284,13 @@ def compTendsto' (f : Germ l β) {lc : Filter γ} (g : Germ lc α) (hg : g.Tends
 #align filter.germ.comp_tendsto' Filter.Germ.compTendsto'
 -/
 
+#print Filter.Germ.coe_compTendsto' /-
 @[simp]
 theorem coe_compTendsto' (f : α → β) {lc : Filter γ} {g : Germ lc α} (hg : g.Tendsto l) :
     (f : Germ l β).compTendsto' g hg = g.map f :=
   rfl
 #align filter.germ.coe_comp_tendsto' Filter.Germ.coe_compTendsto'
+-/
 
 #print Filter.Germ.compTendsto /-
 /-- Given a germ `f : germ l β` and a function `g : γ → α`, where `l : filter α`, if `g` tends
@@ -270,45 +300,59 @@ def compTendsto (f : Germ l β) {lc : Filter γ} (g : γ → α) (hg : Tendsto g
 #align filter.germ.comp_tendsto Filter.Germ.compTendsto
 -/
 
+#print Filter.Germ.coe_compTendsto /-
 @[simp]
 theorem coe_compTendsto (f : α → β) {lc : Filter γ} {g : γ → α} (hg : Tendsto g lc l) :
     (f : Germ l β).comp_tendsto g hg = f ∘ g :=
   rfl
 #align filter.germ.coe_comp_tendsto Filter.Germ.coe_compTendsto
+-/
 
+#print Filter.Germ.compTendsto'_coe /-
 @[simp]
 theorem compTendsto'_coe (f : Germ l β) {lc : Filter γ} {g : γ → α} (hg : Tendsto g lc l) :
     f.compTendsto' _ hg.germ_tendsto = f.comp_tendsto g hg :=
   rfl
 #align filter.germ.comp_tendsto'_coe Filter.Germ.compTendsto'_coe
+-/
 
+#print Filter.Germ.const_inj /-
 @[simp, norm_cast]
 theorem const_inj [NeBot l] {a b : β} : (↑a : Germ l β) = ↑b ↔ a = b :=
   coe_eq.trans <| const_eventuallyEq
 #align filter.germ.const_inj Filter.Germ.const_inj
+-/
 
+#print Filter.Germ.map_const /-
 @[simp]
 theorem map_const (l : Filter α) (a : β) (f : β → γ) : (↑a : Germ l β).map f = ↑(f a) :=
   rfl
 #align filter.germ.map_const Filter.Germ.map_const
+-/
 
+#print Filter.Germ.map₂_const /-
 @[simp]
 theorem map₂_const (l : Filter α) (b : β) (c : γ) (f : β → γ → δ) :
     map₂ f (↑b : Germ l β) ↑c = ↑(f b c) :=
   rfl
 #align filter.germ.map₂_const Filter.Germ.map₂_const
+-/
 
+#print Filter.Germ.const_compTendsto /-
 @[simp]
 theorem const_compTendsto {l : Filter α} (b : β) {lc : Filter γ} {g : γ → α} (hg : Tendsto g lc l) :
     (↑b : Germ l β).comp_tendsto g hg = ↑b :=
   rfl
 #align filter.germ.const_comp_tendsto Filter.Germ.const_compTendsto
+-/
 
+#print Filter.Germ.const_compTendsto' /-
 @[simp]
 theorem const_compTendsto' {l : Filter α} (b : β) {lc : Filter γ} {g : Germ lc α}
     (hg : g.Tendsto l) : (↑b : Germ l β).compTendsto' g hg = ↑b :=
   inductionOn g (fun _ _ => rfl) hg
 #align filter.germ.const_comp_tendsto' Filter.Germ.const_compTendsto'
+-/
 
 #print Filter.Germ.LiftPred /-
 /-- Lift a predicate on `β` to `germ l β`. -/
@@ -318,19 +362,25 @@ def LiftPred (p : β → Prop) (f : Germ l β) : Prop :=
 #align filter.germ.lift_pred Filter.Germ.LiftPred
 -/
 
+#print Filter.Germ.liftPred_coe /-
 @[simp]
 theorem liftPred_coe {p : β → Prop} {f : α → β} : LiftPred p (f : Germ l β) ↔ ∀ᶠ x in l, p (f x) :=
   Iff.rfl
 #align filter.germ.lift_pred_coe Filter.Germ.liftPred_coe
+-/
 
+#print Filter.Germ.liftPred_const /-
 theorem liftPred_const {p : β → Prop} {x : β} (hx : p x) : LiftPred p (↑x : Germ l β) :=
   eventually_of_forall fun y => hx
 #align filter.germ.lift_pred_const Filter.Germ.liftPred_const
+-/
 
+#print Filter.Germ.liftPred_const_iff /-
 @[simp]
 theorem liftPred_const_iff [NeBot l] {p : β → Prop} {x : β} : LiftPred p (↑x : Germ l β) ↔ p x :=
   @eventually_const _ _ _ (p x)
 #align filter.germ.lift_pred_const_iff Filter.Germ.liftPred_const_iff
+-/
 
 #print Filter.Germ.LiftRel /-
 /-- Lift a relation `r : β → γ → Prop` to `germ l β → germ l γ → Prop`. -/
@@ -340,22 +390,28 @@ def LiftRel (r : β → γ → Prop) (f : Germ l β) (g : Germ l γ) : Prop :=
 #align filter.germ.lift_rel Filter.Germ.LiftRel
 -/
 
+#print Filter.Germ.liftRel_coe /-
 @[simp]
 theorem liftRel_coe {r : β → γ → Prop} {f : α → β} {g : α → γ} :
     LiftRel r (f : Germ l β) g ↔ ∀ᶠ x in l, r (f x) (g x) :=
   Iff.rfl
 #align filter.germ.lift_rel_coe Filter.Germ.liftRel_coe
+-/
 
+#print Filter.Germ.liftRel_const /-
 theorem liftRel_const {r : β → γ → Prop} {x : β} {y : γ} (h : r x y) :
     LiftRel r (↑x : Germ l β) ↑y :=
   eventually_of_forall fun _ => h
 #align filter.germ.lift_rel_const Filter.Germ.liftRel_const
+-/
 
+#print Filter.Germ.liftRel_const_iff /-
 @[simp]
 theorem liftRel_const_iff [NeBot l] {r : β → γ → Prop} {x : β} {y : γ} :
     LiftRel r (↑x : Germ l β) ↑y ↔ r x y :=
   @eventually_const _ _ _ (r x y)
 #align filter.germ.lift_rel_const_iff Filter.Germ.liftRel_const_iff
+-/
 
 instance [Inhabited β] : Inhabited (Germ l β) :=
   ⟨↑(default : β)⟩
@@ -423,17 +479,21 @@ instance [SMul M G] : SMul M (Germ l G) :=
 instance [Pow G M] : Pow (Germ l G) M :=
   ⟨fun f n => map (· ^ n) f⟩
 
+#print Filter.Germ.coe_smul /-
 @[simp, norm_cast, to_additive]
 theorem coe_smul [SMul M G] (n : M) (f : α → G) : ↑(n • f) = (n • f : Germ l G) :=
   rfl
 #align filter.germ.coe_smul Filter.Germ.coe_smul
 #align filter.germ.coe_vadd Filter.Germ.coe_vadd
+-/
 
+#print Filter.Germ.const_smul /-
 @[simp, norm_cast, to_additive]
 theorem const_smul [SMul M G] (n : M) (a : G) : (↑(n • a) : Germ l G) = n • ↑a :=
   rfl
 #align filter.germ.const_smul Filter.Germ.const_smul
 #align filter.germ.const_vadd Filter.Germ.const_vadd
+-/
 
 #print Filter.Germ.coe_pow /-
 @[simp, norm_cast, to_additive coe_smul]
@@ -462,11 +522,13 @@ def coeMulHom [Monoid M] (l : Filter α) : (α → M) →* Germ l M :=
 #align filter.germ.coe_add_hom Filter.Germ.coeAddHom
 -/
 
+#print Filter.Germ.coe_coeMulHom /-
 @[simp, to_additive]
 theorem coe_coeMulHom [Monoid M] : (coeMulHom l : (α → M) → Germ l M) = coe :=
   rfl
 #align filter.germ.coe_coe_mul_hom Filter.Germ.coe_coeMulHom
 #align filter.germ.coe_coe_add_hom Filter.Germ.coe_coeAddHom
+-/
 
 @[to_additive]
 instance [CommMonoid M] : CommMonoid (Germ l M) :=
@@ -576,10 +638,12 @@ def coeRingHom [Semiring R] (l : Filter α) : (α → R) →+* Germ l R :=
 #align filter.germ.coe_ring_hom Filter.Germ.coeRingHom
 -/
 
+#print Filter.Germ.coe_coeRingHom /-
 @[simp]
 theorem coe_coeRingHom [Semiring R] : (coeRingHom l : (α → R) → Germ l R) = coe :=
   rfl
 #align filter.germ.coe_coe_ring_hom Filter.Germ.coe_coeRingHom
+-/
 
 instance [Ring R] : Ring (Germ l R) :=
   { Germ.addCommGroup, Germ.semiring with }

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

@@ -64,32 +64,14 @@ namespace Filter
 
 variable {α β γ δ : Type _} {l : Filter α} {f g h : α → β}
 
-/- warning: filter.const_eventually_eq' -> Filter.const_eventuallyEq' is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {β : Type.{u2}} {l : Filter.{u1} α} [_inst_1 : Filter.NeBot.{u1} α l] {a : β} {b : β}, Iff (Filter.Eventually.{u1} α (fun (x : α) => Eq.{succ u2} β a b) l) (Eq.{succ u2} β a b)
-but is expected to have type
-  forall {α : Type.{u2}} {β : Type.{u1}} {l : Filter.{u2} α} [_inst_1 : Filter.NeBot.{u2} α l] {a : β} {b : β}, Iff (Filter.Eventually.{u2} α (fun (x : α) => Eq.{succ u1} β a b) l) (Eq.{succ u1} β a b)
-Case conversion may be inaccurate. Consider using '#align filter.const_eventually_eq' Filter.const_eventuallyEq'ₓ'. -/
 theorem const_eventuallyEq' [NeBot l] {a b : β} : (∀ᶠ x in l, a = b) ↔ a = b :=
   eventually_const
 #align filter.const_eventually_eq' Filter.const_eventuallyEq'
 
-/- warning: filter.const_eventually_eq -> Filter.const_eventuallyEq is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {β : Type.{u2}} {l : Filter.{u1} α} [_inst_1 : Filter.NeBot.{u1} α l] {a : β} {b : β}, Iff (Filter.EventuallyEq.{u1, u2} α β l (fun (_x : α) => a) (fun (_x : α) => b)) (Eq.{succ u2} β a b)
-but is expected to have type
-  forall {α : Type.{u2}} {β : Type.{u1}} {l : Filter.{u2} α} [_inst_1 : Filter.NeBot.{u2} α l] {a : β} {b : β}, Iff (Filter.EventuallyEq.{u2, u1} α β l (fun (_x : α) => a) (fun (_x : α) => b)) (Eq.{succ u1} β a b)
-Case conversion may be inaccurate. Consider using '#align filter.const_eventually_eq Filter.const_eventuallyEqₓ'. -/
 theorem const_eventuallyEq [NeBot l] {a b : β} : ((fun _ => a) =ᶠ[l] fun _ => b) ↔ a = b :=
   @const_eventuallyEq' _ _ _ _ a b
 #align filter.const_eventually_eq Filter.const_eventuallyEq
 
-/- warning: filter.eventually_eq.comp_tendsto -> Filter.EventuallyEq.comp_tendsto is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {β : Type.{u2}} {γ : Type.{u3}} {l : Filter.{u1} α} {f : α -> β} {f' : α -> β}, (Filter.EventuallyEq.{u1, u2} α β l f f') -> (forall {g : γ -> α} {lc : Filter.{u3} γ}, (Filter.Tendsto.{u3, u1} γ α g lc l) -> (Filter.EventuallyEq.{u3, u2} γ β lc (Function.comp.{succ u3, succ u1, succ u2} γ α β f g) (Function.comp.{succ u3, succ u1, succ u2} γ α β f' g)))
-but is expected to have type
-  forall {α : Type.{u3}} {β : Type.{u2}} {γ : Type.{u1}} {l : Filter.{u3} α} {f : α -> β} {f' : α -> β}, (Filter.EventuallyEq.{u3, u2} α β l f f') -> (forall {g : γ -> α} {lc : Filter.{u1} γ}, (Filter.Tendsto.{u1, u3} γ α g lc l) -> (Filter.EventuallyEq.{u1, u2} γ β lc (Function.comp.{succ u1, succ u3, succ u2} γ α β f g) (Function.comp.{succ u1, succ u3, succ u2} γ α β f' g)))
-Case conversion may be inaccurate. Consider using '#align filter.eventually_eq.comp_tendsto Filter.EventuallyEq.comp_tendstoₓ'. -/
 theorem EventuallyEq.comp_tendsto {f' : α → β} (H : f =ᶠ[l] f') {g : γ → α} {lc : Filter γ}
     (hg : Tendsto g lc l) : f ∘ g =ᶠ[lc] f' ∘ g :=
   hg.Eventually H
@@ -152,57 +134,27 @@ instance : CoeTC (α → β) (Germ l β) :=
 instance : HasLiftT β (Germ l β) :=
   ⟨fun c => ↑fun x : α => c⟩
 
-/- warning: filter.germ.quot_mk_eq_coe -> Filter.Germ.quot_mk_eq_coe is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {β : Type.{u2}} (l : Filter.{u1} α) (f : α -> β), Eq.{max (succ u1) (succ u2)} (Quot.{max (succ u1) (succ u2)} (α -> β) (Setoid.r.{succ (max u1 u2)} (α -> β) (Filter.germSetoid.{u1, u2} α l β))) (Quot.mk.{max (succ u1) (succ u2)} (α -> β) (Setoid.r.{succ (max u1 u2)} (α -> β) (Filter.germSetoid.{u1, u2} α l β)) f) ((fun (a : Sort.{max (succ u1) (succ u2)}) (b : Type.{max u1 u2}) [self : HasLiftT.{max (succ u1) (succ u2), succ (max u1 u2)} a b] => self.0) (α -> β) (Filter.Germ.{u1, u2} α l β) (HasLiftT.mk.{max (succ u1) (succ u2), succ (max u1 u2)} (α -> β) (Filter.Germ.{u1, u2} α l β) (CoeTCₓ.coe.{max (succ u1) (succ u2), succ (max u1 u2)} (α -> β) (Filter.Germ.{u1, u2} α l β) (Filter.Germ.hasCoeT.{u1, u2} α β l))) f)
-but is expected to have type
-  forall {α : Type.{u2}} {β : Type.{u1}} (l : Filter.{u2} α) (f : α -> β), Eq.{max (succ u2) (succ u1)} (Quot.{max (succ u2) (succ u1)} (α -> β) (Setoid.r.{succ (max u2 u1)} (α -> β) (Filter.germSetoid.{u2, u1} α l β))) (Quot.mk.{max (succ u2) (succ u1)} (α -> β) (Setoid.r.{succ (max u2 u1)} (α -> β) (Filter.germSetoid.{u2, u1} α l β)) f) (Filter.Germ.ofFun.{u2, u1} α β l f)
-Case conversion may be inaccurate. Consider using '#align filter.germ.quot_mk_eq_coe Filter.Germ.quot_mk_eq_coeₓ'. -/
 @[simp]
 theorem quot_mk_eq_coe (l : Filter α) (f : α → β) : Quot.mk _ f = (f : Germ l β) :=
   rfl
 #align filter.germ.quot_mk_eq_coe Filter.Germ.quot_mk_eq_coe
 
-/- warning: filter.germ.mk'_eq_coe -> Filter.Germ.mk'_eq_coe is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {β : Type.{u2}} (l : Filter.{u1} α) (f : α -> β), Eq.{max (succ u1) (succ u2)} (Quotient.{max (succ u1) (succ u2)} (α -> β) (Filter.germSetoid.{u1, u2} α l β)) (Quotient.mk''.{max (succ u1) (succ u2)} (α -> β) (Filter.germSetoid.{u1, u2} α l β) f) ((fun (a : Sort.{max (succ u1) (succ u2)}) (b : Type.{max u1 u2}) [self : HasLiftT.{max (succ u1) (succ u2), succ (max u1 u2)} a b] => self.0) (α -> β) (Filter.Germ.{u1, u2} α l β) (HasLiftT.mk.{max (succ u1) (succ u2), succ (max u1 u2)} (α -> β) (Filter.Germ.{u1, u2} α l β) (CoeTCₓ.coe.{max (succ u1) (succ u2), succ (max u1 u2)} (α -> β) (Filter.Germ.{u1, u2} α l β) (Filter.Germ.hasCoeT.{u1, u2} α β l))) f)
-but is expected to have type
-  forall {α : Type.{u2}} {β : Type.{u1}} (l : Filter.{u2} α) (f : α -> β), Eq.{max (succ u2) (succ u1)} (Quotient.{max (succ u1) (succ u2)} (α -> β) (Filter.germSetoid.{u2, u1} α l β)) (Quotient.mk'.{max (succ u1) (succ u2)} (α -> β) (Filter.germSetoid.{u2, u1} α l β) f) (Filter.Germ.ofFun.{u2, u1} α β l f)
-Case conversion may be inaccurate. Consider using '#align filter.germ.mk'_eq_coe Filter.Germ.mk'_eq_coeₓ'. -/
 @[simp]
 theorem mk'_eq_coe (l : Filter α) (f : α → β) : Quotient.mk'' f = (f : Germ l β) :=
   rfl
 #align filter.germ.mk'_eq_coe Filter.Germ.mk'_eq_coe
 
-/- warning: filter.germ.induction_on -> Filter.Germ.inductionOn is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {β : Type.{u2}} {l : Filter.{u1} α} (f : Filter.Germ.{u1, u2} α l β) {p : (Filter.Germ.{u1, u2} α l β) -> Prop}, (forall (f : α -> β), p ((fun (a : Sort.{max (succ u1) (succ u2)}) (b : Type.{max u1 u2}) [self : HasLiftT.{max (succ u1) (succ u2), succ (max u1 u2)} a b] => self.0) (α -> β) (Filter.Germ.{u1, u2} α l β) (HasLiftT.mk.{max (succ u1) (succ u2), succ (max u1 u2)} (α -> β) (Filter.Germ.{u1, u2} α l β) (CoeTCₓ.coe.{max (succ u1) (succ u2), succ (max u1 u2)} (α -> β) (Filter.Germ.{u1, u2} α l β) (Filter.Germ.hasCoeT.{u1, u2} α β l))) f)) -> (p f)
-but is expected to have type
-  forall {α : Type.{u2}} {β : Type.{u1}} {l : Filter.{u2} α} (f : Filter.Germ.{u2, u1} α l β) {p : (Filter.Germ.{u2, u1} α l β) -> Prop}, (forall (f : α -> β), p (Filter.Germ.ofFun.{u2, u1} α β l f)) -> (p f)
-Case conversion may be inaccurate. Consider using '#align filter.germ.induction_on Filter.Germ.inductionOnₓ'. -/
 @[elab_as_elim]
 theorem inductionOn (f : Germ l β) {p : Germ l β → Prop} (h : ∀ f : α → β, p f) : p f :=
   Quotient.inductionOn' f h
 #align filter.germ.induction_on Filter.Germ.inductionOn
 
-/- warning: filter.germ.induction_on₂ -> Filter.Germ.inductionOn₂ is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {β : Type.{u2}} {γ : Type.{u3}} {l : Filter.{u1} α} (f : Filter.Germ.{u1, u2} α l β) (g : Filter.Germ.{u1, u3} α l γ) {p : (Filter.Germ.{u1, u2} α l β) -> (Filter.Germ.{u1, u3} α l γ) -> Prop}, (forall (f : α -> β) (g : α -> γ), p ((fun (a : Sort.{max (succ u1) (succ u2)}) (b : Type.{max u1 u2}) [self : HasLiftT.{max (succ u1) (succ u2), succ (max u1 u2)} a b] => self.0) (α -> β) (Filter.Germ.{u1, u2} α l β) (HasLiftT.mk.{max (succ u1) (succ u2), succ (max u1 u2)} (α -> β) (Filter.Germ.{u1, u2} α l β) (CoeTCₓ.coe.{max (succ u1) (succ u2), succ (max u1 u2)} (α -> β) (Filter.Germ.{u1, u2} α l β) (Filter.Germ.hasCoeT.{u1, u2} α β l))) f) ((fun (a : Sort.{max (succ u1) (succ u3)}) (b : Type.{max u1 u3}) [self : HasLiftT.{max (succ u1) (succ u3), succ (max u1 u3)} a b] => self.0) (α -> γ) (Filter.Germ.{u1, u3} α l γ) (HasLiftT.mk.{max (succ u1) (succ u3), succ (max u1 u3)} (α -> γ) (Filter.Germ.{u1, u3} α l γ) (CoeTCₓ.coe.{max (succ u1) (succ u3), succ (max u1 u3)} (α -> γ) (Filter.Germ.{u1, u3} α l γ) (Filter.Germ.hasCoeT.{u1, u3} α γ l))) g)) -> (p f g)
-but is expected to have type
-  forall {α : Type.{u3}} {β : Type.{u2}} {γ : Type.{u1}} {l : Filter.{u3} α} (f : Filter.Germ.{u3, u2} α l β) (g : Filter.Germ.{u3, u1} α l γ) {p : (Filter.Germ.{u3, u2} α l β) -> (Filter.Germ.{u3, u1} α l γ) -> Prop}, (forall (f : α -> β) (g : α -> γ), p (Filter.Germ.ofFun.{u3, u2} α β l f) (Filter.Germ.ofFun.{u3, u1} α γ l g)) -> (p f g)
-Case conversion may be inaccurate. Consider using '#align filter.germ.induction_on₂ Filter.Germ.inductionOn₂ₓ'. -/
 @[elab_as_elim]
 theorem inductionOn₂ (f : Germ l β) (g : Germ l γ) {p : Germ l β → Germ l γ → Prop}
     (h : ∀ (f : α → β) (g : α → γ), p f g) : p f g :=
   Quotient.inductionOn₂' f g h
 #align filter.germ.induction_on₂ Filter.Germ.inductionOn₂
 
-/- warning: filter.germ.induction_on₃ -> Filter.Germ.inductionOn₃ is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {β : Type.{u2}} {γ : Type.{u3}} {δ : Type.{u4}} {l : Filter.{u1} α} (f : Filter.Germ.{u1, u2} α l β) (g : Filter.Germ.{u1, u3} α l γ) (h : Filter.Germ.{u1, u4} α l δ) {p : (Filter.Germ.{u1, u2} α l β) -> (Filter.Germ.{u1, u3} α l γ) -> (Filter.Germ.{u1, u4} α l δ) -> Prop}, (forall (f : α -> β) (g : α -> γ) (h : α -> δ), p ((fun (a : Sort.{max (succ u1) (succ u2)}) (b : Type.{max u1 u2}) [self : HasLiftT.{max (succ u1) (succ u2), succ (max u1 u2)} a b] => self.0) (α -> β) (Filter.Germ.{u1, u2} α l β) (HasLiftT.mk.{max (succ u1) (succ u2), succ (max u1 u2)} (α -> β) (Filter.Germ.{u1, u2} α l β) (CoeTCₓ.coe.{max (succ u1) (succ u2), succ (max u1 u2)} (α -> β) (Filter.Germ.{u1, u2} α l β) (Filter.Germ.hasCoeT.{u1, u2} α β l))) f) ((fun (a : Sort.{max (succ u1) (succ u3)}) (b : Type.{max u1 u3}) [self : HasLiftT.{max (succ u1) (succ u3), succ (max u1 u3)} a b] => self.0) (α -> γ) (Filter.Germ.{u1, u3} α l γ) (HasLiftT.mk.{max (succ u1) (succ u3), succ (max u1 u3)} (α -> γ) (Filter.Germ.{u1, u3} α l γ) (CoeTCₓ.coe.{max (succ u1) (succ u3), succ (max u1 u3)} (α -> γ) (Filter.Germ.{u1, u3} α l γ) (Filter.Germ.hasCoeT.{u1, u3} α γ l))) g) ((fun (a : Sort.{max (succ u1) (succ u4)}) (b : Type.{max u1 u4}) [self : HasLiftT.{max (succ u1) (succ u4), succ (max u1 u4)} a b] => self.0) (α -> δ) (Filter.Germ.{u1, u4} α l δ) (HasLiftT.mk.{max (succ u1) (succ u4), succ (max u1 u4)} (α -> δ) (Filter.Germ.{u1, u4} α l δ) (CoeTCₓ.coe.{max (succ u1) (succ u4), succ (max u1 u4)} (α -> δ) (Filter.Germ.{u1, u4} α l δ) (Filter.Germ.hasCoeT.{u1, u4} α δ l))) h)) -> (p f g h)
-but is expected to have type
-  forall {α : Type.{u4}} {β : Type.{u3}} {γ : Type.{u2}} {δ : Type.{u1}} {l : Filter.{u4} α} (f : Filter.Germ.{u4, u3} α l β) (g : Filter.Germ.{u4, u2} α l γ) (h : Filter.Germ.{u4, u1} α l δ) {p : (Filter.Germ.{u4, u3} α l β) -> (Filter.Germ.{u4, u2} α l γ) -> (Filter.Germ.{u4, u1} α l δ) -> Prop}, (forall (f : α -> β) (g : α -> γ) (h : α -> δ), p (Filter.Germ.ofFun.{u4, u3} α β l f) (Filter.Germ.ofFun.{u4, u2} α γ l g) (Filter.Germ.ofFun.{u4, u1} α δ l h)) -> (p f g h)
-Case conversion may be inaccurate. Consider using '#align filter.germ.induction_on₃ Filter.Germ.inductionOn₃ₓ'. -/
 @[elab_as_elim]
 theorem inductionOn₃ (f : Germ l β) (g : Germ l γ) (h : Germ l δ)
     {p : Germ l β → Germ l γ → Germ l δ → Prop}
@@ -228,35 +180,17 @@ def liftOn {γ : Sort _} (f : Germ l β) (F : (α → β) → γ) (hF : (l.Event
 #align filter.germ.lift_on Filter.Germ.liftOn
 -/
 
-/- warning: filter.germ.map'_coe -> Filter.Germ.map'_coe is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {β : Type.{u2}} {γ : Type.{u3}} {δ : Type.{u4}} {l : Filter.{u1} α} {lc : Filter.{u3} γ} (F : (α -> β) -> γ -> δ) (hF : Relator.LiftFun.{max (succ u1) (succ u2), max (succ u1) (succ u2), max (succ u3) (succ u4), max (succ u3) (succ u4)} (α -> β) (α -> β) (γ -> δ) (γ -> δ) (Filter.EventuallyEq.{u1, u2} α β l) (Filter.EventuallyEq.{u3, u4} γ δ lc) F F) (f : α -> β), Eq.{succ (max u3 u4)} (Filter.Germ.{u3, u4} γ lc δ) (Filter.Germ.map'.{u1, u2, u3, u4} α β γ δ l lc F hF ((fun (a : Sort.{max (succ u1) (succ u2)}) (b : Type.{max u1 u2}) [self : HasLiftT.{max (succ u1) (succ u2), succ (max u1 u2)} a b] => self.0) (α -> β) (Filter.Germ.{u1, u2} α l β) (HasLiftT.mk.{max (succ u1) (succ u2), succ (max u1 u2)} (α -> β) (Filter.Germ.{u1, u2} α l β) (CoeTCₓ.coe.{max (succ u1) (succ u2), succ (max u1 u2)} (α -> β) (Filter.Germ.{u1, u2} α l β) (Filter.Germ.hasCoeT.{u1, u2} α β l))) f)) ((fun (a : Sort.{max (succ u3) (succ u4)}) (b : Type.{max u3 u4}) [self : HasLiftT.{max (succ u3) (succ u4), succ (max u3 u4)} a b] => self.0) (γ -> δ) (Filter.Germ.{u3, u4} γ lc δ) (HasLiftT.mk.{max (succ u3) (succ u4), succ (max u3 u4)} (γ -> δ) (Filter.Germ.{u3, u4} γ lc δ) (CoeTCₓ.coe.{max (succ u3) (succ u4), succ (max u3 u4)} (γ -> δ) (Filter.Germ.{u3, u4} γ lc δ) (Filter.Germ.hasCoeT.{u3, u4} γ δ lc))) (F f))
-but is expected to have type
-  forall {α : Type.{u3}} {β : Type.{u2}} {γ : Type.{u4}} {δ : Type.{u1}} {l : Filter.{u3} α} {lc : Filter.{u4} γ} (F : (α -> β) -> γ -> δ) (hF : Relator.LiftFun.{max (succ u3) (succ u2), max (succ u3) (succ u2), max (succ u4) (succ u1), max (succ u4) (succ u1)} (α -> β) (α -> β) (γ -> δ) (γ -> δ) (Filter.EventuallyEq.{u3, u2} α β l) (Filter.EventuallyEq.{u4, u1} γ δ lc) F F) (f : α -> β), Eq.{max (succ u4) (succ u1)} (Filter.Germ.{u4, u1} γ lc δ) (Filter.Germ.map'.{u3, u2, u4, u1} α β γ δ l lc F hF (Filter.Germ.ofFun.{u3, u2} α β l f)) (Filter.Germ.ofFun.{u4, u1} γ δ lc (F f))
-Case conversion may be inaccurate. Consider using '#align filter.germ.map'_coe Filter.Germ.map'_coeₓ'. -/
 @[simp]
 theorem map'_coe {lc : Filter γ} (F : (α → β) → γ → δ) (hF : (l.EventuallyEq ⇒ lc.EventuallyEq) F F)
     (f : α → β) : map' F hF f = F f :=
   rfl
 #align filter.germ.map'_coe Filter.Germ.map'_coe
 
-/- warning: filter.germ.coe_eq -> Filter.Germ.coe_eq is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {β : Type.{u2}} {l : Filter.{u1} α} {f : α -> β} {g : α -> β}, Iff (Eq.{succ (max u1 u2)} (Filter.Germ.{u1, u2} α l β) ((fun (a : Sort.{max (succ u1) (succ u2)}) (b : Type.{max u1 u2}) [self : HasLiftT.{max (succ u1) (succ u2), succ (max u1 u2)} a b] => self.0) (α -> β) (Filter.Germ.{u1, u2} α l β) (HasLiftT.mk.{max (succ u1) (succ u2), succ (max u1 u2)} (α -> β) (Filter.Germ.{u1, u2} α l β) (CoeTCₓ.coe.{max (succ u1) (succ u2), succ (max u1 u2)} (α -> β) (Filter.Germ.{u1, u2} α l β) (Filter.Germ.hasCoeT.{u1, u2} α β l))) f) ((fun (a : Sort.{max (succ u1) (succ u2)}) (b : Type.{max u1 u2}) [self : HasLiftT.{max (succ u1) (succ u2), succ (max u1 u2)} a b] => self.0) (α -> β) (Filter.Germ.{u1, u2} α l β) (HasLiftT.mk.{max (succ u1) (succ u2), succ (max u1 u2)} (α -> β) (Filter.Germ.{u1, u2} α l β) (CoeTCₓ.coe.{max (succ u1) (succ u2), succ (max u1 u2)} (α -> β) (Filter.Germ.{u1, u2} α l β) (Filter.Germ.hasCoeT.{u1, u2} α β l))) g)) (Filter.EventuallyEq.{u1, u2} α β l f g)
-but is expected to have type
-  forall {α : Type.{u2}} {β : Type.{u1}} {l : Filter.{u2} α} {f : α -> β} {g : α -> β}, Iff (Eq.{max (succ u2) (succ u1)} (Filter.Germ.{u2, u1} α l β) (Filter.Germ.ofFun.{u2, u1} α β l f) (Filter.Germ.ofFun.{u2, u1} α β l g)) (Filter.EventuallyEq.{u2, u1} α β l f g)
-Case conversion may be inaccurate. Consider using '#align filter.germ.coe_eq Filter.Germ.coe_eqₓ'. -/
 @[simp, norm_cast]
 theorem coe_eq : (f : Germ l β) = g ↔ f =ᶠ[l] g :=
   Quotient.eq''
 #align filter.germ.coe_eq Filter.Germ.coe_eq
 
-/- warning: filter.eventually_eq.germ_eq -> Filter.EventuallyEq.germ_eq is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {β : Type.{u2}} {l : Filter.{u1} α} {f : α -> β} {g : α -> β}, (Filter.EventuallyEq.{u1, u2} α β l f g) -> (Eq.{succ (max u1 u2)} (Filter.Germ.{u1, u2} α l β) ((fun (a : Sort.{max (succ u1) (succ u2)}) (b : Type.{max u1 u2}) [self : HasLiftT.{max (succ u1) (succ u2), succ (max u1 u2)} a b] => self.0) (α -> β) (Filter.Germ.{u1, u2} α l β) (HasLiftT.mk.{max (succ u1) (succ u2), succ (max u1 u2)} (α -> β) (Filter.Germ.{u1, u2} α l β) (CoeTCₓ.coe.{max (succ u1) (succ u2), succ (max u1 u2)} (α -> β) (Filter.Germ.{u1, u2} α l β) (Filter.Germ.hasCoeT.{u1, u2} α β l))) f) ((fun (a : Sort.{max (succ u1) (succ u2)}) (b : Type.{max u1 u2}) [self : HasLiftT.{max (succ u1) (succ u2), succ (max u1 u2)} a b] => self.0) (α -> β) (Filter.Germ.{u1, u2} α l β) (HasLiftT.mk.{max (succ u1) (succ u2), succ (max u1 u2)} (α -> β) (Filter.Germ.{u1, u2} α l β) (CoeTCₓ.coe.{max (succ u1) (succ u2), succ (max u1 u2)} (α -> β) (Filter.Germ.{u1, u2} α l β) (Filter.Germ.hasCoeT.{u1, u2} α β l))) g))
-but is expected to have type
-  forall {α : Type.{u2}} {β : Type.{u1}} {l : Filter.{u2} α} {f : α -> β} {g : α -> β}, (Filter.EventuallyEq.{u2, u1} α β l f g) -> (Eq.{max (succ u2) (succ u1)} (Filter.Germ.{u2, u1} α l β) (Filter.Germ.ofFun.{u2, u1} α β l f) (Filter.Germ.ofFun.{u2, u1} α β l g))
-Case conversion may be inaccurate. Consider using '#align filter.eventually_eq.germ_eq Filter.EventuallyEq.germ_eqₓ'. -/
 alias coe_eq ↔ _ _root_.filter.eventually_eq.germ_eq
 #align filter.eventually_eq.germ_eq Filter.EventuallyEq.germ_eq
 
@@ -267,33 +201,15 @@ def map (op : β → γ) : Germ l β → Germ l γ :=
 #align filter.germ.map Filter.Germ.map
 -/
 
-/- warning: filter.germ.map_coe -> Filter.Germ.map_coe is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {β : Type.{u2}} {γ : Type.{u3}} {l : Filter.{u1} α} (op : β -> γ) (f : α -> β), Eq.{succ (max u1 u3)} (Filter.Germ.{u1, u3} α l γ) (Filter.Germ.map.{u1, u2, u3} α β γ l op ((fun (a : Sort.{max (succ u1) (succ u2)}) (b : Type.{max u1 u2}) [self : HasLiftT.{max (succ u1) (succ u2), succ (max u1 u2)} a b] => self.0) (α -> β) (Filter.Germ.{u1, u2} α l β) (HasLiftT.mk.{max (succ u1) (succ u2), succ (max u1 u2)} (α -> β) (Filter.Germ.{u1, u2} α l β) (CoeTCₓ.coe.{max (succ u1) (succ u2), succ (max u1 u2)} (α -> β) (Filter.Germ.{u1, u2} α l β) (Filter.Germ.hasCoeT.{u1, u2} α β l))) f)) ((fun (a : Sort.{max (succ u1) (succ u3)}) (b : Type.{max u1 u3}) [self : HasLiftT.{max (succ u1) (succ u3), succ (max u1 u3)} a b] => self.0) (α -> γ) (Filter.Germ.{u1, u3} α l γ) (HasLiftT.mk.{max (succ u1) (succ u3), succ (max u1 u3)} (α -> γ) (Filter.Germ.{u1, u3} α l γ) (CoeTCₓ.coe.{max (succ u1) (succ u3), succ (max u1 u3)} (α -> γ) (Filter.Germ.{u1, u3} α l γ) (Filter.Germ.hasCoeT.{u1, u3} α γ l))) (Function.comp.{succ u1, succ u2, succ u3} α β γ op f))
-but is expected to have type
-  forall {α : Type.{u3}} {β : Type.{u1}} {γ : Type.{u2}} {l : Filter.{u3} α} (op : β -> γ) (f : α -> β), Eq.{max (succ u3) (succ u2)} (Filter.Germ.{u3, u2} α l γ) (Filter.Germ.map.{u3, u1, u2} α β γ l op (Filter.Germ.ofFun.{u3, u1} α β l f)) (Filter.Germ.ofFun.{u3, u2} α γ l (Function.comp.{succ u3, succ u1, succ u2} α β γ op f))
-Case conversion may be inaccurate. Consider using '#align filter.germ.map_coe Filter.Germ.map_coeₓ'. -/
 @[simp]
 theorem map_coe (op : β → γ) (f : α → β) : map op (f : Germ l β) = op ∘ f :=
   rfl
 #align filter.germ.map_coe Filter.Germ.map_coe
 
-/- warning: filter.germ.map_id -> Filter.Germ.map_id is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {β : Type.{u2}} {l : Filter.{u1} α}, Eq.{succ (max u1 u2)} ((Filter.Germ.{u1, u2} α l β) -> (Filter.Germ.{u1, u2} α l β)) (Filter.Germ.map.{u1, u2, u2} α β β l (id.{succ u2} β)) (id.{succ (max u1 u2)} (Filter.Germ.{u1, u2} α l β))
-but is expected to have type
-  forall {α : Type.{u2}} {β : Type.{u1}} {l : Filter.{u2} α}, Eq.{max (succ u2) (succ u1)} ((Filter.Germ.{u2, u1} α l β) -> (Filter.Germ.{u2, u1} α l β)) (Filter.Germ.map.{u2, u1, u1} α β β l (id.{succ u1} β)) (id.{max (succ u2) (succ u1)} (Filter.Germ.{u2, u1} α l β))
-Case conversion may be inaccurate. Consider using '#align filter.germ.map_id Filter.Germ.map_idₓ'. -/
 @[simp]
 theorem map_id : map id = (id : Germ l β → Germ l β) := by ext ⟨f⟩; rfl
 #align filter.germ.map_id Filter.Germ.map_id
 
-/- warning: filter.germ.map_map -> Filter.Germ.map_map is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {β : Type.{u2}} {γ : Type.{u3}} {δ : Type.{u4}} {l : Filter.{u1} α} (op₁ : γ -> δ) (op₂ : β -> γ) (f : Filter.Germ.{u1, u2} α l β), Eq.{succ (max u1 u4)} (Filter.Germ.{u1, u4} α l δ) (Filter.Germ.map.{u1, u3, u4} α γ δ l op₁ (Filter.Germ.map.{u1, u2, u3} α β γ l op₂ f)) (Filter.Germ.map.{u1, u2, u4} α β δ l (Function.comp.{succ u2, succ u3, succ u4} β γ δ op₁ op₂) f)
-but is expected to have type
-  forall {α : Type.{u4}} {β : Type.{u3}} {γ : Type.{u1}} {δ : Type.{u2}} {l : Filter.{u4} α} (op₁ : γ -> δ) (op₂ : β -> γ) (f : Filter.Germ.{u4, u3} α l β), Eq.{max (succ u4) (succ u2)} (Filter.Germ.{u4, u2} α l δ) (Filter.Germ.map.{u4, u1, u2} α γ δ l op₁ (Filter.Germ.map.{u4, u3, u1} α β γ l op₂ f)) (Filter.Germ.map.{u4, u3, u2} α β δ l (Function.comp.{succ u3, succ u1, succ u2} β γ δ op₁ op₂) f)
-Case conversion may be inaccurate. Consider using '#align filter.germ.map_map Filter.Germ.map_mapₓ'. -/
 theorem map_map (op₁ : γ → δ) (op₂ : β → γ) (f : Germ l β) :
     map op₁ (map op₂ f) = map (op₁ ∘ op₂) f :=
   inductionOn f fun f => rfl
@@ -307,12 +223,6 @@ def map₂ (op : β → γ → δ) : Germ l β → Germ l γ → Germ l δ :=
 #align filter.germ.map₂ Filter.Germ.map₂
 -/
 
-/- warning: filter.germ.map₂_coe -> Filter.Germ.map₂_coe is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {β : Type.{u2}} {γ : Type.{u3}} {δ : Type.{u4}} {l : Filter.{u1} α} (op : β -> γ -> δ) (f : α -> β) (g : α -> γ), Eq.{succ (max u1 u4)} (Filter.Germ.{u1, u4} α l δ) (Filter.Germ.map₂.{u1, u2, u3, u4} α β γ δ l op ((fun (a : Sort.{max (succ u1) (succ u2)}) (b : Type.{max u1 u2}) [self : HasLiftT.{max (succ u1) (succ u2), succ (max u1 u2)} a b] => self.0) (α -> β) (Filter.Germ.{u1, u2} α l β) (HasLiftT.mk.{max (succ u1) (succ u2), succ (max u1 u2)} (α -> β) (Filter.Germ.{u1, u2} α l β) (CoeTCₓ.coe.{max (succ u1) (succ u2), succ (max u1 u2)} (α -> β) (Filter.Germ.{u1, u2} α l β) (Filter.Germ.hasCoeT.{u1, u2} α β l))) f) ((fun (a : Sort.{max (succ u1) (succ u3)}) (b : Type.{max u1 u3}) [self : HasLiftT.{max (succ u1) (succ u3), succ (max u1 u3)} a b] => self.0) (α -> γ) (Filter.Germ.{u1, u3} α l γ) (HasLiftT.mk.{max (succ u1) (succ u3), succ (max u1 u3)} (α -> γ) (Filter.Germ.{u1, u3} α l γ) (CoeTCₓ.coe.{max (succ u1) (succ u3), succ (max u1 u3)} (α -> γ) (Filter.Germ.{u1, u3} α l γ) (Filter.Germ.hasCoeT.{u1, u3} α γ l))) g)) ((fun (a : Sort.{max (succ u1) (succ u4)}) (b : Type.{max u1 u4}) [self : HasLiftT.{max (succ u1) (succ u4), succ (max u1 u4)} a b] => self.0) (α -> δ) (Filter.Germ.{u1, u4} α l δ) (HasLiftT.mk.{max (succ u1) (succ u4), succ (max u1 u4)} (α -> δ) (Filter.Germ.{u1, u4} α l δ) (CoeTCₓ.coe.{max (succ u1) (succ u4), succ (max u1 u4)} (α -> δ) (Filter.Germ.{u1, u4} α l δ) (Filter.Germ.hasCoeT.{u1, u4} α δ l))) (fun (x : α) => op (f x) (g x)))
-but is expected to have type
-  forall {α : Type.{u4}} {β : Type.{u2}} {γ : Type.{u1}} {δ : Type.{u3}} {l : Filter.{u4} α} (op : β -> γ -> δ) (f : α -> β) (g : α -> γ), Eq.{max (succ u4) (succ u3)} (Filter.Germ.{u4, u3} α l δ) (Filter.Germ.map₂.{u4, u2, u1, u3} α β γ δ l op (Filter.Germ.ofFun.{u4, u2} α β l f) (Filter.Germ.ofFun.{u4, u1} α γ l g)) (Filter.Germ.ofFun.{u4, u3} α δ l (fun (x : α) => op (f x) (g x)))
-Case conversion may be inaccurate. Consider using '#align filter.germ.map₂_coe Filter.Germ.map₂_coeₓ'. -/
 @[simp]
 theorem map₂_coe (op : β → γ → δ) (f : α → β) (g : α → γ) :
     map₂ op (f : Germ l β) g = fun x => op (f x) (g x) :=
@@ -346,12 +256,6 @@ def compTendsto' (f : Germ l β) {lc : Filter γ} (g : Germ lc α) (hg : g.Tends
 #align filter.germ.comp_tendsto' Filter.Germ.compTendsto'
 -/
 
-/- warning: filter.germ.coe_comp_tendsto' -> Filter.Germ.coe_compTendsto' is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {β : Type.{u2}} {γ : Type.{u3}} {l : Filter.{u1} α} (f : α -> β) {lc : Filter.{u3} γ} {g : Filter.Germ.{u3, u1} γ lc α} (hg : Filter.Germ.Tendsto.{u3, u1} γ α lc g l), Eq.{succ (max u3 u2)} (Filter.Germ.{u3, u2} γ lc β) (Filter.Germ.compTendsto'.{u1, u2, u3} α β γ l ((fun (a : Sort.{max (succ u1) (succ u2)}) (b : Type.{max u1 u2}) [self : HasLiftT.{max (succ u1) (succ u2), succ (max u1 u2)} a b] => self.0) (α -> β) (Filter.Germ.{u1, u2} α l β) (HasLiftT.mk.{max (succ u1) (succ u2), succ (max u1 u2)} (α -> β) (Filter.Germ.{u1, u2} α l β) (CoeTCₓ.coe.{max (succ u1) (succ u2), succ (max u1 u2)} (α -> β) (Filter.Germ.{u1, u2} α l β) (Filter.Germ.hasCoeT.{u1, u2} α β l))) f) lc g hg) (Filter.Germ.map.{u3, u1, u2} γ α β lc f g)
-but is expected to have type
-  forall {α : Type.{u2}} {β : Type.{u1}} {γ : Type.{u3}} {l : Filter.{u2} α} (f : α -> β) {lc : Filter.{u3} γ} {g : Filter.Germ.{u3, u2} γ lc α} (hg : Filter.Germ.Tendsto.{u3, u2} γ α lc g l), Eq.{max (succ u1) (succ u3)} (Filter.Germ.{u3, u1} γ lc β) (Filter.Germ.compTendsto'.{u2, u1, u3} α β γ l (Filter.Germ.ofFun.{u2, u1} α β l f) lc g hg) (Filter.Germ.map.{u3, u2, u1} γ α β lc f g)
-Case conversion may be inaccurate. Consider using '#align filter.germ.coe_comp_tendsto' Filter.Germ.coe_compTendsto'ₓ'. -/
 @[simp]
 theorem coe_compTendsto' (f : α → β) {lc : Filter γ} {g : Germ lc α} (hg : g.Tendsto l) :
     (f : Germ l β).compTendsto' g hg = g.map f :=
@@ -366,82 +270,40 @@ def compTendsto (f : Germ l β) {lc : Filter γ} (g : γ → α) (hg : Tendsto g
 #align filter.germ.comp_tendsto Filter.Germ.compTendsto
 -/
 
-/- warning: filter.germ.coe_comp_tendsto -> Filter.Germ.coe_compTendsto is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {β : Type.{u2}} {γ : Type.{u3}} {l : Filter.{u1} α} (f : α -> β) {lc : Filter.{u3} γ} {g : γ -> α} (hg : Filter.Tendsto.{u3, u1} γ α g lc l), Eq.{succ (max u3 u2)} (Filter.Germ.{u3, u2} γ lc β) (Filter.Germ.compTendsto.{u1, u2, u3} α β γ l ((fun (a : Sort.{max (succ u1) (succ u2)}) (b : Type.{max u1 u2}) [self : HasLiftT.{max (succ u1) (succ u2), succ (max u1 u2)} a b] => self.0) (α -> β) (Filter.Germ.{u1, u2} α l β) (HasLiftT.mk.{max (succ u1) (succ u2), succ (max u1 u2)} (α -> β) (Filter.Germ.{u1, u2} α l β) (CoeTCₓ.coe.{max (succ u1) (succ u2), succ (max u1 u2)} (α -> β) (Filter.Germ.{u1, u2} α l β) (Filter.Germ.hasCoeT.{u1, u2} α β l))) f) lc g hg) ((fun (a : Sort.{max (succ u3) (succ u2)}) (b : Type.{max u3 u2}) [self : HasLiftT.{max (succ u3) (succ u2), succ (max u3 u2)} a b] => self.0) (γ -> β) (Filter.Germ.{u3, u2} γ lc β) (HasLiftT.mk.{max (succ u3) (succ u2), succ (max u3 u2)} (γ -> β) (Filter.Germ.{u3, u2} γ lc β) (CoeTCₓ.coe.{max (succ u3) (succ u2), succ (max u3 u2)} (γ -> β) (Filter.Germ.{u3, u2} γ lc β) (Filter.Germ.hasCoeT.{u3, u2} γ β lc))) (Function.comp.{succ u3, succ u1, succ u2} γ α β f g))
-but is expected to have type
-  forall {α : Type.{u2}} {β : Type.{u1}} {γ : Type.{u3}} {l : Filter.{u2} α} (f : α -> β) {lc : Filter.{u3} γ} {g : γ -> α} (hg : Filter.Tendsto.{u3, u2} γ α g lc l), Eq.{max (succ u1) (succ u3)} (Filter.Germ.{u3, u1} γ lc β) (Filter.Germ.compTendsto.{u2, u1, u3} α β γ l (Filter.Germ.ofFun.{u2, u1} α β l f) lc g hg) (Filter.Germ.ofFun.{u3, u1} γ β lc (Function.comp.{succ u3, succ u2, succ u1} γ α β f g))
-Case conversion may be inaccurate. Consider using '#align filter.germ.coe_comp_tendsto Filter.Germ.coe_compTendstoₓ'. -/
 @[simp]
 theorem coe_compTendsto (f : α → β) {lc : Filter γ} {g : γ → α} (hg : Tendsto g lc l) :
     (f : Germ l β).comp_tendsto g hg = f ∘ g :=
   rfl
 #align filter.germ.coe_comp_tendsto Filter.Germ.coe_compTendsto
 
-/- warning: filter.germ.comp_tendsto'_coe -> Filter.Germ.compTendsto'_coe is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {β : Type.{u2}} {γ : Type.{u3}} {l : Filter.{u1} α} (f : Filter.Germ.{u1, u2} α l β) {lc : Filter.{u3} γ} {g : γ -> α} (hg : Filter.Tendsto.{u3, u1} γ α g lc l), Eq.{succ (max u3 u2)} (Filter.Germ.{u3, u2} γ lc β) (Filter.Germ.compTendsto'.{u1, u2, u3} α β γ l f lc ((fun (a : Sort.{max (succ u3) (succ u1)}) (b : Type.{max u3 u1}) [self : HasLiftT.{max (succ u3) (succ u1), succ (max u3 u1)} a b] => self.0) (γ -> α) (Filter.Germ.{u3, u1} γ lc α) (HasLiftT.mk.{max (succ u3) (succ u1), succ (max u3 u1)} (γ -> α) (Filter.Germ.{u3, u1} γ lc α) (CoeTCₓ.coe.{max (succ u3) (succ u1), succ (max u3 u1)} (γ -> α) (Filter.Germ.{u3, u1} γ lc α) (Filter.Germ.hasCoeT.{u3, u1} γ α lc))) g) (Filter.Tendsto.germ_tendsto.{u3, u1} γ α lc g l hg)) (Filter.Germ.compTendsto.{u1, u2, u3} α β γ l f lc g hg)
-but is expected to have type
-  forall {α : Type.{u3}} {β : Type.{u2}} {γ : Type.{u1}} {l : Filter.{u3} α} (f : Filter.Germ.{u3, u2} α l β) {lc : Filter.{u1} γ} {g : γ -> α} (hg : Filter.Tendsto.{u1, u3} γ α g lc l), Eq.{max (succ u2) (succ u1)} (Filter.Germ.{u1, u2} γ lc β) (Filter.Germ.compTendsto'.{u3, u2, u1} α β γ l f lc (Filter.Germ.ofFun.{u1, u3} γ α lc g) (Filter.Tendsto.germ_tendsto.{u1, u3} γ α lc g l hg)) (Filter.Germ.compTendsto.{u3, u2, u1} α β γ l f lc g hg)
-Case conversion may be inaccurate. Consider using '#align filter.germ.comp_tendsto'_coe Filter.Germ.compTendsto'_coeₓ'. -/
 @[simp]
 theorem compTendsto'_coe (f : Germ l β) {lc : Filter γ} {g : γ → α} (hg : Tendsto g lc l) :
     f.compTendsto' _ hg.germ_tendsto = f.comp_tendsto g hg :=
   rfl
 #align filter.germ.comp_tendsto'_coe Filter.Germ.compTendsto'_coe
 
-/- warning: filter.germ.const_inj -> Filter.Germ.const_inj is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {β : Type.{u2}} {l : Filter.{u1} α} [_inst_1 : Filter.NeBot.{u1} α l] {a : β} {b : β}, Iff (Eq.{succ (max u1 u2)} (Filter.Germ.{u1, u2} α l β) ((fun (a : Type.{u2}) (b : Type.{max u1 u2}) [self : HasLiftT.{succ u2, succ (max u1 u2)} a b] => self.0) β (Filter.Germ.{u1, u2} α l β) (Filter.Germ.hasLiftT.{u1, u2} α β l) a) ((fun (a : Type.{u2}) (b : Type.{max u1 u2}) [self : HasLiftT.{succ u2, succ (max u1 u2)} a b] => self.0) β (Filter.Germ.{u1, u2} α l β) (Filter.Germ.hasLiftT.{u1, u2} α β l) b)) (Eq.{succ u2} β a b)
-but is expected to have type
-  forall {α : Type.{u2}} {β : Type.{u1}} {l : Filter.{u2} α} [_inst_1 : Filter.NeBot.{u2} α l] {a : β} {b : β}, Iff (Eq.{max (succ u2) (succ u1)} (Filter.Germ.{u2, u1} α l β) (Filter.Germ.const.{u2, u1} α β l a) (Filter.Germ.const.{u2, u1} α β l b)) (Eq.{succ u1} β a b)
-Case conversion may be inaccurate. Consider using '#align filter.germ.const_inj Filter.Germ.const_injₓ'. -/
 @[simp, norm_cast]
 theorem const_inj [NeBot l] {a b : β} : (↑a : Germ l β) = ↑b ↔ a = b :=
   coe_eq.trans <| const_eventuallyEq
 #align filter.germ.const_inj Filter.Germ.const_inj
 
-/- warning: filter.germ.map_const -> Filter.Germ.map_const is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {β : Type.{u2}} {γ : Type.{u3}} (l : Filter.{u1} α) (a : β) (f : β -> γ), Eq.{succ (max u1 u3)} (Filter.Germ.{u1, u3} α l γ) (Filter.Germ.map.{u1, u2, u3} α β γ l f ((fun (a : Type.{u2}) (b : Type.{max u1 u2}) [self : HasLiftT.{succ u2, succ (max u1 u2)} a b] => self.0) β (Filter.Germ.{u1, u2} α l β) (Filter.Germ.hasLiftT.{u1, u2} α β l) a)) ((fun (a : Type.{u3}) (b : Type.{max u1 u3}) [self : HasLiftT.{succ u3, succ (max u1 u3)} a b] => self.0) γ (Filter.Germ.{u1, u3} α l γ) (Filter.Germ.hasLiftT.{u1, u3} α γ l) (f a))
-but is expected to have type
-  forall {α : Type.{u3}} {β : Type.{u1}} {γ : Type.{u2}} (l : Filter.{u3} α) (a : β) (f : β -> γ), Eq.{max (succ u3) (succ u2)} (Filter.Germ.{u3, u2} α l γ) (Filter.Germ.map.{u3, u1, u2} α β γ l f (Filter.Germ.const.{u3, u1} α β l a)) (Filter.Germ.const.{u3, u2} α γ l (f a))
-Case conversion may be inaccurate. Consider using '#align filter.germ.map_const Filter.Germ.map_constₓ'. -/
 @[simp]
 theorem map_const (l : Filter α) (a : β) (f : β → γ) : (↑a : Germ l β).map f = ↑(f a) :=
   rfl
 #align filter.germ.map_const Filter.Germ.map_const
 
-/- warning: filter.germ.map₂_const -> Filter.Germ.map₂_const is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {β : Type.{u2}} {γ : Type.{u3}} {δ : Type.{u4}} (l : Filter.{u1} α) (b : β) (c : γ) (f : β -> γ -> δ), Eq.{succ (max u1 u4)} (Filter.Germ.{u1, u4} α l δ) (Filter.Germ.map₂.{u1, u2, u3, u4} α β γ δ l f ((fun (a : Type.{u2}) (b : Type.{max u1 u2}) [self : HasLiftT.{succ u2, succ (max u1 u2)} a b] => self.0) β (Filter.Germ.{u1, u2} α l β) (Filter.Germ.hasLiftT.{u1, u2} α β l) b) ((fun (a : Type.{u3}) (b : Type.{max u1 u3}) [self : HasLiftT.{succ u3, succ (max u1 u3)} a b] => self.0) γ (Filter.Germ.{u1, u3} α l γ) (Filter.Germ.hasLiftT.{u1, u3} α γ l) c)) ((fun (a : Type.{u4}) (b : Type.{max u1 u4}) [self : HasLiftT.{succ u4, succ (max u1 u4)} a b] => self.0) δ (Filter.Germ.{u1, u4} α l δ) (Filter.Germ.hasLiftT.{u1, u4} α δ l) (f b c))
-but is expected to have type
-  forall {α : Type.{u4}} {β : Type.{u2}} {γ : Type.{u1}} {δ : Type.{u3}} (l : Filter.{u4} α) (b : β) (c : γ) (f : β -> γ -> δ), Eq.{max (succ u4) (succ u3)} (Filter.Germ.{u4, u3} α l δ) (Filter.Germ.map₂.{u4, u2, u1, u3} α β γ δ l f (Filter.Germ.const.{u4, u2} α β l b) (Filter.Germ.const.{u4, u1} α γ l c)) (Filter.Germ.const.{u4, u3} α δ l (f b c))
-Case conversion may be inaccurate. Consider using '#align filter.germ.map₂_const Filter.Germ.map₂_constₓ'. -/
 @[simp]
 theorem map₂_const (l : Filter α) (b : β) (c : γ) (f : β → γ → δ) :
     map₂ f (↑b : Germ l β) ↑c = ↑(f b c) :=
   rfl
 #align filter.germ.map₂_const Filter.Germ.map₂_const
 
-/- warning: filter.germ.const_comp_tendsto -> Filter.Germ.const_compTendsto is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {β : Type.{u2}} {γ : Type.{u3}} {l : Filter.{u1} α} (b : β) {lc : Filter.{u3} γ} {g : γ -> α} (hg : Filter.Tendsto.{u3, u1} γ α g lc l), Eq.{succ (max u3 u2)} (Filter.Germ.{u3, u2} γ lc β) (Filter.Germ.compTendsto.{u1, u2, u3} α β γ l ((fun (a : Type.{u2}) (b : Type.{max u1 u2}) [self : HasLiftT.{succ u2, succ (max u1 u2)} a b] => self.0) β (Filter.Germ.{u1, u2} α l β) (Filter.Germ.hasLiftT.{u1, u2} α β l) b) lc g hg) ((fun (a : Type.{u2}) (b : Type.{max u3 u2}) [self : HasLiftT.{succ u2, succ (max u3 u2)} a b] => self.0) β (Filter.Germ.{u3, u2} γ lc β) (Filter.Germ.hasLiftT.{u3, u2} γ β lc) b)
-but is expected to have type
-  forall {α : Type.{u3}} {β : Type.{u1}} {γ : Type.{u2}} {l : Filter.{u3} α} (b : β) {lc : Filter.{u2} γ} {g : γ -> α} (hg : Filter.Tendsto.{u2, u3} γ α g lc l), Eq.{max (succ u1) (succ u2)} (Filter.Germ.{u2, u1} γ lc β) (Filter.Germ.compTendsto.{u3, u1, u2} α β γ l (Filter.Germ.const.{u3, u1} α β l b) lc g hg) (Filter.Germ.const.{u2, u1} γ β lc b)
-Case conversion may be inaccurate. Consider using '#align filter.germ.const_comp_tendsto Filter.Germ.const_compTendstoₓ'. -/
 @[simp]
 theorem const_compTendsto {l : Filter α} (b : β) {lc : Filter γ} {g : γ → α} (hg : Tendsto g lc l) :
     (↑b : Germ l β).comp_tendsto g hg = ↑b :=
   rfl
 #align filter.germ.const_comp_tendsto Filter.Germ.const_compTendsto
 
-/- warning: filter.germ.const_comp_tendsto' -> Filter.Germ.const_compTendsto' is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {β : Type.{u2}} {γ : Type.{u3}} {l : Filter.{u1} α} (b : β) {lc : Filter.{u3} γ} {g : Filter.Germ.{u3, u1} γ lc α} (hg : Filter.Germ.Tendsto.{u3, u1} γ α lc g l), Eq.{succ (max u3 u2)} (Filter.Germ.{u3, u2} γ lc β) (Filter.Germ.compTendsto'.{u1, u2, u3} α β γ l ((fun (a : Type.{u2}) (b : Type.{max u1 u2}) [self : HasLiftT.{succ u2, succ (max u1 u2)} a b] => self.0) β (Filter.Germ.{u1, u2} α l β) (Filter.Germ.hasLiftT.{u1, u2} α β l) b) lc g hg) ((fun (a : Type.{u2}) (b : Type.{max u3 u2}) [self : HasLiftT.{succ u2, succ (max u3 u2)} a b] => self.0) β (Filter.Germ.{u3, u2} γ lc β) (Filter.Germ.hasLiftT.{u3, u2} γ β lc) b)
-but is expected to have type
-  forall {α : Type.{u3}} {β : Type.{u1}} {γ : Type.{u2}} {l : Filter.{u3} α} (b : β) {lc : Filter.{u2} γ} {g : Filter.Germ.{u2, u3} γ lc α} (hg : Filter.Germ.Tendsto.{u2, u3} γ α lc g l), Eq.{max (succ u1) (succ u2)} (Filter.Germ.{u2, u1} γ lc β) (Filter.Germ.compTendsto'.{u3, u1, u2} α β γ l (Filter.Germ.const.{u3, u1} α β l b) lc g hg) (Filter.Germ.const.{u2, u1} γ β lc b)
-Case conversion may be inaccurate. Consider using '#align filter.germ.const_comp_tendsto' Filter.Germ.const_compTendsto'ₓ'. -/
 @[simp]
 theorem const_compTendsto' {l : Filter α} (b : β) {lc : Filter γ} {g : Germ lc α}
     (hg : g.Tendsto l) : (↑b : Germ l β).compTendsto' g hg = ↑b :=
@@ -456,33 +318,15 @@ def LiftPred (p : β → Prop) (f : Germ l β) : Prop :=
 #align filter.germ.lift_pred Filter.Germ.LiftPred
 -/
 
-/- warning: filter.germ.lift_pred_coe -> Filter.Germ.liftPred_coe is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {β : Type.{u2}} {l : Filter.{u1} α} {p : β -> Prop} {f : α -> β}, Iff (Filter.Germ.LiftPred.{u1, u2} α β l p ((fun (a : Sort.{max (succ u1) (succ u2)}) (b : Type.{max u1 u2}) [self : HasLiftT.{max (succ u1) (succ u2), succ (max u1 u2)} a b] => self.0) (α -> β) (Filter.Germ.{u1, u2} α l β) (HasLiftT.mk.{max (succ u1) (succ u2), succ (max u1 u2)} (α -> β) (Filter.Germ.{u1, u2} α l β) (CoeTCₓ.coe.{max (succ u1) (succ u2), succ (max u1 u2)} (α -> β) (Filter.Germ.{u1, u2} α l β) (Filter.Germ.hasCoeT.{u1, u2} α β l))) f)) (Filter.Eventually.{u1} α (fun (x : α) => p (f x)) l)
-but is expected to have type
-  forall {α : Type.{u2}} {β : Type.{u1}} {l : Filter.{u2} α} {p : β -> Prop} {f : α -> β}, Iff (Filter.Germ.LiftPred.{u2, u1} α β l p (Filter.Germ.ofFun.{u2, u1} α β l f)) (Filter.Eventually.{u2} α (fun (x : α) => p (f x)) l)
-Case conversion may be inaccurate. Consider using '#align filter.germ.lift_pred_coe Filter.Germ.liftPred_coeₓ'. -/
 @[simp]
 theorem liftPred_coe {p : β → Prop} {f : α → β} : LiftPred p (f : Germ l β) ↔ ∀ᶠ x in l, p (f x) :=
   Iff.rfl
 #align filter.germ.lift_pred_coe Filter.Germ.liftPred_coe
 
-/- warning: filter.germ.lift_pred_const -> Filter.Germ.liftPred_const is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {β : Type.{u2}} {l : Filter.{u1} α} {p : β -> Prop} {x : β}, (p x) -> (Filter.Germ.LiftPred.{u1, u2} α β l p ((fun (a : Type.{u2}) (b : Type.{max u1 u2}) [self : HasLiftT.{succ u2, succ (max u1 u2)} a b] => self.0) β (Filter.Germ.{u1, u2} α l β) (Filter.Germ.hasLiftT.{u1, u2} α β l) x))
-but is expected to have type
-  forall {α : Type.{u2}} {β : Type.{u1}} {l : Filter.{u2} α} {p : β -> Prop} {x : β}, (p x) -> (Filter.Germ.LiftPred.{u2, u1} α β l p (Filter.Germ.const.{u2, u1} α β l x))
-Case conversion may be inaccurate. Consider using '#align filter.germ.lift_pred_const Filter.Germ.liftPred_constₓ'. -/
 theorem liftPred_const {p : β → Prop} {x : β} (hx : p x) : LiftPred p (↑x : Germ l β) :=
   eventually_of_forall fun y => hx
 #align filter.germ.lift_pred_const Filter.Germ.liftPred_const
 
-/- warning: filter.germ.lift_pred_const_iff -> Filter.Germ.liftPred_const_iff is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {β : Type.{u2}} {l : Filter.{u1} α} [_inst_1 : Filter.NeBot.{u1} α l] {p : β -> Prop} {x : β}, Iff (Filter.Germ.LiftPred.{u1, u2} α β l p ((fun (a : Type.{u2}) (b : Type.{max u1 u2}) [self : HasLiftT.{succ u2, succ (max u1 u2)} a b] => self.0) β (Filter.Germ.{u1, u2} α l β) (Filter.Germ.hasLiftT.{u1, u2} α β l) x)) (p x)
-but is expected to have type
-  forall {α : Type.{u2}} {β : Type.{u1}} {l : Filter.{u2} α} [_inst_1 : Filter.NeBot.{u2} α l] {p : β -> Prop} {x : β}, Iff (Filter.Germ.LiftPred.{u2, u1} α β l p (Filter.Germ.const.{u2, u1} α β l x)) (p x)
-Case conversion may be inaccurate. Consider using '#align filter.germ.lift_pred_const_iff Filter.Germ.liftPred_const_iffₓ'. -/
 @[simp]
 theorem liftPred_const_iff [NeBot l] {p : β → Prop} {x : β} : LiftPred p (↑x : Germ l β) ↔ p x :=
   @eventually_const _ _ _ (p x)
@@ -496,35 +340,17 @@ def LiftRel (r : β → γ → Prop) (f : Germ l β) (g : Germ l γ) : Prop :=
 #align filter.germ.lift_rel Filter.Germ.LiftRel
 -/
 
-/- warning: filter.germ.lift_rel_coe -> Filter.Germ.liftRel_coe is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {β : Type.{u2}} {γ : Type.{u3}} {l : Filter.{u1} α} {r : β -> γ -> Prop} {f : α -> β} {g : α -> γ}, Iff (Filter.Germ.LiftRel.{u1, u2, u3} α β γ l r ((fun (a : Sort.{max (succ u1) (succ u2)}) (b : Type.{max u1 u2}) [self : HasLiftT.{max (succ u1) (succ u2), succ (max u1 u2)} a b] => self.0) (α -> β) (Filter.Germ.{u1, u2} α l β) (HasLiftT.mk.{max (succ u1) (succ u2), succ (max u1 u2)} (α -> β) (Filter.Germ.{u1, u2} α l β) (CoeTCₓ.coe.{max (succ u1) (succ u2), succ (max u1 u2)} (α -> β) (Filter.Germ.{u1, u2} α l β) (Filter.Germ.hasCoeT.{u1, u2} α β l))) f) ((fun (a : Sort.{max (succ u1) (succ u3)}) (b : Type.{max u1 u3}) [self : HasLiftT.{max (succ u1) (succ u3), succ (max u1 u3)} a b] => self.0) (α -> γ) (Filter.Germ.{u1, u3} α l γ) (HasLiftT.mk.{max (succ u1) (succ u3), succ (max u1 u3)} (α -> γ) (Filter.Germ.{u1, u3} α l γ) (CoeTCₓ.coe.{max (succ u1) (succ u3), succ (max u1 u3)} (α -> γ) (Filter.Germ.{u1, u3} α l γ) (Filter.Germ.hasCoeT.{u1, u3} α γ l))) g)) (Filter.Eventually.{u1} α (fun (x : α) => r (f x) (g x)) l)
-but is expected to have type
-  forall {α : Type.{u3}} {β : Type.{u2}} {γ : Type.{u1}} {l : Filter.{u3} α} {r : β -> γ -> Prop} {f : α -> β} {g : α -> γ}, Iff (Filter.Germ.LiftRel.{u3, u2, u1} α β γ l r (Filter.Germ.ofFun.{u3, u2} α β l f) (Filter.Germ.ofFun.{u3, u1} α γ l g)) (Filter.Eventually.{u3} α (fun (x : α) => r (f x) (g x)) l)
-Case conversion may be inaccurate. Consider using '#align filter.germ.lift_rel_coe Filter.Germ.liftRel_coeₓ'. -/
 @[simp]
 theorem liftRel_coe {r : β → γ → Prop} {f : α → β} {g : α → γ} :
     LiftRel r (f : Germ l β) g ↔ ∀ᶠ x in l, r (f x) (g x) :=
   Iff.rfl
 #align filter.germ.lift_rel_coe Filter.Germ.liftRel_coe
 
-/- warning: filter.germ.lift_rel_const -> Filter.Germ.liftRel_const is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {β : Type.{u2}} {γ : Type.{u3}} {l : Filter.{u1} α} {r : β -> γ -> Prop} {x : β} {y : γ}, (r x y) -> (Filter.Germ.LiftRel.{u1, u2, u3} α β γ l r ((fun (a : Type.{u2}) (b : Type.{max u1 u2}) [self : HasLiftT.{succ u2, succ (max u1 u2)} a b] => self.0) β (Filter.Germ.{u1, u2} α l β) (Filter.Germ.hasLiftT.{u1, u2} α β l) x) ((fun (a : Type.{u3}) (b : Type.{max u1 u3}) [self : HasLiftT.{succ u3, succ (max u1 u3)} a b] => self.0) γ (Filter.Germ.{u1, u3} α l γ) (Filter.Germ.hasLiftT.{u1, u3} α γ l) y))
-but is expected to have type
-  forall {α : Type.{u3}} {β : Type.{u2}} {γ : Type.{u1}} {l : Filter.{u3} α} {r : β -> γ -> Prop} {x : β} {y : γ}, (r x y) -> (Filter.Germ.LiftRel.{u3, u2, u1} α β γ l r (Filter.Germ.const.{u3, u2} α β l x) (Filter.Germ.const.{u3, u1} α γ l y))
-Case conversion may be inaccurate. Consider using '#align filter.germ.lift_rel_const Filter.Germ.liftRel_constₓ'. -/
 theorem liftRel_const {r : β → γ → Prop} {x : β} {y : γ} (h : r x y) :
     LiftRel r (↑x : Germ l β) ↑y :=
   eventually_of_forall fun _ => h
 #align filter.germ.lift_rel_const Filter.Germ.liftRel_const
 
-/- warning: filter.germ.lift_rel_const_iff -> Filter.Germ.liftRel_const_iff is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {β : Type.{u2}} {γ : Type.{u3}} {l : Filter.{u1} α} [_inst_1 : Filter.NeBot.{u1} α l] {r : β -> γ -> Prop} {x : β} {y : γ}, Iff (Filter.Germ.LiftRel.{u1, u2, u3} α β γ l r ((fun (a : Type.{u2}) (b : Type.{max u1 u2}) [self : HasLiftT.{succ u2, succ (max u1 u2)} a b] => self.0) β (Filter.Germ.{u1, u2} α l β) (Filter.Germ.hasLiftT.{u1, u2} α β l) x) ((fun (a : Type.{u3}) (b : Type.{max u1 u3}) [self : HasLiftT.{succ u3, succ (max u1 u3)} a b] => self.0) γ (Filter.Germ.{u1, u3} α l γ) (Filter.Germ.hasLiftT.{u1, u3} α γ l) y)) (r x y)
-but is expected to have type
-  forall {α : Type.{u3}} {β : Type.{u2}} {γ : Type.{u1}} {l : Filter.{u3} α} [_inst_1 : Filter.NeBot.{u3} α l] {r : β -> γ -> Prop} {x : β} {y : γ}, Iff (Filter.Germ.LiftRel.{u3, u2, u1} α β γ l r (Filter.Germ.const.{u3, u2} α β l x) (Filter.Germ.const.{u3, u1} α γ l y)) (r x y)
-Case conversion may be inaccurate. Consider using '#align filter.germ.lift_rel_const_iff Filter.Germ.liftRel_const_iffₓ'. -/
 @[simp]
 theorem liftRel_const_iff [NeBot l] {r : β → γ → Prop} {x : β} {y : γ} :
     LiftRel r (↑x : Germ l β) ↑y ↔ r x y :=
@@ -597,24 +423,12 @@ instance [SMul M G] : SMul M (Germ l G) :=
 instance [Pow G M] : Pow (Germ l G) M :=
   ⟨fun f n => map (· ^ n) f⟩
 
-/- warning: filter.germ.coe_smul -> Filter.Germ.coe_smul is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {l : Filter.{u1} α} {M : Type.{u2}} {G : Type.{u3}} [_inst_1 : SMul.{u2, u3} M G] (n : M) (f : α -> G), Eq.{succ (max u1 u3)} (Filter.Germ.{u1, u3} α l G) ((fun (a : Type.{max u1 u3}) (b : Type.{max u1 u3}) [self : HasLiftT.{succ (max u1 u3), succ (max u1 u3)} a b] => self.0) (α -> G) (Filter.Germ.{u1, u3} α l G) (HasLiftT.mk.{succ (max u1 u3), succ (max u1 u3)} (α -> G) (Filter.Germ.{u1, u3} α l G) (CoeTCₓ.coe.{succ (max u1 u3), succ (max u1 u3)} (α -> G) (Filter.Germ.{u1, u3} α l G) (Filter.Germ.hasCoeT.{u1, u3} α G l))) (SMul.smul.{u2, max u1 u3} M (α -> G) (Function.hasSMul.{u1, u2, u3} α M G _inst_1) n f)) (SMul.smul.{u2, max u1 u3} M (Filter.Germ.{u1, u3} α l G) (Filter.Germ.hasSmul.{u1, u2, u3} α l M G _inst_1) n ((fun (a : Sort.{max (succ u1) (succ u3)}) (b : Type.{max u1 u3}) [self : HasLiftT.{max (succ u1) (succ u3), succ (max u1 u3)} a b] => self.0) (α -> G) (Filter.Germ.{u1, u3} α l G) (HasLiftT.mk.{max (succ u1) (succ u3), succ (max u1 u3)} (α -> G) (Filter.Germ.{u1, u3} α l G) (CoeTCₓ.coe.{max (succ u1) (succ u3), succ (max u1 u3)} (α -> G) (Filter.Germ.{u1, u3} α l G) (Filter.Germ.hasCoeT.{u1, u3} α G l))) f))
-but is expected to have type
-  forall {α : Type.{u1}} {l : Filter.{u1} α} {M : Type.{u3}} {G : Type.{u2}} [_inst_1 : SMul.{u3, u2} M G] (n : M) (f : α -> G), Eq.{max (succ u1) (succ u2)} (Filter.Germ.{u1, u2} α l G) (Filter.Germ.ofFun.{u1, u2} α G l (HSMul.hSMul.{u3, max u1 u2, max u1 u2} M (α -> G) (α -> G) (instHSMul.{u3, max u1 u2} M (α -> G) (Pi.instSMul.{u1, u2, u3} α M (fun (a._@.Mathlib.Order.Filter.Germ._hyg.3203 : α) => G) (fun (i : α) => _inst_1))) n f)) (HSMul.hSMul.{u3, max u1 u2, max u1 u2} M (Filter.Germ.{u1, u2} α l G) (Filter.Germ.{u1, u2} α l G) (instHSMul.{u3, max u1 u2} M (Filter.Germ.{u1, u2} α l G) (Filter.Germ.smul.{u1, u3, u2} α l M G _inst_1)) n (Filter.Germ.ofFun.{u1, u2} α G l f))
-Case conversion may be inaccurate. Consider using '#align filter.germ.coe_smul Filter.Germ.coe_smulₓ'. -/
 @[simp, norm_cast, to_additive]
 theorem coe_smul [SMul M G] (n : M) (f : α → G) : ↑(n • f) = (n • f : Germ l G) :=
   rfl
 #align filter.germ.coe_smul Filter.Germ.coe_smul
 #align filter.germ.coe_vadd Filter.Germ.coe_vadd
 
-/- warning: filter.germ.const_smul -> Filter.Germ.const_smul is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {l : Filter.{u1} α} {M : Type.{u2}} {G : Type.{u3}} [_inst_1 : SMul.{u2, u3} M G] (n : M) (a : G), Eq.{succ (max u1 u3)} (Filter.Germ.{u1, u3} α l G) ((fun (a : Type.{u3}) (b : Type.{max u1 u3}) [self : HasLiftT.{succ u3, succ (max u1 u3)} a b] => self.0) G (Filter.Germ.{u1, u3} α l G) (Filter.Germ.hasLiftT.{u1, u3} α G l) (SMul.smul.{u2, u3} M G _inst_1 n a)) (SMul.smul.{u2, max u1 u3} M (Filter.Germ.{u1, u3} α l G) (Filter.Germ.hasSmul.{u1, u2, u3} α l M G _inst_1) n ((fun (a : Type.{u3}) (b : Type.{max u1 u3}) [self : HasLiftT.{succ u3, succ (max u1 u3)} a b] => self.0) G (Filter.Germ.{u1, u3} α l G) (Filter.Germ.hasLiftT.{u1, u3} α G l) a))
-but is expected to have type
-  forall {α : Type.{u1}} {l : Filter.{u1} α} {M : Type.{u3}} {G : Type.{u2}} [_inst_1 : SMul.{u3, u2} M G] (n : M) (a : G), Eq.{max (succ u1) (succ u2)} (Filter.Germ.{u1, u2} α l G) (Filter.Germ.const.{u1, u2} α G l (HSMul.hSMul.{u3, u2, u2} M G G (instHSMul.{u3, u2} M G _inst_1) n a)) (HSMul.hSMul.{u3, max u1 u2, max u1 u2} M (Filter.Germ.{u1, u2} α l G) (Filter.Germ.{u1, u2} α l G) (instHSMul.{u3, max u1 u2} M (Filter.Germ.{u1, u2} α l G) (Filter.Germ.smul.{u1, u3, u2} α l M G _inst_1)) n (Filter.Germ.const.{u1, u2} α G l a))
-Case conversion may be inaccurate. Consider using '#align filter.germ.const_smul Filter.Germ.const_smulₓ'. -/
 @[simp, norm_cast, to_additive]
 theorem const_smul [SMul M G] (n : M) (a : G) : (↑(n • a) : Germ l G) = n • ↑a :=
   rfl
@@ -648,12 +462,6 @@ def coeMulHom [Monoid M] (l : Filter α) : (α → M) →* Germ l M :=
 #align filter.germ.coe_add_hom Filter.Germ.coeAddHom
 -/
 
-/- warning: filter.germ.coe_coe_mul_hom -> Filter.Germ.coe_coeMulHom is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {l : Filter.{u1} α} {M : Type.{u2}} [_inst_1 : Monoid.{u2} M], Eq.{max (max (succ u1) (succ u2)) (succ (max u1 u2))} ((fun (_x : MonoidHom.{max u1 u2, max u1 u2} (α -> M) (Filter.Germ.{u1, u2} α l M) (Pi.mulOneClass.{u1, u2} α (fun (ᾰ : α) => M) (fun (i : α) => Monoid.toMulOneClass.{u2} M _inst_1)) (Monoid.toMulOneClass.{max u1 u2} (Filter.Germ.{u1, u2} α l M) (Filter.Germ.monoid.{u1, u2} α l M _inst_1))) => (α -> M) -> (Filter.Germ.{u1, u2} α l M)) (Filter.Germ.coeMulHom.{u1, u2} α M _inst_1 l)) (coeFn.{succ (max u1 u2), succ (max u1 u2)} (MonoidHom.{max u1 u2, max u1 u2} (α -> M) (Filter.Germ.{u1, u2} α l M) (Pi.mulOneClass.{u1, u2} α (fun (ᾰ : α) => M) (fun (i : α) => Monoid.toMulOneClass.{u2} M _inst_1)) (Monoid.toMulOneClass.{max u1 u2} (Filter.Germ.{u1, u2} α l M) (Filter.Germ.monoid.{u1, u2} α l M _inst_1))) (fun (_x : MonoidHom.{max u1 u2, max u1 u2} (α -> M) (Filter.Germ.{u1, u2} α l M) (Pi.mulOneClass.{u1, u2} α (fun (ᾰ : α) => M) (fun (i : α) => Monoid.toMulOneClass.{u2} M _inst_1)) (Monoid.toMulOneClass.{max u1 u2} (Filter.Germ.{u1, u2} α l M) (Filter.Germ.monoid.{u1, u2} α l M _inst_1))) => (α -> M) -> (Filter.Germ.{u1, u2} α l M)) (MonoidHom.hasCoeToFun.{max u1 u2, max u1 u2} (α -> M) (Filter.Germ.{u1, u2} α l M) (Pi.mulOneClass.{u1, u2} α (fun (ᾰ : α) => M) (fun (i : α) => Monoid.toMulOneClass.{u2} M _inst_1)) (Monoid.toMulOneClass.{max u1 u2} (Filter.Germ.{u1, u2} α l M) (Filter.Germ.monoid.{u1, u2} α l M _inst_1))) (Filter.Germ.coeMulHom.{u1, u2} α M _inst_1 l)) ((fun (a : Sort.{max (succ u1) (succ u2)}) (b : Type.{max u1 u2}) [self : HasLiftT.{max (succ u1) (succ u2), succ (max u1 u2)} a b] => self.0) (α -> M) (Filter.Germ.{u1, u2} α l M) (HasLiftT.mk.{max (succ u1) (succ u2), succ (max u1 u2)} (α -> M) (Filter.Germ.{u1, u2} α l M) (CoeTCₓ.coe.{max (succ u1) (succ u2), succ (max u1 u2)} (α -> M) (Filter.Germ.{u1, u2} α l M) (Filter.Germ.hasCoeT.{u1, u2} α M l))))
-but is expected to have type
-  forall {α : Type.{u1}} {l : Filter.{u1} α} {M : Type.{u2}} [_inst_1 : Monoid.{u2} M], Eq.{max (succ u1) (succ u2)} (forall (a : α -> M), (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2397 : α -> M) => Filter.Germ.{u1, u2} α l M) a) (FunLike.coe.{max (succ u1) (succ u2), max (succ u1) (succ u2), max (succ u1) (succ u2)} (MonoidHom.{max u1 u2, max u2 u1} (α -> M) (Filter.Germ.{u1, u2} α l M) (Pi.mulOneClass.{u1, u2} α (fun (a._@.Mathlib.Order.Filter.Germ._hyg.3518 : α) => M) (fun (i : α) => Monoid.toMulOneClass.{u2} M _inst_1)) (Monoid.toMulOneClass.{max u1 u2} (Filter.Germ.{u1, u2} α l M) (Filter.Germ.monoid.{u1, u2} α l M _inst_1))) (α -> M) (fun (_x : α -> M) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2397 : α -> M) => Filter.Germ.{u1, u2} α l M) _x) (MulHomClass.toFunLike.{max u1 u2, max u1 u2, max u1 u2} (MonoidHom.{max u1 u2, max u2 u1} (α -> M) (Filter.Germ.{u1, u2} α l M) (Pi.mulOneClass.{u1, u2} α (fun (a._@.Mathlib.Order.Filter.Germ._hyg.3518 : α) => M) (fun (i : α) => Monoid.toMulOneClass.{u2} M _inst_1)) (Monoid.toMulOneClass.{max u1 u2} (Filter.Germ.{u1, u2} α l M) (Filter.Germ.monoid.{u1, u2} α l M _inst_1))) (α -> M) (Filter.Germ.{u1, u2} α l M) (MulOneClass.toMul.{max u1 u2} (α -> M) (Pi.mulOneClass.{u1, u2} α (fun (a._@.Mathlib.Order.Filter.Germ._hyg.3518 : α) => M) (fun (i : α) => Monoid.toMulOneClass.{u2} M _inst_1))) (MulOneClass.toMul.{max u1 u2} (Filter.Germ.{u1, u2} α l M) (Monoid.toMulOneClass.{max u1 u2} (Filter.Germ.{u1, u2} α l M) (Filter.Germ.monoid.{u1, u2} α l M _inst_1))) (MonoidHomClass.toMulHomClass.{max u1 u2, max u1 u2, max u1 u2} (MonoidHom.{max u1 u2, max u2 u1} (α -> M) (Filter.Germ.{u1, u2} α l M) (Pi.mulOneClass.{u1, u2} α (fun (a._@.Mathlib.Order.Filter.Germ._hyg.3518 : α) => M) (fun (i : α) => Monoid.toMulOneClass.{u2} M _inst_1)) (Monoid.toMulOneClass.{max u1 u2} (Filter.Germ.{u1, u2} α l M) (Filter.Germ.monoid.{u1, u2} α l M _inst_1))) (α -> M) (Filter.Germ.{u1, u2} α l M) (Pi.mulOneClass.{u1, u2} α (fun (a._@.Mathlib.Order.Filter.Germ._hyg.3518 : α) => M) (fun (i : α) => Monoid.toMulOneClass.{u2} M _inst_1)) (Monoid.toMulOneClass.{max u1 u2} (Filter.Germ.{u1, u2} α l M) (Filter.Germ.monoid.{u1, u2} α l M _inst_1)) (MonoidHom.monoidHomClass.{max u1 u2, max u1 u2} (α -> M) (Filter.Germ.{u1, u2} α l M) (Pi.mulOneClass.{u1, u2} α (fun (a._@.Mathlib.Order.Filter.Germ._hyg.3518 : α) => M) (fun (i : α) => Monoid.toMulOneClass.{u2} M _inst_1)) (Monoid.toMulOneClass.{max u1 u2} (Filter.Germ.{u1, u2} α l M) (Filter.Germ.monoid.{u1, u2} α l M _inst_1))))) (Filter.Germ.coeMulHom.{u1, u2} α M _inst_1 l)) (Filter.Germ.ofFun.{u1, u2} α M l)
-Case conversion may be inaccurate. Consider using '#align filter.germ.coe_coe_mul_hom Filter.Germ.coe_coeMulHomₓ'. -/
 @[simp, to_additive]
 theorem coe_coeMulHom [Monoid M] : (coeMulHom l : (α → M) → Germ l M) = coe :=
   rfl
@@ -768,12 +576,6 @@ def coeRingHom [Semiring R] (l : Filter α) : (α → R) →+* Germ l R :=
 #align filter.germ.coe_ring_hom Filter.Germ.coeRingHom
 -/
 
-/- warning: filter.germ.coe_coe_ring_hom -> Filter.Germ.coe_coeRingHom is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {l : Filter.{u1} α} {R : Type.{u2}} [_inst_1 : Semiring.{u2} R], Eq.{max (max (succ u1) (succ u2)) (succ (max u1 u2))} ((fun (_x : RingHom.{max u1 u2, max u1 u2} (α -> R) (Filter.Germ.{u1, u2} α l R) (Pi.nonAssocSemiring.{u1, u2} α (fun (ᾰ : α) => R) (fun (i : α) => Semiring.toNonAssocSemiring.{u2} R _inst_1)) (Semiring.toNonAssocSemiring.{max u1 u2} (Filter.Germ.{u1, u2} α l R) (Filter.Germ.semiring.{u1, u2} α l R _inst_1))) => (α -> R) -> (Filter.Germ.{u1, u2} α l R)) (Filter.Germ.coeRingHom.{u1, u2} α R _inst_1 l)) (coeFn.{succ (max u1 u2), succ (max u1 u2)} (RingHom.{max u1 u2, max u1 u2} (α -> R) (Filter.Germ.{u1, u2} α l R) (Pi.nonAssocSemiring.{u1, u2} α (fun (ᾰ : α) => R) (fun (i : α) => Semiring.toNonAssocSemiring.{u2} R _inst_1)) (Semiring.toNonAssocSemiring.{max u1 u2} (Filter.Germ.{u1, u2} α l R) (Filter.Germ.semiring.{u1, u2} α l R _inst_1))) (fun (_x : RingHom.{max u1 u2, max u1 u2} (α -> R) (Filter.Germ.{u1, u2} α l R) (Pi.nonAssocSemiring.{u1, u2} α (fun (ᾰ : α) => R) (fun (i : α) => Semiring.toNonAssocSemiring.{u2} R _inst_1)) (Semiring.toNonAssocSemiring.{max u1 u2} (Filter.Germ.{u1, u2} α l R) (Filter.Germ.semiring.{u1, u2} α l R _inst_1))) => (α -> R) -> (Filter.Germ.{u1, u2} α l R)) (RingHom.hasCoeToFun.{max u1 u2, max u1 u2} (α -> R) (Filter.Germ.{u1, u2} α l R) (Pi.nonAssocSemiring.{u1, u2} α (fun (ᾰ : α) => R) (fun (i : α) => Semiring.toNonAssocSemiring.{u2} R _inst_1)) (Semiring.toNonAssocSemiring.{max u1 u2} (Filter.Germ.{u1, u2} α l R) (Filter.Germ.semiring.{u1, u2} α l R _inst_1))) (Filter.Germ.coeRingHom.{u1, u2} α R _inst_1 l)) ((fun (a : Sort.{max (succ u1) (succ u2)}) (b : Type.{max u1 u2}) [self : HasLiftT.{max (succ u1) (succ u2), succ (max u1 u2)} a b] => self.0) (α -> R) (Filter.Germ.{u1, u2} α l R) (HasLiftT.mk.{max (succ u1) (succ u2), succ (max u1 u2)} (α -> R) (Filter.Germ.{u1, u2} α l R) (CoeTCₓ.coe.{max (succ u1) (succ u2), succ (max u1 u2)} (α -> R) (Filter.Germ.{u1, u2} α l R) (Filter.Germ.hasCoeT.{u1, u2} α R l))))
-but is expected to have type
-  forall {α : Type.{u1}} {l : Filter.{u1} α} {R : Type.{u2}} [_inst_1 : Semiring.{u2} R], Eq.{max (succ u1) (succ u2)} (forall (a : α -> R), (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2397 : α -> R) => Filter.Germ.{u1, u2} α l R) a) (FunLike.coe.{max (succ u1) (succ u2), max (succ u1) (succ u2), max (succ u1) (succ u2)} (RingHom.{max u1 u2, max u2 u1} (α -> R) (Filter.Germ.{u1, u2} α l R) (Pi.nonAssocSemiring.{u1, u2} α (fun (a._@.Mathlib.Order.Filter.Germ._hyg.4920 : α) => R) (fun (i : α) => Semiring.toNonAssocSemiring.{u2} R _inst_1)) (Semiring.toNonAssocSemiring.{max u1 u2} (Filter.Germ.{u1, u2} α l R) (Filter.Germ.semiring.{u1, u2} α l R _inst_1))) (α -> R) (fun (_x : α -> R) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2397 : α -> R) => Filter.Germ.{u1, u2} α l R) _x) (MulHomClass.toFunLike.{max u1 u2, max u1 u2, max u1 u2} (RingHom.{max u1 u2, max u2 u1} (α -> R) (Filter.Germ.{u1, u2} α l R) (Pi.nonAssocSemiring.{u1, u2} α (fun (a._@.Mathlib.Order.Filter.Germ._hyg.4920 : α) => R) (fun (i : α) => Semiring.toNonAssocSemiring.{u2} R _inst_1)) (Semiring.toNonAssocSemiring.{max u1 u2} (Filter.Germ.{u1, u2} α l R) (Filter.Germ.semiring.{u1, u2} α l R _inst_1))) (α -> R) (Filter.Germ.{u1, u2} α l R) (NonUnitalNonAssocSemiring.toMul.{max u1 u2} (α -> R) (NonAssocSemiring.toNonUnitalNonAssocSemiring.{max u1 u2} (α -> R) (Pi.nonAssocSemiring.{u1, u2} α (fun (a._@.Mathlib.Order.Filter.Germ._hyg.4920 : α) => R) (fun (i : α) => Semiring.toNonAssocSemiring.{u2} R _inst_1)))) (NonUnitalNonAssocSemiring.toMul.{max u1 u2} (Filter.Germ.{u1, u2} α l R) (NonAssocSemiring.toNonUnitalNonAssocSemiring.{max u1 u2} (Filter.Germ.{u1, u2} α l R) (Semiring.toNonAssocSemiring.{max u1 u2} (Filter.Germ.{u1, u2} α l R) (Filter.Germ.semiring.{u1, u2} α l R _inst_1)))) (NonUnitalRingHomClass.toMulHomClass.{max u1 u2, max u1 u2, max u1 u2} (RingHom.{max u1 u2, max u2 u1} (α -> R) (Filter.Germ.{u1, u2} α l R) (Pi.nonAssocSemiring.{u1, u2} α (fun (a._@.Mathlib.Order.Filter.Germ._hyg.4920 : α) => R) (fun (i : α) => Semiring.toNonAssocSemiring.{u2} R _inst_1)) (Semiring.toNonAssocSemiring.{max u1 u2} (Filter.Germ.{u1, u2} α l R) (Filter.Germ.semiring.{u1, u2} α l R _inst_1))) (α -> R) (Filter.Germ.{u1, u2} α l R) (NonAssocSemiring.toNonUnitalNonAssocSemiring.{max u1 u2} (α -> R) (Pi.nonAssocSemiring.{u1, u2} α (fun (a._@.Mathlib.Order.Filter.Germ._hyg.4920 : α) => R) (fun (i : α) => Semiring.toNonAssocSemiring.{u2} R _inst_1))) (NonAssocSemiring.toNonUnitalNonAssocSemiring.{max u1 u2} (Filter.Germ.{u1, u2} α l R) (Semiring.toNonAssocSemiring.{max u1 u2} (Filter.Germ.{u1, u2} α l R) (Filter.Germ.semiring.{u1, u2} α l R _inst_1))) (RingHomClass.toNonUnitalRingHomClass.{max u1 u2, max u1 u2, max u1 u2} (RingHom.{max u1 u2, max u2 u1} (α -> R) (Filter.Germ.{u1, u2} α l R) (Pi.nonAssocSemiring.{u1, u2} α (fun (a._@.Mathlib.Order.Filter.Germ._hyg.4920 : α) => R) (fun (i : α) => Semiring.toNonAssocSemiring.{u2} R _inst_1)) (Semiring.toNonAssocSemiring.{max u1 u2} (Filter.Germ.{u1, u2} α l R) (Filter.Germ.semiring.{u1, u2} α l R _inst_1))) (α -> R) (Filter.Germ.{u1, u2} α l R) (Pi.nonAssocSemiring.{u1, u2} α (fun (a._@.Mathlib.Order.Filter.Germ._hyg.4920 : α) => R) (fun (i : α) => Semiring.toNonAssocSemiring.{u2} R _inst_1)) (Semiring.toNonAssocSemiring.{max u1 u2} (Filter.Germ.{u1, u2} α l R) (Filter.Germ.semiring.{u1, u2} α l R _inst_1)) (RingHom.instRingHomClassRingHom.{max u1 u2, max u1 u2} (α -> R) (Filter.Germ.{u1, u2} α l R) (Pi.nonAssocSemiring.{u1, u2} α (fun (a._@.Mathlib.Order.Filter.Germ._hyg.4920 : α) => R) (fun (i : α) => Semiring.toNonAssocSemiring.{u2} R _inst_1)) (Semiring.toNonAssocSemiring.{max u1 u2} (Filter.Germ.{u1, u2} α l R) (Filter.Germ.semiring.{u1, u2} α l R _inst_1)))))) (Filter.Germ.coeRingHom.{u1, u2} α R _inst_1 l)) (Filter.Germ.ofFun.{u1, u2} α R l)
-Case conversion may be inaccurate. Consider using '#align filter.germ.coe_coe_ring_hom Filter.Germ.coe_coeRingHomₓ'. -/
 @[simp]
 theorem coe_coeRingHom [Semiring R] : (coeRingHom l : (α → R) → Germ l R) = coe :=
   rfl

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

@@ -285,10 +285,7 @@ but is expected to have type
   forall {α : Type.{u2}} {β : Type.{u1}} {l : Filter.{u2} α}, Eq.{max (succ u2) (succ u1)} ((Filter.Germ.{u2, u1} α l β) -> (Filter.Germ.{u2, u1} α l β)) (Filter.Germ.map.{u2, u1, u1} α β β l (id.{succ u1} β)) (id.{max (succ u2) (succ u1)} (Filter.Germ.{u2, u1} α l β))
 Case conversion may be inaccurate. Consider using '#align filter.germ.map_id Filter.Germ.map_idₓ'. -/
 @[simp]
-theorem map_id : map id = (id : Germ l β → Germ l β) :=
-  by
-  ext ⟨f⟩
-  rfl
+theorem map_id : map id = (id : Germ l β → Germ l β) := by ext ⟨f⟩; rfl
 #align filter.germ.map_id Filter.Germ.map_id
 
 /- warning: filter.germ.map_map -> Filter.Germ.map_map is a dubious translation:
@@ -725,9 +722,7 @@ instance [Group G] : Group (Germ l G) :=
   { Germ.divInvMonoid with
     mul := (· * ·)
     one := 1
-    mul_left_inv := by
-      rintro ⟨f⟩
-      exact congr_arg (Quot.mk _) (mul_left_inv f) }
+    mul_left_inv := by rintro ⟨f⟩; exact congr_arg (Quot.mk _) (mul_left_inv f) }
 
 @[to_additive]
 instance [CommGroup G] : CommGroup (Germ l G) :=
@@ -753,27 +748,15 @@ instance [MulZeroClass R] : MulZeroClass (Germ l R)
     where
   zero := 0
   mul := (· * ·)
-  mul_zero f :=
-    inductionOn f fun f => by
-      norm_cast
-      rw [MulZeroClass.mul_zero]
-  zero_mul f :=
-    inductionOn f fun f => by
-      norm_cast
-      rw [MulZeroClass.zero_mul]
+  mul_zero f := inductionOn f fun f => by norm_cast; rw [MulZeroClass.mul_zero]
+  zero_mul f := inductionOn f fun f => by norm_cast; rw [MulZeroClass.zero_mul]
 
 instance [Distrib R] : Distrib (Germ l R)
     where
   mul := (· * ·)
   add := (· + ·)
-  left_distrib f g h :=
-    inductionOn₃ f g h fun f g h => by
-      norm_cast
-      rw [left_distrib]
-  right_distrib f g h :=
-    inductionOn₃ f g h fun f g h => by
-      norm_cast
-      rw [right_distrib]
+  left_distrib f g h := inductionOn₃ f g h fun f g h => by norm_cast; rw [left_distrib]
+  right_distrib f g h := inductionOn₃ f g h fun f g h => by norm_cast; rw [right_distrib]
 
 instance [Semiring R] : Semiring (Germ l R) :=
   { Germ.addCommMonoid, Germ.monoid, Germ.distrib, Germ.mulZeroClass, Germ.addMonoidWithOne with }
@@ -830,66 +813,42 @@ theorem coe_smul' [SMul M β] (c : α → M) (f : α → β) : ↑(c • f) = (c
 @[to_additive]
 instance [Monoid M] [MulAction M β] : MulAction M (Germ l β)
     where
-  one_smul f :=
-    inductionOn f fun f => by
-      norm_cast
-      simp only [one_smul]
-  mul_smul c₁ c₂ f :=
-    inductionOn f fun f => by
-      norm_cast
-      simp only [mul_smul]
+  one_smul f := inductionOn f fun f => by norm_cast; simp only [one_smul]
+  mul_smul c₁ c₂ f := inductionOn f fun f => by norm_cast; simp only [mul_smul]
 
 #print Filter.Germ.mulAction' /-
 @[to_additive]
 instance mulAction' [Monoid M] [MulAction M β] : MulAction (Germ l M) (Germ l β)
     where
   one_smul f := inductionOn f fun f => by simp only [← coe_one, ← coe_smul', one_smul]
-  mul_smul c₁ c₂ f :=
-    inductionOn₃ c₁ c₂ f fun c₁ c₂ f => by
-      norm_cast
-      simp only [mul_smul]
+  mul_smul c₁ c₂ f := inductionOn₃ c₁ c₂ f fun c₁ c₂ f => by norm_cast; simp only [mul_smul]
 #align filter.germ.mul_action' Filter.Germ.mulAction'
 #align filter.germ.add_action' Filter.Germ.addAction'
 -/
 
 instance [Monoid M] [AddMonoid N] [DistribMulAction M N] : DistribMulAction M (Germ l N)
     where
-  smul_add c f g :=
-    inductionOn₂ f g fun f g => by
-      norm_cast
-      simp only [smul_add]
+  smul_add c f g := inductionOn₂ f g fun f g => by norm_cast; simp only [smul_add]
   smul_zero c := by simp only [← coe_zero, ← coe_smul, smul_zero]
 
 #print Filter.Germ.distribMulAction' /-
 instance distribMulAction' [Monoid M] [AddMonoid N] [DistribMulAction M N] :
     DistribMulAction (Germ l M) (Germ l N)
     where
-  smul_add c f g :=
-    inductionOn₃ c f g fun c f g => by
-      norm_cast
-      simp only [smul_add]
+  smul_add c f g := inductionOn₃ c f g fun c f g => by norm_cast; simp only [smul_add]
   smul_zero c := inductionOn c fun c => by simp only [← coe_zero, ← coe_smul', smul_zero]
 #align filter.germ.distrib_mul_action' Filter.Germ.distribMulAction'
 -/
 
 instance [Semiring R] [AddCommMonoid M] [Module R M] : Module R (Germ l M)
     where
-  add_smul c₁ c₂ f :=
-    inductionOn f fun f => by
-      norm_cast
-      simp only [add_smul]
-  zero_smul f :=
-    inductionOn f fun f => by
-      norm_cast
-      simp only [zero_smul, coe_zero]
+  add_smul c₁ c₂ f := inductionOn f fun f => by norm_cast; simp only [add_smul]
+  zero_smul f := inductionOn f fun f => by norm_cast; simp only [zero_smul, coe_zero]
 
 #print Filter.Germ.module' /-
 instance module' [Semiring R] [AddCommMonoid M] [Module R M] : Module (Germ l R) (Germ l M)
     where
-  add_smul c₁ c₂ f :=
-    inductionOn₃ c₁ c₂ f fun c₁ c₂ f => by
-      norm_cast
-      simp only [add_smul]
+  add_smul c₁ c₂ f := inductionOn₃ c₁ c₂ f fun c₁ c₂ f => by norm_cast; simp only [add_smul]
   zero_smul f := inductionOn f fun f => by simp only [← coe_zero, ← coe_smul', zero_smul]
 #align filter.germ.module' Filter.Germ.module'
 -/

mathlib commit https://github.com/leanprover-community/mathlib/commit/95a87616d63b3cb49d3fe678d416fbe9c4217bf4

@@ -655,7 +655,7 @@ def coeMulHom [Monoid M] (l : Filter α) : (α → M) →* Germ l M :=
 lean 3 declaration is
   forall {α : Type.{u1}} {l : Filter.{u1} α} {M : Type.{u2}} [_inst_1 : Monoid.{u2} M], Eq.{max (max (succ u1) (succ u2)) (succ (max u1 u2))} ((fun (_x : MonoidHom.{max u1 u2, max u1 u2} (α -> M) (Filter.Germ.{u1, u2} α l M) (Pi.mulOneClass.{u1, u2} α (fun (ᾰ : α) => M) (fun (i : α) => Monoid.toMulOneClass.{u2} M _inst_1)) (Monoid.toMulOneClass.{max u1 u2} (Filter.Germ.{u1, u2} α l M) (Filter.Germ.monoid.{u1, u2} α l M _inst_1))) => (α -> M) -> (Filter.Germ.{u1, u2} α l M)) (Filter.Germ.coeMulHom.{u1, u2} α M _inst_1 l)) (coeFn.{succ (max u1 u2), succ (max u1 u2)} (MonoidHom.{max u1 u2, max u1 u2} (α -> M) (Filter.Germ.{u1, u2} α l M) (Pi.mulOneClass.{u1, u2} α (fun (ᾰ : α) => M) (fun (i : α) => Monoid.toMulOneClass.{u2} M _inst_1)) (Monoid.toMulOneClass.{max u1 u2} (Filter.Germ.{u1, u2} α l M) (Filter.Germ.monoid.{u1, u2} α l M _inst_1))) (fun (_x : MonoidHom.{max u1 u2, max u1 u2} (α -> M) (Filter.Germ.{u1, u2} α l M) (Pi.mulOneClass.{u1, u2} α (fun (ᾰ : α) => M) (fun (i : α) => Monoid.toMulOneClass.{u2} M _inst_1)) (Monoid.toMulOneClass.{max u1 u2} (Filter.Germ.{u1, u2} α l M) (Filter.Germ.monoid.{u1, u2} α l M _inst_1))) => (α -> M) -> (Filter.Germ.{u1, u2} α l M)) (MonoidHom.hasCoeToFun.{max u1 u2, max u1 u2} (α -> M) (Filter.Germ.{u1, u2} α l M) (Pi.mulOneClass.{u1, u2} α (fun (ᾰ : α) => M) (fun (i : α) => Monoid.toMulOneClass.{u2} M _inst_1)) (Monoid.toMulOneClass.{max u1 u2} (Filter.Germ.{u1, u2} α l M) (Filter.Germ.monoid.{u1, u2} α l M _inst_1))) (Filter.Germ.coeMulHom.{u1, u2} α M _inst_1 l)) ((fun (a : Sort.{max (succ u1) (succ u2)}) (b : Type.{max u1 u2}) [self : HasLiftT.{max (succ u1) (succ u2), succ (max u1 u2)} a b] => self.0) (α -> M) (Filter.Germ.{u1, u2} α l M) (HasLiftT.mk.{max (succ u1) (succ u2), succ (max u1 u2)} (α -> M) (Filter.Germ.{u1, u2} α l M) (CoeTCₓ.coe.{max (succ u1) (succ u2), succ (max u1 u2)} (α -> M) (Filter.Germ.{u1, u2} α l M) (Filter.Germ.hasCoeT.{u1, u2} α M l))))
 but is expected to have type
-  forall {α : Type.{u1}} {l : Filter.{u1} α} {M : Type.{u2}} [_inst_1 : Monoid.{u2} M], Eq.{max (succ u1) (succ u2)} (forall (a : α -> M), (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : α -> M) => Filter.Germ.{u1, u2} α l M) a) (FunLike.coe.{max (succ u1) (succ u2), max (succ u1) (succ u2), max (succ u1) (succ u2)} (MonoidHom.{max u1 u2, max u2 u1} (α -> M) (Filter.Germ.{u1, u2} α l M) (Pi.mulOneClass.{u1, u2} α (fun (a._@.Mathlib.Order.Filter.Germ._hyg.3518 : α) => M) (fun (i : α) => Monoid.toMulOneClass.{u2} M _inst_1)) (Monoid.toMulOneClass.{max u1 u2} (Filter.Germ.{u1, u2} α l M) (Filter.Germ.monoid.{u1, u2} α l M _inst_1))) (α -> M) (fun (_x : α -> M) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : α -> M) => Filter.Germ.{u1, u2} α l M) _x) (MulHomClass.toFunLike.{max u1 u2, max u1 u2, max u1 u2} (MonoidHom.{max u1 u2, max u2 u1} (α -> M) (Filter.Germ.{u1, u2} α l M) (Pi.mulOneClass.{u1, u2} α (fun (a._@.Mathlib.Order.Filter.Germ._hyg.3518 : α) => M) (fun (i : α) => Monoid.toMulOneClass.{u2} M _inst_1)) (Monoid.toMulOneClass.{max u1 u2} (Filter.Germ.{u1, u2} α l M) (Filter.Germ.monoid.{u1, u2} α l M _inst_1))) (α -> M) (Filter.Germ.{u1, u2} α l M) (MulOneClass.toMul.{max u1 u2} (α -> M) (Pi.mulOneClass.{u1, u2} α (fun (a._@.Mathlib.Order.Filter.Germ._hyg.3518 : α) => M) (fun (i : α) => Monoid.toMulOneClass.{u2} M _inst_1))) (MulOneClass.toMul.{max u1 u2} (Filter.Germ.{u1, u2} α l M) (Monoid.toMulOneClass.{max u1 u2} (Filter.Germ.{u1, u2} α l M) (Filter.Germ.monoid.{u1, u2} α l M _inst_1))) (MonoidHomClass.toMulHomClass.{max u1 u2, max u1 u2, max u1 u2} (MonoidHom.{max u1 u2, max u2 u1} (α -> M) (Filter.Germ.{u1, u2} α l M) (Pi.mulOneClass.{u1, u2} α (fun (a._@.Mathlib.Order.Filter.Germ._hyg.3518 : α) => M) (fun (i : α) => Monoid.toMulOneClass.{u2} M _inst_1)) (Monoid.toMulOneClass.{max u1 u2} (Filter.Germ.{u1, u2} α l M) (Filter.Germ.monoid.{u1, u2} α l M _inst_1))) (α -> M) (Filter.Germ.{u1, u2} α l M) (Pi.mulOneClass.{u1, u2} α (fun (a._@.Mathlib.Order.Filter.Germ._hyg.3518 : α) => M) (fun (i : α) => Monoid.toMulOneClass.{u2} M _inst_1)) (Monoid.toMulOneClass.{max u1 u2} (Filter.Germ.{u1, u2} α l M) (Filter.Germ.monoid.{u1, u2} α l M _inst_1)) (MonoidHom.monoidHomClass.{max u1 u2, max u1 u2} (α -> M) (Filter.Germ.{u1, u2} α l M) (Pi.mulOneClass.{u1, u2} α (fun (a._@.Mathlib.Order.Filter.Germ._hyg.3518 : α) => M) (fun (i : α) => Monoid.toMulOneClass.{u2} M _inst_1)) (Monoid.toMulOneClass.{max u1 u2} (Filter.Germ.{u1, u2} α l M) (Filter.Germ.monoid.{u1, u2} α l M _inst_1))))) (Filter.Germ.coeMulHom.{u1, u2} α M _inst_1 l)) (Filter.Germ.ofFun.{u1, u2} α M l)
+  forall {α : Type.{u1}} {l : Filter.{u1} α} {M : Type.{u2}} [_inst_1 : Monoid.{u2} M], Eq.{max (succ u1) (succ u2)} (forall (a : α -> M), (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2397 : α -> M) => Filter.Germ.{u1, u2} α l M) a) (FunLike.coe.{max (succ u1) (succ u2), max (succ u1) (succ u2), max (succ u1) (succ u2)} (MonoidHom.{max u1 u2, max u2 u1} (α -> M) (Filter.Germ.{u1, u2} α l M) (Pi.mulOneClass.{u1, u2} α (fun (a._@.Mathlib.Order.Filter.Germ._hyg.3518 : α) => M) (fun (i : α) => Monoid.toMulOneClass.{u2} M _inst_1)) (Monoid.toMulOneClass.{max u1 u2} (Filter.Germ.{u1, u2} α l M) (Filter.Germ.monoid.{u1, u2} α l M _inst_1))) (α -> M) (fun (_x : α -> M) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2397 : α -> M) => Filter.Germ.{u1, u2} α l M) _x) (MulHomClass.toFunLike.{max u1 u2, max u1 u2, max u1 u2} (MonoidHom.{max u1 u2, max u2 u1} (α -> M) (Filter.Germ.{u1, u2} α l M) (Pi.mulOneClass.{u1, u2} α (fun (a._@.Mathlib.Order.Filter.Germ._hyg.3518 : α) => M) (fun (i : α) => Monoid.toMulOneClass.{u2} M _inst_1)) (Monoid.toMulOneClass.{max u1 u2} (Filter.Germ.{u1, u2} α l M) (Filter.Germ.monoid.{u1, u2} α l M _inst_1))) (α -> M) (Filter.Germ.{u1, u2} α l M) (MulOneClass.toMul.{max u1 u2} (α -> M) (Pi.mulOneClass.{u1, u2} α (fun (a._@.Mathlib.Order.Filter.Germ._hyg.3518 : α) => M) (fun (i : α) => Monoid.toMulOneClass.{u2} M _inst_1))) (MulOneClass.toMul.{max u1 u2} (Filter.Germ.{u1, u2} α l M) (Monoid.toMulOneClass.{max u1 u2} (Filter.Germ.{u1, u2} α l M) (Filter.Germ.monoid.{u1, u2} α l M _inst_1))) (MonoidHomClass.toMulHomClass.{max u1 u2, max u1 u2, max u1 u2} (MonoidHom.{max u1 u2, max u2 u1} (α -> M) (Filter.Germ.{u1, u2} α l M) (Pi.mulOneClass.{u1, u2} α (fun (a._@.Mathlib.Order.Filter.Germ._hyg.3518 : α) => M) (fun (i : α) => Monoid.toMulOneClass.{u2} M _inst_1)) (Monoid.toMulOneClass.{max u1 u2} (Filter.Germ.{u1, u2} α l M) (Filter.Germ.monoid.{u1, u2} α l M _inst_1))) (α -> M) (Filter.Germ.{u1, u2} α l M) (Pi.mulOneClass.{u1, u2} α (fun (a._@.Mathlib.Order.Filter.Germ._hyg.3518 : α) => M) (fun (i : α) => Monoid.toMulOneClass.{u2} M _inst_1)) (Monoid.toMulOneClass.{max u1 u2} (Filter.Germ.{u1, u2} α l M) (Filter.Germ.monoid.{u1, u2} α l M _inst_1)) (MonoidHom.monoidHomClass.{max u1 u2, max u1 u2} (α -> M) (Filter.Germ.{u1, u2} α l M) (Pi.mulOneClass.{u1, u2} α (fun (a._@.Mathlib.Order.Filter.Germ._hyg.3518 : α) => M) (fun (i : α) => Monoid.toMulOneClass.{u2} M _inst_1)) (Monoid.toMulOneClass.{max u1 u2} (Filter.Germ.{u1, u2} α l M) (Filter.Germ.monoid.{u1, u2} α l M _inst_1))))) (Filter.Germ.coeMulHom.{u1, u2} α M _inst_1 l)) (Filter.Germ.ofFun.{u1, u2} α M l)
 Case conversion may be inaccurate. Consider using '#align filter.germ.coe_coe_mul_hom Filter.Germ.coe_coeMulHomₓ'. -/
 @[simp, to_additive]
 theorem coe_coeMulHom [Monoid M] : (coeMulHom l : (α → M) → Germ l M) = coe :=
@@ -789,7 +789,7 @@ def coeRingHom [Semiring R] (l : Filter α) : (α → R) →+* Germ l R :=
 lean 3 declaration is
   forall {α : Type.{u1}} {l : Filter.{u1} α} {R : Type.{u2}} [_inst_1 : Semiring.{u2} R], Eq.{max (max (succ u1) (succ u2)) (succ (max u1 u2))} ((fun (_x : RingHom.{max u1 u2, max u1 u2} (α -> R) (Filter.Germ.{u1, u2} α l R) (Pi.nonAssocSemiring.{u1, u2} α (fun (ᾰ : α) => R) (fun (i : α) => Semiring.toNonAssocSemiring.{u2} R _inst_1)) (Semiring.toNonAssocSemiring.{max u1 u2} (Filter.Germ.{u1, u2} α l R) (Filter.Germ.semiring.{u1, u2} α l R _inst_1))) => (α -> R) -> (Filter.Germ.{u1, u2} α l R)) (Filter.Germ.coeRingHom.{u1, u2} α R _inst_1 l)) (coeFn.{succ (max u1 u2), succ (max u1 u2)} (RingHom.{max u1 u2, max u1 u2} (α -> R) (Filter.Germ.{u1, u2} α l R) (Pi.nonAssocSemiring.{u1, u2} α (fun (ᾰ : α) => R) (fun (i : α) => Semiring.toNonAssocSemiring.{u2} R _inst_1)) (Semiring.toNonAssocSemiring.{max u1 u2} (Filter.Germ.{u1, u2} α l R) (Filter.Germ.semiring.{u1, u2} α l R _inst_1))) (fun (_x : RingHom.{max u1 u2, max u1 u2} (α -> R) (Filter.Germ.{u1, u2} α l R) (Pi.nonAssocSemiring.{u1, u2} α (fun (ᾰ : α) => R) (fun (i : α) => Semiring.toNonAssocSemiring.{u2} R _inst_1)) (Semiring.toNonAssocSemiring.{max u1 u2} (Filter.Germ.{u1, u2} α l R) (Filter.Germ.semiring.{u1, u2} α l R _inst_1))) => (α -> R) -> (Filter.Germ.{u1, u2} α l R)) (RingHom.hasCoeToFun.{max u1 u2, max u1 u2} (α -> R) (Filter.Germ.{u1, u2} α l R) (Pi.nonAssocSemiring.{u1, u2} α (fun (ᾰ : α) => R) (fun (i : α) => Semiring.toNonAssocSemiring.{u2} R _inst_1)) (Semiring.toNonAssocSemiring.{max u1 u2} (Filter.Germ.{u1, u2} α l R) (Filter.Germ.semiring.{u1, u2} α l R _inst_1))) (Filter.Germ.coeRingHom.{u1, u2} α R _inst_1 l)) ((fun (a : Sort.{max (succ u1) (succ u2)}) (b : Type.{max u1 u2}) [self : HasLiftT.{max (succ u1) (succ u2), succ (max u1 u2)} a b] => self.0) (α -> R) (Filter.Germ.{u1, u2} α l R) (HasLiftT.mk.{max (succ u1) (succ u2), succ (max u1 u2)} (α -> R) (Filter.Germ.{u1, u2} α l R) (CoeTCₓ.coe.{max (succ u1) (succ u2), succ (max u1 u2)} (α -> R) (Filter.Germ.{u1, u2} α l R) (Filter.Germ.hasCoeT.{u1, u2} α R l))))
 but is expected to have type
-  forall {α : Type.{u1}} {l : Filter.{u1} α} {R : Type.{u2}} [_inst_1 : Semiring.{u2} R], Eq.{max (succ u1) (succ u2)} (forall (a : α -> R), (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : α -> R) => Filter.Germ.{u1, u2} α l R) a) (FunLike.coe.{max (succ u1) (succ u2), max (succ u1) (succ u2), max (succ u1) (succ u2)} (RingHom.{max u1 u2, max u2 u1} (α -> R) (Filter.Germ.{u1, u2} α l R) (Pi.nonAssocSemiring.{u1, u2} α (fun (a._@.Mathlib.Order.Filter.Germ._hyg.4920 : α) => R) (fun (i : α) => Semiring.toNonAssocSemiring.{u2} R _inst_1)) (Semiring.toNonAssocSemiring.{max u1 u2} (Filter.Germ.{u1, u2} α l R) (Filter.Germ.semiring.{u1, u2} α l R _inst_1))) (α -> R) (fun (_x : α -> R) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : α -> R) => Filter.Germ.{u1, u2} α l R) _x) (MulHomClass.toFunLike.{max u1 u2, max u1 u2, max u1 u2} (RingHom.{max u1 u2, max u2 u1} (α -> R) (Filter.Germ.{u1, u2} α l R) (Pi.nonAssocSemiring.{u1, u2} α (fun (a._@.Mathlib.Order.Filter.Germ._hyg.4920 : α) => R) (fun (i : α) => Semiring.toNonAssocSemiring.{u2} R _inst_1)) (Semiring.toNonAssocSemiring.{max u1 u2} (Filter.Germ.{u1, u2} α l R) (Filter.Germ.semiring.{u1, u2} α l R _inst_1))) (α -> R) (Filter.Germ.{u1, u2} α l R) (NonUnitalNonAssocSemiring.toMul.{max u1 u2} (α -> R) (NonAssocSemiring.toNonUnitalNonAssocSemiring.{max u1 u2} (α -> R) (Pi.nonAssocSemiring.{u1, u2} α (fun (a._@.Mathlib.Order.Filter.Germ._hyg.4920 : α) => R) (fun (i : α) => Semiring.toNonAssocSemiring.{u2} R _inst_1)))) (NonUnitalNonAssocSemiring.toMul.{max u1 u2} (Filter.Germ.{u1, u2} α l R) (NonAssocSemiring.toNonUnitalNonAssocSemiring.{max u1 u2} (Filter.Germ.{u1, u2} α l R) (Semiring.toNonAssocSemiring.{max u1 u2} (Filter.Germ.{u1, u2} α l R) (Filter.Germ.semiring.{u1, u2} α l R _inst_1)))) (NonUnitalRingHomClass.toMulHomClass.{max u1 u2, max u1 u2, max u1 u2} (RingHom.{max u1 u2, max u2 u1} (α -> R) (Filter.Germ.{u1, u2} α l R) (Pi.nonAssocSemiring.{u1, u2} α (fun (a._@.Mathlib.Order.Filter.Germ._hyg.4920 : α) => R) (fun (i : α) => Semiring.toNonAssocSemiring.{u2} R _inst_1)) (Semiring.toNonAssocSemiring.{max u1 u2} (Filter.Germ.{u1, u2} α l R) (Filter.Germ.semiring.{u1, u2} α l R _inst_1))) (α -> R) (Filter.Germ.{u1, u2} α l R) (NonAssocSemiring.toNonUnitalNonAssocSemiring.{max u1 u2} (α -> R) (Pi.nonAssocSemiring.{u1, u2} α (fun (a._@.Mathlib.Order.Filter.Germ._hyg.4920 : α) => R) (fun (i : α) => Semiring.toNonAssocSemiring.{u2} R _inst_1))) (NonAssocSemiring.toNonUnitalNonAssocSemiring.{max u1 u2} (Filter.Germ.{u1, u2} α l R) (Semiring.toNonAssocSemiring.{max u1 u2} (Filter.Germ.{u1, u2} α l R) (Filter.Germ.semiring.{u1, u2} α l R _inst_1))) (RingHomClass.toNonUnitalRingHomClass.{max u1 u2, max u1 u2, max u1 u2} (RingHom.{max u1 u2, max u2 u1} (α -> R) (Filter.Germ.{u1, u2} α l R) (Pi.nonAssocSemiring.{u1, u2} α (fun (a._@.Mathlib.Order.Filter.Germ._hyg.4920 : α) => R) (fun (i : α) => Semiring.toNonAssocSemiring.{u2} R _inst_1)) (Semiring.toNonAssocSemiring.{max u1 u2} (Filter.Germ.{u1, u2} α l R) (Filter.Germ.semiring.{u1, u2} α l R _inst_1))) (α -> R) (Filter.Germ.{u1, u2} α l R) (Pi.nonAssocSemiring.{u1, u2} α (fun (a._@.Mathlib.Order.Filter.Germ._hyg.4920 : α) => R) (fun (i : α) => Semiring.toNonAssocSemiring.{u2} R _inst_1)) (Semiring.toNonAssocSemiring.{max u1 u2} (Filter.Germ.{u1, u2} α l R) (Filter.Germ.semiring.{u1, u2} α l R _inst_1)) (RingHom.instRingHomClassRingHom.{max u1 u2, max u1 u2} (α -> R) (Filter.Germ.{u1, u2} α l R) (Pi.nonAssocSemiring.{u1, u2} α (fun (a._@.Mathlib.Order.Filter.Germ._hyg.4920 : α) => R) (fun (i : α) => Semiring.toNonAssocSemiring.{u2} R _inst_1)) (Semiring.toNonAssocSemiring.{max u1 u2} (Filter.Germ.{u1, u2} α l R) (Filter.Germ.semiring.{u1, u2} α l R _inst_1)))))) (Filter.Germ.coeRingHom.{u1, u2} α R _inst_1 l)) (Filter.Germ.ofFun.{u1, u2} α R l)
+  forall {α : Type.{u1}} {l : Filter.{u1} α} {R : Type.{u2}} [_inst_1 : Semiring.{u2} R], Eq.{max (succ u1) (succ u2)} (forall (a : α -> R), (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2397 : α -> R) => Filter.Germ.{u1, u2} α l R) a) (FunLike.coe.{max (succ u1) (succ u2), max (succ u1) (succ u2), max (succ u1) (succ u2)} (RingHom.{max u1 u2, max u2 u1} (α -> R) (Filter.Germ.{u1, u2} α l R) (Pi.nonAssocSemiring.{u1, u2} α (fun (a._@.Mathlib.Order.Filter.Germ._hyg.4920 : α) => R) (fun (i : α) => Semiring.toNonAssocSemiring.{u2} R _inst_1)) (Semiring.toNonAssocSemiring.{max u1 u2} (Filter.Germ.{u1, u2} α l R) (Filter.Germ.semiring.{u1, u2} α l R _inst_1))) (α -> R) (fun (_x : α -> R) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2397 : α -> R) => Filter.Germ.{u1, u2} α l R) _x) (MulHomClass.toFunLike.{max u1 u2, max u1 u2, max u1 u2} (RingHom.{max u1 u2, max u2 u1} (α -> R) (Filter.Germ.{u1, u2} α l R) (Pi.nonAssocSemiring.{u1, u2} α (fun (a._@.Mathlib.Order.Filter.Germ._hyg.4920 : α) => R) (fun (i : α) => Semiring.toNonAssocSemiring.{u2} R _inst_1)) (Semiring.toNonAssocSemiring.{max u1 u2} (Filter.Germ.{u1, u2} α l R) (Filter.Germ.semiring.{u1, u2} α l R _inst_1))) (α -> R) (Filter.Germ.{u1, u2} α l R) (NonUnitalNonAssocSemiring.toMul.{max u1 u2} (α -> R) (NonAssocSemiring.toNonUnitalNonAssocSemiring.{max u1 u2} (α -> R) (Pi.nonAssocSemiring.{u1, u2} α (fun (a._@.Mathlib.Order.Filter.Germ._hyg.4920 : α) => R) (fun (i : α) => Semiring.toNonAssocSemiring.{u2} R _inst_1)))) (NonUnitalNonAssocSemiring.toMul.{max u1 u2} (Filter.Germ.{u1, u2} α l R) (NonAssocSemiring.toNonUnitalNonAssocSemiring.{max u1 u2} (Filter.Germ.{u1, u2} α l R) (Semiring.toNonAssocSemiring.{max u1 u2} (Filter.Germ.{u1, u2} α l R) (Filter.Germ.semiring.{u1, u2} α l R _inst_1)))) (NonUnitalRingHomClass.toMulHomClass.{max u1 u2, max u1 u2, max u1 u2} (RingHom.{max u1 u2, max u2 u1} (α -> R) (Filter.Germ.{u1, u2} α l R) (Pi.nonAssocSemiring.{u1, u2} α (fun (a._@.Mathlib.Order.Filter.Germ._hyg.4920 : α) => R) (fun (i : α) => Semiring.toNonAssocSemiring.{u2} R _inst_1)) (Semiring.toNonAssocSemiring.{max u1 u2} (Filter.Germ.{u1, u2} α l R) (Filter.Germ.semiring.{u1, u2} α l R _inst_1))) (α -> R) (Filter.Germ.{u1, u2} α l R) (NonAssocSemiring.toNonUnitalNonAssocSemiring.{max u1 u2} (α -> R) (Pi.nonAssocSemiring.{u1, u2} α (fun (a._@.Mathlib.Order.Filter.Germ._hyg.4920 : α) => R) (fun (i : α) => Semiring.toNonAssocSemiring.{u2} R _inst_1))) (NonAssocSemiring.toNonUnitalNonAssocSemiring.{max u1 u2} (Filter.Germ.{u1, u2} α l R) (Semiring.toNonAssocSemiring.{max u1 u2} (Filter.Germ.{u1, u2} α l R) (Filter.Germ.semiring.{u1, u2} α l R _inst_1))) (RingHomClass.toNonUnitalRingHomClass.{max u1 u2, max u1 u2, max u1 u2} (RingHom.{max u1 u2, max u2 u1} (α -> R) (Filter.Germ.{u1, u2} α l R) (Pi.nonAssocSemiring.{u1, u2} α (fun (a._@.Mathlib.Order.Filter.Germ._hyg.4920 : α) => R) (fun (i : α) => Semiring.toNonAssocSemiring.{u2} R _inst_1)) (Semiring.toNonAssocSemiring.{max u1 u2} (Filter.Germ.{u1, u2} α l R) (Filter.Germ.semiring.{u1, u2} α l R _inst_1))) (α -> R) (Filter.Germ.{u1, u2} α l R) (Pi.nonAssocSemiring.{u1, u2} α (fun (a._@.Mathlib.Order.Filter.Germ._hyg.4920 : α) => R) (fun (i : α) => Semiring.toNonAssocSemiring.{u2} R _inst_1)) (Semiring.toNonAssocSemiring.{max u1 u2} (Filter.Germ.{u1, u2} α l R) (Filter.Germ.semiring.{u1, u2} α l R _inst_1)) (RingHom.instRingHomClassRingHom.{max u1 u2, max u1 u2} (α -> R) (Filter.Germ.{u1, u2} α l R) (Pi.nonAssocSemiring.{u1, u2} α (fun (a._@.Mathlib.Order.Filter.Germ._hyg.4920 : α) => R) (fun (i : α) => Semiring.toNonAssocSemiring.{u2} R _inst_1)) (Semiring.toNonAssocSemiring.{max u1 u2} (Filter.Germ.{u1, u2} α l R) (Filter.Germ.semiring.{u1, u2} α l R _inst_1)))))) (Filter.Germ.coeRingHom.{u1, u2} α R _inst_1 l)) (Filter.Germ.ofFun.{u1, u2} α R l)
 Case conversion may be inaccurate. Consider using '#align filter.germ.coe_coe_ring_hom Filter.Germ.coe_coeRingHomₓ'. -/
 @[simp]
 theorem coe_coeRingHom [Semiring R] : (coeRingHom l : (α → R) → Germ l R) = coe :=

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

@@ -655,7 +655,7 @@ def coeMulHom [Monoid M] (l : Filter α) : (α → M) →* Germ l M :=
 lean 3 declaration is
   forall {α : Type.{u1}} {l : Filter.{u1} α} {M : Type.{u2}} [_inst_1 : Monoid.{u2} M], Eq.{max (max (succ u1) (succ u2)) (succ (max u1 u2))} ((fun (_x : MonoidHom.{max u1 u2, max u1 u2} (α -> M) (Filter.Germ.{u1, u2} α l M) (Pi.mulOneClass.{u1, u2} α (fun (ᾰ : α) => M) (fun (i : α) => Monoid.toMulOneClass.{u2} M _inst_1)) (Monoid.toMulOneClass.{max u1 u2} (Filter.Germ.{u1, u2} α l M) (Filter.Germ.monoid.{u1, u2} α l M _inst_1))) => (α -> M) -> (Filter.Germ.{u1, u2} α l M)) (Filter.Germ.coeMulHom.{u1, u2} α M _inst_1 l)) (coeFn.{succ (max u1 u2), succ (max u1 u2)} (MonoidHom.{max u1 u2, max u1 u2} (α -> M) (Filter.Germ.{u1, u2} α l M) (Pi.mulOneClass.{u1, u2} α (fun (ᾰ : α) => M) (fun (i : α) => Monoid.toMulOneClass.{u2} M _inst_1)) (Monoid.toMulOneClass.{max u1 u2} (Filter.Germ.{u1, u2} α l M) (Filter.Germ.monoid.{u1, u2} α l M _inst_1))) (fun (_x : MonoidHom.{max u1 u2, max u1 u2} (α -> M) (Filter.Germ.{u1, u2} α l M) (Pi.mulOneClass.{u1, u2} α (fun (ᾰ : α) => M) (fun (i : α) => Monoid.toMulOneClass.{u2} M _inst_1)) (Monoid.toMulOneClass.{max u1 u2} (Filter.Germ.{u1, u2} α l M) (Filter.Germ.monoid.{u1, u2} α l M _inst_1))) => (α -> M) -> (Filter.Germ.{u1, u2} α l M)) (MonoidHom.hasCoeToFun.{max u1 u2, max u1 u2} (α -> M) (Filter.Germ.{u1, u2} α l M) (Pi.mulOneClass.{u1, u2} α (fun (ᾰ : α) => M) (fun (i : α) => Monoid.toMulOneClass.{u2} M _inst_1)) (Monoid.toMulOneClass.{max u1 u2} (Filter.Germ.{u1, u2} α l M) (Filter.Germ.monoid.{u1, u2} α l M _inst_1))) (Filter.Germ.coeMulHom.{u1, u2} α M _inst_1 l)) ((fun (a : Sort.{max (succ u1) (succ u2)}) (b : Type.{max u1 u2}) [self : HasLiftT.{max (succ u1) (succ u2), succ (max u1 u2)} a b] => self.0) (α -> M) (Filter.Germ.{u1, u2} α l M) (HasLiftT.mk.{max (succ u1) (succ u2), succ (max u1 u2)} (α -> M) (Filter.Germ.{u1, u2} α l M) (CoeTCₓ.coe.{max (succ u1) (succ u2), succ (max u1 u2)} (α -> M) (Filter.Germ.{u1, u2} α l M) (Filter.Germ.hasCoeT.{u1, u2} α M l))))
 but is expected to have type
-  forall {α : Type.{u1}} {l : Filter.{u1} α} {M : Type.{u2}} [_inst_1 : Monoid.{u2} M], Eq.{max (succ u1) (succ u2)} (forall (a : α -> M), (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2372 : α -> M) => Filter.Germ.{u1, u2} α l M) a) (FunLike.coe.{max (succ u1) (succ u2), max (succ u1) (succ u2), max (succ u1) (succ u2)} (MonoidHom.{max u1 u2, max u2 u1} (α -> M) (Filter.Germ.{u1, u2} α l M) (Pi.mulOneClass.{u1, u2} α (fun (a._@.Mathlib.Order.Filter.Germ._hyg.3518 : α) => M) (fun (i : α) => Monoid.toMulOneClass.{u2} M _inst_1)) (Monoid.toMulOneClass.{max u1 u2} (Filter.Germ.{u1, u2} α l M) (Filter.Germ.monoid.{u1, u2} α l M _inst_1))) (α -> M) (fun (_x : α -> M) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2372 : α -> M) => Filter.Germ.{u1, u2} α l M) _x) (MulHomClass.toFunLike.{max u1 u2, max u1 u2, max u1 u2} (MonoidHom.{max u1 u2, max u2 u1} (α -> M) (Filter.Germ.{u1, u2} α l M) (Pi.mulOneClass.{u1, u2} α (fun (a._@.Mathlib.Order.Filter.Germ._hyg.3518 : α) => M) (fun (i : α) => Monoid.toMulOneClass.{u2} M _inst_1)) (Monoid.toMulOneClass.{max u1 u2} (Filter.Germ.{u1, u2} α l M) (Filter.Germ.monoid.{u1, u2} α l M _inst_1))) (α -> M) (Filter.Germ.{u1, u2} α l M) (MulOneClass.toMul.{max u1 u2} (α -> M) (Pi.mulOneClass.{u1, u2} α (fun (a._@.Mathlib.Order.Filter.Germ._hyg.3518 : α) => M) (fun (i : α) => Monoid.toMulOneClass.{u2} M _inst_1))) (MulOneClass.toMul.{max u1 u2} (Filter.Germ.{u1, u2} α l M) (Monoid.toMulOneClass.{max u1 u2} (Filter.Germ.{u1, u2} α l M) (Filter.Germ.monoid.{u1, u2} α l M _inst_1))) (MonoidHomClass.toMulHomClass.{max u1 u2, max u1 u2, max u1 u2} (MonoidHom.{max u1 u2, max u2 u1} (α -> M) (Filter.Germ.{u1, u2} α l M) (Pi.mulOneClass.{u1, u2} α (fun (a._@.Mathlib.Order.Filter.Germ._hyg.3518 : α) => M) (fun (i : α) => Monoid.toMulOneClass.{u2} M _inst_1)) (Monoid.toMulOneClass.{max u1 u2} (Filter.Germ.{u1, u2} α l M) (Filter.Germ.monoid.{u1, u2} α l M _inst_1))) (α -> M) (Filter.Germ.{u1, u2} α l M) (Pi.mulOneClass.{u1, u2} α (fun (a._@.Mathlib.Order.Filter.Germ._hyg.3518 : α) => M) (fun (i : α) => Monoid.toMulOneClass.{u2} M _inst_1)) (Monoid.toMulOneClass.{max u1 u2} (Filter.Germ.{u1, u2} α l M) (Filter.Germ.monoid.{u1, u2} α l M _inst_1)) (MonoidHom.monoidHomClass.{max u1 u2, max u1 u2} (α -> M) (Filter.Germ.{u1, u2} α l M) (Pi.mulOneClass.{u1, u2} α (fun (a._@.Mathlib.Order.Filter.Germ._hyg.3518 : α) => M) (fun (i : α) => Monoid.toMulOneClass.{u2} M _inst_1)) (Monoid.toMulOneClass.{max u1 u2} (Filter.Germ.{u1, u2} α l M) (Filter.Germ.monoid.{u1, u2} α l M _inst_1))))) (Filter.Germ.coeMulHom.{u1, u2} α M _inst_1 l)) (Filter.Germ.ofFun.{u1, u2} α M l)
+  forall {α : Type.{u1}} {l : Filter.{u1} α} {M : Type.{u2}} [_inst_1 : Monoid.{u2} M], Eq.{max (succ u1) (succ u2)} (forall (a : α -> M), (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : α -> M) => Filter.Germ.{u1, u2} α l M) a) (FunLike.coe.{max (succ u1) (succ u2), max (succ u1) (succ u2), max (succ u1) (succ u2)} (MonoidHom.{max u1 u2, max u2 u1} (α -> M) (Filter.Germ.{u1, u2} α l M) (Pi.mulOneClass.{u1, u2} α (fun (a._@.Mathlib.Order.Filter.Germ._hyg.3518 : α) => M) (fun (i : α) => Monoid.toMulOneClass.{u2} M _inst_1)) (Monoid.toMulOneClass.{max u1 u2} (Filter.Germ.{u1, u2} α l M) (Filter.Germ.monoid.{u1, u2} α l M _inst_1))) (α -> M) (fun (_x : α -> M) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : α -> M) => Filter.Germ.{u1, u2} α l M) _x) (MulHomClass.toFunLike.{max u1 u2, max u1 u2, max u1 u2} (MonoidHom.{max u1 u2, max u2 u1} (α -> M) (Filter.Germ.{u1, u2} α l M) (Pi.mulOneClass.{u1, u2} α (fun (a._@.Mathlib.Order.Filter.Germ._hyg.3518 : α) => M) (fun (i : α) => Monoid.toMulOneClass.{u2} M _inst_1)) (Monoid.toMulOneClass.{max u1 u2} (Filter.Germ.{u1, u2} α l M) (Filter.Germ.monoid.{u1, u2} α l M _inst_1))) (α -> M) (Filter.Germ.{u1, u2} α l M) (MulOneClass.toMul.{max u1 u2} (α -> M) (Pi.mulOneClass.{u1, u2} α (fun (a._@.Mathlib.Order.Filter.Germ._hyg.3518 : α) => M) (fun (i : α) => Monoid.toMulOneClass.{u2} M _inst_1))) (MulOneClass.toMul.{max u1 u2} (Filter.Germ.{u1, u2} α l M) (Monoid.toMulOneClass.{max u1 u2} (Filter.Germ.{u1, u2} α l M) (Filter.Germ.monoid.{u1, u2} α l M _inst_1))) (MonoidHomClass.toMulHomClass.{max u1 u2, max u1 u2, max u1 u2} (MonoidHom.{max u1 u2, max u2 u1} (α -> M) (Filter.Germ.{u1, u2} α l M) (Pi.mulOneClass.{u1, u2} α (fun (a._@.Mathlib.Order.Filter.Germ._hyg.3518 : α) => M) (fun (i : α) => Monoid.toMulOneClass.{u2} M _inst_1)) (Monoid.toMulOneClass.{max u1 u2} (Filter.Germ.{u1, u2} α l M) (Filter.Germ.monoid.{u1, u2} α l M _inst_1))) (α -> M) (Filter.Germ.{u1, u2} α l M) (Pi.mulOneClass.{u1, u2} α (fun (a._@.Mathlib.Order.Filter.Germ._hyg.3518 : α) => M) (fun (i : α) => Monoid.toMulOneClass.{u2} M _inst_1)) (Monoid.toMulOneClass.{max u1 u2} (Filter.Germ.{u1, u2} α l M) (Filter.Germ.monoid.{u1, u2} α l M _inst_1)) (MonoidHom.monoidHomClass.{max u1 u2, max u1 u2} (α -> M) (Filter.Germ.{u1, u2} α l M) (Pi.mulOneClass.{u1, u2} α (fun (a._@.Mathlib.Order.Filter.Germ._hyg.3518 : α) => M) (fun (i : α) => Monoid.toMulOneClass.{u2} M _inst_1)) (Monoid.toMulOneClass.{max u1 u2} (Filter.Germ.{u1, u2} α l M) (Filter.Germ.monoid.{u1, u2} α l M _inst_1))))) (Filter.Germ.coeMulHom.{u1, u2} α M _inst_1 l)) (Filter.Germ.ofFun.{u1, u2} α M l)
 Case conversion may be inaccurate. Consider using '#align filter.germ.coe_coe_mul_hom Filter.Germ.coe_coeMulHomₓ'. -/
 @[simp, to_additive]
 theorem coe_coeMulHom [Monoid M] : (coeMulHom l : (α → M) → Germ l M) = coe :=
@@ -789,7 +789,7 @@ def coeRingHom [Semiring R] (l : Filter α) : (α → R) →+* Germ l R :=
 lean 3 declaration is
   forall {α : Type.{u1}} {l : Filter.{u1} α} {R : Type.{u2}} [_inst_1 : Semiring.{u2} R], Eq.{max (max (succ u1) (succ u2)) (succ (max u1 u2))} ((fun (_x : RingHom.{max u1 u2, max u1 u2} (α -> R) (Filter.Germ.{u1, u2} α l R) (Pi.nonAssocSemiring.{u1, u2} α (fun (ᾰ : α) => R) (fun (i : α) => Semiring.toNonAssocSemiring.{u2} R _inst_1)) (Semiring.toNonAssocSemiring.{max u1 u2} (Filter.Germ.{u1, u2} α l R) (Filter.Germ.semiring.{u1, u2} α l R _inst_1))) => (α -> R) -> (Filter.Germ.{u1, u2} α l R)) (Filter.Germ.coeRingHom.{u1, u2} α R _inst_1 l)) (coeFn.{succ (max u1 u2), succ (max u1 u2)} (RingHom.{max u1 u2, max u1 u2} (α -> R) (Filter.Germ.{u1, u2} α l R) (Pi.nonAssocSemiring.{u1, u2} α (fun (ᾰ : α) => R) (fun (i : α) => Semiring.toNonAssocSemiring.{u2} R _inst_1)) (Semiring.toNonAssocSemiring.{max u1 u2} (Filter.Germ.{u1, u2} α l R) (Filter.Germ.semiring.{u1, u2} α l R _inst_1))) (fun (_x : RingHom.{max u1 u2, max u1 u2} (α -> R) (Filter.Germ.{u1, u2} α l R) (Pi.nonAssocSemiring.{u1, u2} α (fun (ᾰ : α) => R) (fun (i : α) => Semiring.toNonAssocSemiring.{u2} R _inst_1)) (Semiring.toNonAssocSemiring.{max u1 u2} (Filter.Germ.{u1, u2} α l R) (Filter.Germ.semiring.{u1, u2} α l R _inst_1))) => (α -> R) -> (Filter.Germ.{u1, u2} α l R)) (RingHom.hasCoeToFun.{max u1 u2, max u1 u2} (α -> R) (Filter.Germ.{u1, u2} α l R) (Pi.nonAssocSemiring.{u1, u2} α (fun (ᾰ : α) => R) (fun (i : α) => Semiring.toNonAssocSemiring.{u2} R _inst_1)) (Semiring.toNonAssocSemiring.{max u1 u2} (Filter.Germ.{u1, u2} α l R) (Filter.Germ.semiring.{u1, u2} α l R _inst_1))) (Filter.Germ.coeRingHom.{u1, u2} α R _inst_1 l)) ((fun (a : Sort.{max (succ u1) (succ u2)}) (b : Type.{max u1 u2}) [self : HasLiftT.{max (succ u1) (succ u2), succ (max u1 u2)} a b] => self.0) (α -> R) (Filter.Germ.{u1, u2} α l R) (HasLiftT.mk.{max (succ u1) (succ u2), succ (max u1 u2)} (α -> R) (Filter.Germ.{u1, u2} α l R) (CoeTCₓ.coe.{max (succ u1) (succ u2), succ (max u1 u2)} (α -> R) (Filter.Germ.{u1, u2} α l R) (Filter.Germ.hasCoeT.{u1, u2} α R l))))
 but is expected to have type
-  forall {α : Type.{u1}} {l : Filter.{u1} α} {R : Type.{u2}} [_inst_1 : Semiring.{u2} R], Eq.{max (succ u1) (succ u2)} (forall (a : α -> R), (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2372 : α -> R) => Filter.Germ.{u1, u2} α l R) a) (FunLike.coe.{max (succ u1) (succ u2), max (succ u1) (succ u2), max (succ u1) (succ u2)} (RingHom.{max u1 u2, max u2 u1} (α -> R) (Filter.Germ.{u1, u2} α l R) (Pi.nonAssocSemiring.{u1, u2} α (fun (a._@.Mathlib.Order.Filter.Germ._hyg.4919 : α) => R) (fun (i : α) => Semiring.toNonAssocSemiring.{u2} R _inst_1)) (Semiring.toNonAssocSemiring.{max u1 u2} (Filter.Germ.{u1, u2} α l R) (Filter.Germ.semiring.{u1, u2} α l R _inst_1))) (α -> R) (fun (_x : α -> R) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2372 : α -> R) => Filter.Germ.{u1, u2} α l R) _x) (MulHomClass.toFunLike.{max u1 u2, max u1 u2, max u1 u2} (RingHom.{max u1 u2, max u2 u1} (α -> R) (Filter.Germ.{u1, u2} α l R) (Pi.nonAssocSemiring.{u1, u2} α (fun (a._@.Mathlib.Order.Filter.Germ._hyg.4919 : α) => R) (fun (i : α) => Semiring.toNonAssocSemiring.{u2} R _inst_1)) (Semiring.toNonAssocSemiring.{max u1 u2} (Filter.Germ.{u1, u2} α l R) (Filter.Germ.semiring.{u1, u2} α l R _inst_1))) (α -> R) (Filter.Germ.{u1, u2} α l R) (NonUnitalNonAssocSemiring.toMul.{max u1 u2} (α -> R) (NonAssocSemiring.toNonUnitalNonAssocSemiring.{max u1 u2} (α -> R) (Pi.nonAssocSemiring.{u1, u2} α (fun (a._@.Mathlib.Order.Filter.Germ._hyg.4919 : α) => R) (fun (i : α) => Semiring.toNonAssocSemiring.{u2} R _inst_1)))) (NonUnitalNonAssocSemiring.toMul.{max u1 u2} (Filter.Germ.{u1, u2} α l R) (NonAssocSemiring.toNonUnitalNonAssocSemiring.{max u1 u2} (Filter.Germ.{u1, u2} α l R) (Semiring.toNonAssocSemiring.{max u1 u2} (Filter.Germ.{u1, u2} α l R) (Filter.Germ.semiring.{u1, u2} α l R _inst_1)))) (NonUnitalRingHomClass.toMulHomClass.{max u1 u2, max u1 u2, max u1 u2} (RingHom.{max u1 u2, max u2 u1} (α -> R) (Filter.Germ.{u1, u2} α l R) (Pi.nonAssocSemiring.{u1, u2} α (fun (a._@.Mathlib.Order.Filter.Germ._hyg.4919 : α) => R) (fun (i : α) => Semiring.toNonAssocSemiring.{u2} R _inst_1)) (Semiring.toNonAssocSemiring.{max u1 u2} (Filter.Germ.{u1, u2} α l R) (Filter.Germ.semiring.{u1, u2} α l R _inst_1))) (α -> R) (Filter.Germ.{u1, u2} α l R) (NonAssocSemiring.toNonUnitalNonAssocSemiring.{max u1 u2} (α -> R) (Pi.nonAssocSemiring.{u1, u2} α (fun (a._@.Mathlib.Order.Filter.Germ._hyg.4919 : α) => R) (fun (i : α) => Semiring.toNonAssocSemiring.{u2} R _inst_1))) (NonAssocSemiring.toNonUnitalNonAssocSemiring.{max u1 u2} (Filter.Germ.{u1, u2} α l R) (Semiring.toNonAssocSemiring.{max u1 u2} (Filter.Germ.{u1, u2} α l R) (Filter.Germ.semiring.{u1, u2} α l R _inst_1))) (RingHomClass.toNonUnitalRingHomClass.{max u1 u2, max u1 u2, max u1 u2} (RingHom.{max u1 u2, max u2 u1} (α -> R) (Filter.Germ.{u1, u2} α l R) (Pi.nonAssocSemiring.{u1, u2} α (fun (a._@.Mathlib.Order.Filter.Germ._hyg.4919 : α) => R) (fun (i : α) => Semiring.toNonAssocSemiring.{u2} R _inst_1)) (Semiring.toNonAssocSemiring.{max u1 u2} (Filter.Germ.{u1, u2} α l R) (Filter.Germ.semiring.{u1, u2} α l R _inst_1))) (α -> R) (Filter.Germ.{u1, u2} α l R) (Pi.nonAssocSemiring.{u1, u2} α (fun (a._@.Mathlib.Order.Filter.Germ._hyg.4919 : α) => R) (fun (i : α) => Semiring.toNonAssocSemiring.{u2} R _inst_1)) (Semiring.toNonAssocSemiring.{max u1 u2} (Filter.Germ.{u1, u2} α l R) (Filter.Germ.semiring.{u1, u2} α l R _inst_1)) (RingHom.instRingHomClassRingHom.{max u1 u2, max u1 u2} (α -> R) (Filter.Germ.{u1, u2} α l R) (Pi.nonAssocSemiring.{u1, u2} α (fun (a._@.Mathlib.Order.Filter.Germ._hyg.4919 : α) => R) (fun (i : α) => Semiring.toNonAssocSemiring.{u2} R _inst_1)) (Semiring.toNonAssocSemiring.{max u1 u2} (Filter.Germ.{u1, u2} α l R) (Filter.Germ.semiring.{u1, u2} α l R _inst_1)))))) (Filter.Germ.coeRingHom.{u1, u2} α R _inst_1 l)) (Filter.Germ.ofFun.{u1, u2} α R l)
+  forall {α : Type.{u1}} {l : Filter.{u1} α} {R : Type.{u2}} [_inst_1 : Semiring.{u2} R], Eq.{max (succ u1) (succ u2)} (forall (a : α -> R), (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : α -> R) => Filter.Germ.{u1, u2} α l R) a) (FunLike.coe.{max (succ u1) (succ u2), max (succ u1) (succ u2), max (succ u1) (succ u2)} (RingHom.{max u1 u2, max u2 u1} (α -> R) (Filter.Germ.{u1, u2} α l R) (Pi.nonAssocSemiring.{u1, u2} α (fun (a._@.Mathlib.Order.Filter.Germ._hyg.4920 : α) => R) (fun (i : α) => Semiring.toNonAssocSemiring.{u2} R _inst_1)) (Semiring.toNonAssocSemiring.{max u1 u2} (Filter.Germ.{u1, u2} α l R) (Filter.Germ.semiring.{u1, u2} α l R _inst_1))) (α -> R) (fun (_x : α -> R) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : α -> R) => Filter.Germ.{u1, u2} α l R) _x) (MulHomClass.toFunLike.{max u1 u2, max u1 u2, max u1 u2} (RingHom.{max u1 u2, max u2 u1} (α -> R) (Filter.Germ.{u1, u2} α l R) (Pi.nonAssocSemiring.{u1, u2} α (fun (a._@.Mathlib.Order.Filter.Germ._hyg.4920 : α) => R) (fun (i : α) => Semiring.toNonAssocSemiring.{u2} R _inst_1)) (Semiring.toNonAssocSemiring.{max u1 u2} (Filter.Germ.{u1, u2} α l R) (Filter.Germ.semiring.{u1, u2} α l R _inst_1))) (α -> R) (Filter.Germ.{u1, u2} α l R) (NonUnitalNonAssocSemiring.toMul.{max u1 u2} (α -> R) (NonAssocSemiring.toNonUnitalNonAssocSemiring.{max u1 u2} (α -> R) (Pi.nonAssocSemiring.{u1, u2} α (fun (a._@.Mathlib.Order.Filter.Germ._hyg.4920 : α) => R) (fun (i : α) => Semiring.toNonAssocSemiring.{u2} R _inst_1)))) (NonUnitalNonAssocSemiring.toMul.{max u1 u2} (Filter.Germ.{u1, u2} α l R) (NonAssocSemiring.toNonUnitalNonAssocSemiring.{max u1 u2} (Filter.Germ.{u1, u2} α l R) (Semiring.toNonAssocSemiring.{max u1 u2} (Filter.Germ.{u1, u2} α l R) (Filter.Germ.semiring.{u1, u2} α l R _inst_1)))) (NonUnitalRingHomClass.toMulHomClass.{max u1 u2, max u1 u2, max u1 u2} (RingHom.{max u1 u2, max u2 u1} (α -> R) (Filter.Germ.{u1, u2} α l R) (Pi.nonAssocSemiring.{u1, u2} α (fun (a._@.Mathlib.Order.Filter.Germ._hyg.4920 : α) => R) (fun (i : α) => Semiring.toNonAssocSemiring.{u2} R _inst_1)) (Semiring.toNonAssocSemiring.{max u1 u2} (Filter.Germ.{u1, u2} α l R) (Filter.Germ.semiring.{u1, u2} α l R _inst_1))) (α -> R) (Filter.Germ.{u1, u2} α l R) (NonAssocSemiring.toNonUnitalNonAssocSemiring.{max u1 u2} (α -> R) (Pi.nonAssocSemiring.{u1, u2} α (fun (a._@.Mathlib.Order.Filter.Germ._hyg.4920 : α) => R) (fun (i : α) => Semiring.toNonAssocSemiring.{u2} R _inst_1))) (NonAssocSemiring.toNonUnitalNonAssocSemiring.{max u1 u2} (Filter.Germ.{u1, u2} α l R) (Semiring.toNonAssocSemiring.{max u1 u2} (Filter.Germ.{u1, u2} α l R) (Filter.Germ.semiring.{u1, u2} α l R _inst_1))) (RingHomClass.toNonUnitalRingHomClass.{max u1 u2, max u1 u2, max u1 u2} (RingHom.{max u1 u2, max u2 u1} (α -> R) (Filter.Germ.{u1, u2} α l R) (Pi.nonAssocSemiring.{u1, u2} α (fun (a._@.Mathlib.Order.Filter.Germ._hyg.4920 : α) => R) (fun (i : α) => Semiring.toNonAssocSemiring.{u2} R _inst_1)) (Semiring.toNonAssocSemiring.{max u1 u2} (Filter.Germ.{u1, u2} α l R) (Filter.Germ.semiring.{u1, u2} α l R _inst_1))) (α -> R) (Filter.Germ.{u1, u2} α l R) (Pi.nonAssocSemiring.{u1, u2} α (fun (a._@.Mathlib.Order.Filter.Germ._hyg.4920 : α) => R) (fun (i : α) => Semiring.toNonAssocSemiring.{u2} R _inst_1)) (Semiring.toNonAssocSemiring.{max u1 u2} (Filter.Germ.{u1, u2} α l R) (Filter.Germ.semiring.{u1, u2} α l R _inst_1)) (RingHom.instRingHomClassRingHom.{max u1 u2, max u1 u2} (α -> R) (Filter.Germ.{u1, u2} α l R) (Pi.nonAssocSemiring.{u1, u2} α (fun (a._@.Mathlib.Order.Filter.Germ._hyg.4920 : α) => R) (fun (i : α) => Semiring.toNonAssocSemiring.{u2} R _inst_1)) (Semiring.toNonAssocSemiring.{max u1 u2} (Filter.Germ.{u1, u2} α l R) (Filter.Germ.semiring.{u1, u2} α l R _inst_1)))))) (Filter.Germ.coeRingHom.{u1, u2} α R _inst_1 l)) (Filter.Germ.ofFun.{u1, u2} α R l)
 Case conversion may be inaccurate. Consider using '#align filter.germ.coe_coe_ring_hom Filter.Germ.coe_coeRingHomₓ'. -/
 @[simp]
 theorem coe_coeRingHom [Semiring R] : (coeRingHom l : (α → R) → Germ l R) = coe :=

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

@@ -756,11 +756,11 @@ instance [MulZeroClass R] : MulZeroClass (Germ l R)
   mul_zero f :=
     inductionOn f fun f => by
       norm_cast
-      rw [mul_zero]
+      rw [MulZeroClass.mul_zero]
   zero_mul f :=
     inductionOn f fun f => by
       norm_cast
-      rw [zero_mul]
+      rw [MulZeroClass.zero_mul]
 
 instance [Distrib R] : Distrib (Germ l R)
     where

mathlib commit https://github.com/leanprover-community/mathlib/commit/38f16f960f5006c6c0c2bac7b0aba5273188f4e5

@@ -655,7 +655,7 @@ def coeMulHom [Monoid M] (l : Filter α) : (α → M) →* Germ l M :=
 lean 3 declaration is
   forall {α : Type.{u1}} {l : Filter.{u1} α} {M : Type.{u2}} [_inst_1 : Monoid.{u2} M], Eq.{max (max (succ u1) (succ u2)) (succ (max u1 u2))} ((fun (_x : MonoidHom.{max u1 u2, max u1 u2} (α -> M) (Filter.Germ.{u1, u2} α l M) (Pi.mulOneClass.{u1, u2} α (fun (ᾰ : α) => M) (fun (i : α) => Monoid.toMulOneClass.{u2} M _inst_1)) (Monoid.toMulOneClass.{max u1 u2} (Filter.Germ.{u1, u2} α l M) (Filter.Germ.monoid.{u1, u2} α l M _inst_1))) => (α -> M) -> (Filter.Germ.{u1, u2} α l M)) (Filter.Germ.coeMulHom.{u1, u2} α M _inst_1 l)) (coeFn.{succ (max u1 u2), succ (max u1 u2)} (MonoidHom.{max u1 u2, max u1 u2} (α -> M) (Filter.Germ.{u1, u2} α l M) (Pi.mulOneClass.{u1, u2} α (fun (ᾰ : α) => M) (fun (i : α) => Monoid.toMulOneClass.{u2} M _inst_1)) (Monoid.toMulOneClass.{max u1 u2} (Filter.Germ.{u1, u2} α l M) (Filter.Germ.monoid.{u1, u2} α l M _inst_1))) (fun (_x : MonoidHom.{max u1 u2, max u1 u2} (α -> M) (Filter.Germ.{u1, u2} α l M) (Pi.mulOneClass.{u1, u2} α (fun (ᾰ : α) => M) (fun (i : α) => Monoid.toMulOneClass.{u2} M _inst_1)) (Monoid.toMulOneClass.{max u1 u2} (Filter.Germ.{u1, u2} α l M) (Filter.Germ.monoid.{u1, u2} α l M _inst_1))) => (α -> M) -> (Filter.Germ.{u1, u2} α l M)) (MonoidHom.hasCoeToFun.{max u1 u2, max u1 u2} (α -> M) (Filter.Germ.{u1, u2} α l M) (Pi.mulOneClass.{u1, u2} α (fun (ᾰ : α) => M) (fun (i : α) => Monoid.toMulOneClass.{u2} M _inst_1)) (Monoid.toMulOneClass.{max u1 u2} (Filter.Germ.{u1, u2} α l M) (Filter.Germ.monoid.{u1, u2} α l M _inst_1))) (Filter.Germ.coeMulHom.{u1, u2} α M _inst_1 l)) ((fun (a : Sort.{max (succ u1) (succ u2)}) (b : Type.{max u1 u2}) [self : HasLiftT.{max (succ u1) (succ u2), succ (max u1 u2)} a b] => self.0) (α -> M) (Filter.Germ.{u1, u2} α l M) (HasLiftT.mk.{max (succ u1) (succ u2), succ (max u1 u2)} (α -> M) (Filter.Germ.{u1, u2} α l M) (CoeTCₓ.coe.{max (succ u1) (succ u2), succ (max u1 u2)} (α -> M) (Filter.Germ.{u1, u2} α l M) (Filter.Germ.hasCoeT.{u1, u2} α M l))))
 but is expected to have type
-  forall {α : Type.{u1}} {l : Filter.{u1} α} {M : Type.{u2}} [_inst_1 : Monoid.{u2} M], Eq.{max (succ u1) (succ u2)} (forall (a : α -> M), (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2398 : α -> M) => Filter.Germ.{u1, u2} α l M) a) (FunLike.coe.{max (succ u1) (succ u2), max (succ u1) (succ u2), max (succ u1) (succ u2)} (MonoidHom.{max u1 u2, max u2 u1} (α -> M) (Filter.Germ.{u1, u2} α l M) (Pi.mulOneClass.{u1, u2} α (fun (a._@.Mathlib.Order.Filter.Germ._hyg.3518 : α) => M) (fun (i : α) => Monoid.toMulOneClass.{u2} M _inst_1)) (Monoid.toMulOneClass.{max u1 u2} (Filter.Germ.{u1, u2} α l M) (Filter.Germ.monoid.{u1, u2} α l M _inst_1))) (α -> M) (fun (_x : α -> M) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2398 : α -> M) => Filter.Germ.{u1, u2} α l M) _x) (MulHomClass.toFunLike.{max u1 u2, max u1 u2, max u1 u2} (MonoidHom.{max u1 u2, max u2 u1} (α -> M) (Filter.Germ.{u1, u2} α l M) (Pi.mulOneClass.{u1, u2} α (fun (a._@.Mathlib.Order.Filter.Germ._hyg.3518 : α) => M) (fun (i : α) => Monoid.toMulOneClass.{u2} M _inst_1)) (Monoid.toMulOneClass.{max u1 u2} (Filter.Germ.{u1, u2} α l M) (Filter.Germ.monoid.{u1, u2} α l M _inst_1))) (α -> M) (Filter.Germ.{u1, u2} α l M) (MulOneClass.toMul.{max u1 u2} (α -> M) (Pi.mulOneClass.{u1, u2} α (fun (a._@.Mathlib.Order.Filter.Germ._hyg.3518 : α) => M) (fun (i : α) => Monoid.toMulOneClass.{u2} M _inst_1))) (MulOneClass.toMul.{max u1 u2} (Filter.Germ.{u1, u2} α l M) (Monoid.toMulOneClass.{max u1 u2} (Filter.Germ.{u1, u2} α l M) (Filter.Germ.monoid.{u1, u2} α l M _inst_1))) (MonoidHomClass.toMulHomClass.{max u1 u2, max u1 u2, max u1 u2} (MonoidHom.{max u1 u2, max u2 u1} (α -> M) (Filter.Germ.{u1, u2} α l M) (Pi.mulOneClass.{u1, u2} α (fun (a._@.Mathlib.Order.Filter.Germ._hyg.3518 : α) => M) (fun (i : α) => Monoid.toMulOneClass.{u2} M _inst_1)) (Monoid.toMulOneClass.{max u1 u2} (Filter.Germ.{u1, u2} α l M) (Filter.Germ.monoid.{u1, u2} α l M _inst_1))) (α -> M) (Filter.Germ.{u1, u2} α l M) (Pi.mulOneClass.{u1, u2} α (fun (a._@.Mathlib.Order.Filter.Germ._hyg.3518 : α) => M) (fun (i : α) => Monoid.toMulOneClass.{u2} M _inst_1)) (Monoid.toMulOneClass.{max u1 u2} (Filter.Germ.{u1, u2} α l M) (Filter.Germ.monoid.{u1, u2} α l M _inst_1)) (MonoidHom.monoidHomClass.{max u1 u2, max u1 u2} (α -> M) (Filter.Germ.{u1, u2} α l M) (Pi.mulOneClass.{u1, u2} α (fun (a._@.Mathlib.Order.Filter.Germ._hyg.3518 : α) => M) (fun (i : α) => Monoid.toMulOneClass.{u2} M _inst_1)) (Monoid.toMulOneClass.{max u1 u2} (Filter.Germ.{u1, u2} α l M) (Filter.Germ.monoid.{u1, u2} α l M _inst_1))))) (Filter.Germ.coeMulHom.{u1, u2} α M _inst_1 l)) (Filter.Germ.ofFun.{u1, u2} α M l)
+  forall {α : Type.{u1}} {l : Filter.{u1} α} {M : Type.{u2}} [_inst_1 : Monoid.{u2} M], Eq.{max (succ u1) (succ u2)} (forall (a : α -> M), (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2372 : α -> M) => Filter.Germ.{u1, u2} α l M) a) (FunLike.coe.{max (succ u1) (succ u2), max (succ u1) (succ u2), max (succ u1) (succ u2)} (MonoidHom.{max u1 u2, max u2 u1} (α -> M) (Filter.Germ.{u1, u2} α l M) (Pi.mulOneClass.{u1, u2} α (fun (a._@.Mathlib.Order.Filter.Germ._hyg.3518 : α) => M) (fun (i : α) => Monoid.toMulOneClass.{u2} M _inst_1)) (Monoid.toMulOneClass.{max u1 u2} (Filter.Germ.{u1, u2} α l M) (Filter.Germ.monoid.{u1, u2} α l M _inst_1))) (α -> M) (fun (_x : α -> M) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2372 : α -> M) => Filter.Germ.{u1, u2} α l M) _x) (MulHomClass.toFunLike.{max u1 u2, max u1 u2, max u1 u2} (MonoidHom.{max u1 u2, max u2 u1} (α -> M) (Filter.Germ.{u1, u2} α l M) (Pi.mulOneClass.{u1, u2} α (fun (a._@.Mathlib.Order.Filter.Germ._hyg.3518 : α) => M) (fun (i : α) => Monoid.toMulOneClass.{u2} M _inst_1)) (Monoid.toMulOneClass.{max u1 u2} (Filter.Germ.{u1, u2} α l M) (Filter.Germ.monoid.{u1, u2} α l M _inst_1))) (α -> M) (Filter.Germ.{u1, u2} α l M) (MulOneClass.toMul.{max u1 u2} (α -> M) (Pi.mulOneClass.{u1, u2} α (fun (a._@.Mathlib.Order.Filter.Germ._hyg.3518 : α) => M) (fun (i : α) => Monoid.toMulOneClass.{u2} M _inst_1))) (MulOneClass.toMul.{max u1 u2} (Filter.Germ.{u1, u2} α l M) (Monoid.toMulOneClass.{max u1 u2} (Filter.Germ.{u1, u2} α l M) (Filter.Germ.monoid.{u1, u2} α l M _inst_1))) (MonoidHomClass.toMulHomClass.{max u1 u2, max u1 u2, max u1 u2} (MonoidHom.{max u1 u2, max u2 u1} (α -> M) (Filter.Germ.{u1, u2} α l M) (Pi.mulOneClass.{u1, u2} α (fun (a._@.Mathlib.Order.Filter.Germ._hyg.3518 : α) => M) (fun (i : α) => Monoid.toMulOneClass.{u2} M _inst_1)) (Monoid.toMulOneClass.{max u1 u2} (Filter.Germ.{u1, u2} α l M) (Filter.Germ.monoid.{u1, u2} α l M _inst_1))) (α -> M) (Filter.Germ.{u1, u2} α l M) (Pi.mulOneClass.{u1, u2} α (fun (a._@.Mathlib.Order.Filter.Germ._hyg.3518 : α) => M) (fun (i : α) => Monoid.toMulOneClass.{u2} M _inst_1)) (Monoid.toMulOneClass.{max u1 u2} (Filter.Germ.{u1, u2} α l M) (Filter.Germ.monoid.{u1, u2} α l M _inst_1)) (MonoidHom.monoidHomClass.{max u1 u2, max u1 u2} (α -> M) (Filter.Germ.{u1, u2} α l M) (Pi.mulOneClass.{u1, u2} α (fun (a._@.Mathlib.Order.Filter.Germ._hyg.3518 : α) => M) (fun (i : α) => Monoid.toMulOneClass.{u2} M _inst_1)) (Monoid.toMulOneClass.{max u1 u2} (Filter.Germ.{u1, u2} α l M) (Filter.Germ.monoid.{u1, u2} α l M _inst_1))))) (Filter.Germ.coeMulHom.{u1, u2} α M _inst_1 l)) (Filter.Germ.ofFun.{u1, u2} α M l)
 Case conversion may be inaccurate. Consider using '#align filter.germ.coe_coe_mul_hom Filter.Germ.coe_coeMulHomₓ'. -/
 @[simp, to_additive]
 theorem coe_coeMulHom [Monoid M] : (coeMulHom l : (α → M) → Germ l M) = coe :=
@@ -789,7 +789,7 @@ def coeRingHom [Semiring R] (l : Filter α) : (α → R) →+* Germ l R :=
 lean 3 declaration is
   forall {α : Type.{u1}} {l : Filter.{u1} α} {R : Type.{u2}} [_inst_1 : Semiring.{u2} R], Eq.{max (max (succ u1) (succ u2)) (succ (max u1 u2))} ((fun (_x : RingHom.{max u1 u2, max u1 u2} (α -> R) (Filter.Germ.{u1, u2} α l R) (Pi.nonAssocSemiring.{u1, u2} α (fun (ᾰ : α) => R) (fun (i : α) => Semiring.toNonAssocSemiring.{u2} R _inst_1)) (Semiring.toNonAssocSemiring.{max u1 u2} (Filter.Germ.{u1, u2} α l R) (Filter.Germ.semiring.{u1, u2} α l R _inst_1))) => (α -> R) -> (Filter.Germ.{u1, u2} α l R)) (Filter.Germ.coeRingHom.{u1, u2} α R _inst_1 l)) (coeFn.{succ (max u1 u2), succ (max u1 u2)} (RingHom.{max u1 u2, max u1 u2} (α -> R) (Filter.Germ.{u1, u2} α l R) (Pi.nonAssocSemiring.{u1, u2} α (fun (ᾰ : α) => R) (fun (i : α) => Semiring.toNonAssocSemiring.{u2} R _inst_1)) (Semiring.toNonAssocSemiring.{max u1 u2} (Filter.Germ.{u1, u2} α l R) (Filter.Germ.semiring.{u1, u2} α l R _inst_1))) (fun (_x : RingHom.{max u1 u2, max u1 u2} (α -> R) (Filter.Germ.{u1, u2} α l R) (Pi.nonAssocSemiring.{u1, u2} α (fun (ᾰ : α) => R) (fun (i : α) => Semiring.toNonAssocSemiring.{u2} R _inst_1)) (Semiring.toNonAssocSemiring.{max u1 u2} (Filter.Germ.{u1, u2} α l R) (Filter.Germ.semiring.{u1, u2} α l R _inst_1))) => (α -> R) -> (Filter.Germ.{u1, u2} α l R)) (RingHom.hasCoeToFun.{max u1 u2, max u1 u2} (α -> R) (Filter.Germ.{u1, u2} α l R) (Pi.nonAssocSemiring.{u1, u2} α (fun (ᾰ : α) => R) (fun (i : α) => Semiring.toNonAssocSemiring.{u2} R _inst_1)) (Semiring.toNonAssocSemiring.{max u1 u2} (Filter.Germ.{u1, u2} α l R) (Filter.Germ.semiring.{u1, u2} α l R _inst_1))) (Filter.Germ.coeRingHom.{u1, u2} α R _inst_1 l)) ((fun (a : Sort.{max (succ u1) (succ u2)}) (b : Type.{max u1 u2}) [self : HasLiftT.{max (succ u1) (succ u2), succ (max u1 u2)} a b] => self.0) (α -> R) (Filter.Germ.{u1, u2} α l R) (HasLiftT.mk.{max (succ u1) (succ u2), succ (max u1 u2)} (α -> R) (Filter.Germ.{u1, u2} α l R) (CoeTCₓ.coe.{max (succ u1) (succ u2), succ (max u1 u2)} (α -> R) (Filter.Germ.{u1, u2} α l R) (Filter.Germ.hasCoeT.{u1, u2} α R l))))
 but is expected to have type
-  forall {α : Type.{u1}} {l : Filter.{u1} α} {R : Type.{u2}} [_inst_1 : Semiring.{u2} R], Eq.{max (succ u1) (succ u2)} (forall (a : α -> R), (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2398 : α -> R) => Filter.Germ.{u1, u2} α l R) a) (FunLike.coe.{max (succ u1) (succ u2), max (succ u1) (succ u2), max (succ u1) (succ u2)} (RingHom.{max u1 u2, max u2 u1} (α -> R) (Filter.Germ.{u1, u2} α l R) (Pi.nonAssocSemiring.{u1, u2} α (fun (a._@.Mathlib.Order.Filter.Germ._hyg.4919 : α) => R) (fun (i : α) => Semiring.toNonAssocSemiring.{u2} R _inst_1)) (Semiring.toNonAssocSemiring.{max u1 u2} (Filter.Germ.{u1, u2} α l R) (Filter.Germ.semiring.{u1, u2} α l R _inst_1))) (α -> R) (fun (_x : α -> R) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2398 : α -> R) => Filter.Germ.{u1, u2} α l R) _x) (MulHomClass.toFunLike.{max u1 u2, max u1 u2, max u1 u2} (RingHom.{max u1 u2, max u2 u1} (α -> R) (Filter.Germ.{u1, u2} α l R) (Pi.nonAssocSemiring.{u1, u2} α (fun (a._@.Mathlib.Order.Filter.Germ._hyg.4919 : α) => R) (fun (i : α) => Semiring.toNonAssocSemiring.{u2} R _inst_1)) (Semiring.toNonAssocSemiring.{max u1 u2} (Filter.Germ.{u1, u2} α l R) (Filter.Germ.semiring.{u1, u2} α l R _inst_1))) (α -> R) (Filter.Germ.{u1, u2} α l R) (NonUnitalNonAssocSemiring.toMul.{max u1 u2} (α -> R) (NonAssocSemiring.toNonUnitalNonAssocSemiring.{max u1 u2} (α -> R) (Pi.nonAssocSemiring.{u1, u2} α (fun (a._@.Mathlib.Order.Filter.Germ._hyg.4919 : α) => R) (fun (i : α) => Semiring.toNonAssocSemiring.{u2} R _inst_1)))) (NonUnitalNonAssocSemiring.toMul.{max u1 u2} (Filter.Germ.{u1, u2} α l R) (NonAssocSemiring.toNonUnitalNonAssocSemiring.{max u1 u2} (Filter.Germ.{u1, u2} α l R) (Semiring.toNonAssocSemiring.{max u1 u2} (Filter.Germ.{u1, u2} α l R) (Filter.Germ.semiring.{u1, u2} α l R _inst_1)))) (NonUnitalRingHomClass.toMulHomClass.{max u1 u2, max u1 u2, max u1 u2} (RingHom.{max u1 u2, max u2 u1} (α -> R) (Filter.Germ.{u1, u2} α l R) (Pi.nonAssocSemiring.{u1, u2} α (fun (a._@.Mathlib.Order.Filter.Germ._hyg.4919 : α) => R) (fun (i : α) => Semiring.toNonAssocSemiring.{u2} R _inst_1)) (Semiring.toNonAssocSemiring.{max u1 u2} (Filter.Germ.{u1, u2} α l R) (Filter.Germ.semiring.{u1, u2} α l R _inst_1))) (α -> R) (Filter.Germ.{u1, u2} α l R) (NonAssocSemiring.toNonUnitalNonAssocSemiring.{max u1 u2} (α -> R) (Pi.nonAssocSemiring.{u1, u2} α (fun (a._@.Mathlib.Order.Filter.Germ._hyg.4919 : α) => R) (fun (i : α) => Semiring.toNonAssocSemiring.{u2} R _inst_1))) (NonAssocSemiring.toNonUnitalNonAssocSemiring.{max u1 u2} (Filter.Germ.{u1, u2} α l R) (Semiring.toNonAssocSemiring.{max u1 u2} (Filter.Germ.{u1, u2} α l R) (Filter.Germ.semiring.{u1, u2} α l R _inst_1))) (RingHomClass.toNonUnitalRingHomClass.{max u1 u2, max u1 u2, max u1 u2} (RingHom.{max u1 u2, max u2 u1} (α -> R) (Filter.Germ.{u1, u2} α l R) (Pi.nonAssocSemiring.{u1, u2} α (fun (a._@.Mathlib.Order.Filter.Germ._hyg.4919 : α) => R) (fun (i : α) => Semiring.toNonAssocSemiring.{u2} R _inst_1)) (Semiring.toNonAssocSemiring.{max u1 u2} (Filter.Germ.{u1, u2} α l R) (Filter.Germ.semiring.{u1, u2} α l R _inst_1))) (α -> R) (Filter.Germ.{u1, u2} α l R) (Pi.nonAssocSemiring.{u1, u2} α (fun (a._@.Mathlib.Order.Filter.Germ._hyg.4919 : α) => R) (fun (i : α) => Semiring.toNonAssocSemiring.{u2} R _inst_1)) (Semiring.toNonAssocSemiring.{max u1 u2} (Filter.Germ.{u1, u2} α l R) (Filter.Germ.semiring.{u1, u2} α l R _inst_1)) (RingHom.instRingHomClassRingHom.{max u1 u2, max u1 u2} (α -> R) (Filter.Germ.{u1, u2} α l R) (Pi.nonAssocSemiring.{u1, u2} α (fun (a._@.Mathlib.Order.Filter.Germ._hyg.4919 : α) => R) (fun (i : α) => Semiring.toNonAssocSemiring.{u2} R _inst_1)) (Semiring.toNonAssocSemiring.{max u1 u2} (Filter.Germ.{u1, u2} α l R) (Filter.Germ.semiring.{u1, u2} α l R _inst_1)))))) (Filter.Germ.coeRingHom.{u1, u2} α R _inst_1 l)) (Filter.Germ.ofFun.{u1, u2} α R l)
+  forall {α : Type.{u1}} {l : Filter.{u1} α} {R : Type.{u2}} [_inst_1 : Semiring.{u2} R], Eq.{max (succ u1) (succ u2)} (forall (a : α -> R), (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2372 : α -> R) => Filter.Germ.{u1, u2} α l R) a) (FunLike.coe.{max (succ u1) (succ u2), max (succ u1) (succ u2), max (succ u1) (succ u2)} (RingHom.{max u1 u2, max u2 u1} (α -> R) (Filter.Germ.{u1, u2} α l R) (Pi.nonAssocSemiring.{u1, u2} α (fun (a._@.Mathlib.Order.Filter.Germ._hyg.4919 : α) => R) (fun (i : α) => Semiring.toNonAssocSemiring.{u2} R _inst_1)) (Semiring.toNonAssocSemiring.{max u1 u2} (Filter.Germ.{u1, u2} α l R) (Filter.Germ.semiring.{u1, u2} α l R _inst_1))) (α -> R) (fun (_x : α -> R) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2372 : α -> R) => Filter.Germ.{u1, u2} α l R) _x) (MulHomClass.toFunLike.{max u1 u2, max u1 u2, max u1 u2} (RingHom.{max u1 u2, max u2 u1} (α -> R) (Filter.Germ.{u1, u2} α l R) (Pi.nonAssocSemiring.{u1, u2} α (fun (a._@.Mathlib.Order.Filter.Germ._hyg.4919 : α) => R) (fun (i : α) => Semiring.toNonAssocSemiring.{u2} R _inst_1)) (Semiring.toNonAssocSemiring.{max u1 u2} (Filter.Germ.{u1, u2} α l R) (Filter.Germ.semiring.{u1, u2} α l R _inst_1))) (α -> R) (Filter.Germ.{u1, u2} α l R) (NonUnitalNonAssocSemiring.toMul.{max u1 u2} (α -> R) (NonAssocSemiring.toNonUnitalNonAssocSemiring.{max u1 u2} (α -> R) (Pi.nonAssocSemiring.{u1, u2} α (fun (a._@.Mathlib.Order.Filter.Germ._hyg.4919 : α) => R) (fun (i : α) => Semiring.toNonAssocSemiring.{u2} R _inst_1)))) (NonUnitalNonAssocSemiring.toMul.{max u1 u2} (Filter.Germ.{u1, u2} α l R) (NonAssocSemiring.toNonUnitalNonAssocSemiring.{max u1 u2} (Filter.Germ.{u1, u2} α l R) (Semiring.toNonAssocSemiring.{max u1 u2} (Filter.Germ.{u1, u2} α l R) (Filter.Germ.semiring.{u1, u2} α l R _inst_1)))) (NonUnitalRingHomClass.toMulHomClass.{max u1 u2, max u1 u2, max u1 u2} (RingHom.{max u1 u2, max u2 u1} (α -> R) (Filter.Germ.{u1, u2} α l R) (Pi.nonAssocSemiring.{u1, u2} α (fun (a._@.Mathlib.Order.Filter.Germ._hyg.4919 : α) => R) (fun (i : α) => Semiring.toNonAssocSemiring.{u2} R _inst_1)) (Semiring.toNonAssocSemiring.{max u1 u2} (Filter.Germ.{u1, u2} α l R) (Filter.Germ.semiring.{u1, u2} α l R _inst_1))) (α -> R) (Filter.Germ.{u1, u2} α l R) (NonAssocSemiring.toNonUnitalNonAssocSemiring.{max u1 u2} (α -> R) (Pi.nonAssocSemiring.{u1, u2} α (fun (a._@.Mathlib.Order.Filter.Germ._hyg.4919 : α) => R) (fun (i : α) => Semiring.toNonAssocSemiring.{u2} R _inst_1))) (NonAssocSemiring.toNonUnitalNonAssocSemiring.{max u1 u2} (Filter.Germ.{u1, u2} α l R) (Semiring.toNonAssocSemiring.{max u1 u2} (Filter.Germ.{u1, u2} α l R) (Filter.Germ.semiring.{u1, u2} α l R _inst_1))) (RingHomClass.toNonUnitalRingHomClass.{max u1 u2, max u1 u2, max u1 u2} (RingHom.{max u1 u2, max u2 u1} (α -> R) (Filter.Germ.{u1, u2} α l R) (Pi.nonAssocSemiring.{u1, u2} α (fun (a._@.Mathlib.Order.Filter.Germ._hyg.4919 : α) => R) (fun (i : α) => Semiring.toNonAssocSemiring.{u2} R _inst_1)) (Semiring.toNonAssocSemiring.{max u1 u2} (Filter.Germ.{u1, u2} α l R) (Filter.Germ.semiring.{u1, u2} α l R _inst_1))) (α -> R) (Filter.Germ.{u1, u2} α l R) (Pi.nonAssocSemiring.{u1, u2} α (fun (a._@.Mathlib.Order.Filter.Germ._hyg.4919 : α) => R) (fun (i : α) => Semiring.toNonAssocSemiring.{u2} R _inst_1)) (Semiring.toNonAssocSemiring.{max u1 u2} (Filter.Germ.{u1, u2} α l R) (Filter.Germ.semiring.{u1, u2} α l R _inst_1)) (RingHom.instRingHomClassRingHom.{max u1 u2, max u1 u2} (α -> R) (Filter.Germ.{u1, u2} α l R) (Pi.nonAssocSemiring.{u1, u2} α (fun (a._@.Mathlib.Order.Filter.Germ._hyg.4919 : α) => R) (fun (i : α) => Semiring.toNonAssocSemiring.{u2} R _inst_1)) (Semiring.toNonAssocSemiring.{max u1 u2} (Filter.Germ.{u1, u2} α l R) (Filter.Germ.semiring.{u1, u2} α l R _inst_1)))))) (Filter.Germ.coeRingHom.{u1, u2} α R _inst_1 l)) (Filter.Germ.ofFun.{u1, u2} α R l)
 Case conversion may be inaccurate. Consider using '#align filter.germ.coe_coe_ring_hom Filter.Germ.coe_coeRingHomₓ'. -/
 @[simp]
 theorem coe_coeRingHom [Semiring R] : (coeRingHom l : (α → R) → Germ l R) = coe :=

mathlib commit https://github.com/leanprover-community/mathlib/commit/195fcd60ff2bfe392543bceb0ec2adcdb472db4c

@@ -604,7 +604,7 @@ instance [Pow G M] : Pow (Germ l G) M :=
 lean 3 declaration is
   forall {α : Type.{u1}} {l : Filter.{u1} α} {M : Type.{u2}} {G : Type.{u3}} [_inst_1 : SMul.{u2, u3} M G] (n : M) (f : α -> G), Eq.{succ (max u1 u3)} (Filter.Germ.{u1, u3} α l G) ((fun (a : Type.{max u1 u3}) (b : Type.{max u1 u3}) [self : HasLiftT.{succ (max u1 u3), succ (max u1 u3)} a b] => self.0) (α -> G) (Filter.Germ.{u1, u3} α l G) (HasLiftT.mk.{succ (max u1 u3), succ (max u1 u3)} (α -> G) (Filter.Germ.{u1, u3} α l G) (CoeTCₓ.coe.{succ (max u1 u3), succ (max u1 u3)} (α -> G) (Filter.Germ.{u1, u3} α l G) (Filter.Germ.hasCoeT.{u1, u3} α G l))) (SMul.smul.{u2, max u1 u3} M (α -> G) (Function.hasSMul.{u1, u2, u3} α M G _inst_1) n f)) (SMul.smul.{u2, max u1 u3} M (Filter.Germ.{u1, u3} α l G) (Filter.Germ.hasSmul.{u1, u2, u3} α l M G _inst_1) n ((fun (a : Sort.{max (succ u1) (succ u3)}) (b : Type.{max u1 u3}) [self : HasLiftT.{max (succ u1) (succ u3), succ (max u1 u3)} a b] => self.0) (α -> G) (Filter.Germ.{u1, u3} α l G) (HasLiftT.mk.{max (succ u1) (succ u3), succ (max u1 u3)} (α -> G) (Filter.Germ.{u1, u3} α l G) (CoeTCₓ.coe.{max (succ u1) (succ u3), succ (max u1 u3)} (α -> G) (Filter.Germ.{u1, u3} α l G) (Filter.Germ.hasCoeT.{u1, u3} α G l))) f))
 but is expected to have type
-  forall {α : Type.{u1}} {l : Filter.{u1} α} {M : Type.{u3}} {G : Type.{u2}} [_inst_1 : SMul.{u3, u2} M G] (n : M) (f : α -> G), Eq.{max (succ u1) (succ u2)} (Filter.Germ.{u1, u2} α l G) (Filter.Germ.ofFun.{u1, u2} α G l (HSMul.hSMul.{u3, max u1 u2, max u1 u2} M (α -> G) (α -> G) (instHSMul.{u3, max u1 u2} M (α -> G) (Pi.instSMul.{u1, u2, u3} α M (fun (a._@.Mathlib.Order.Filter.Germ._hyg.3203 : α) => G) (fun (i : α) => _inst_1))) n f)) (HSMul.hSMul.{u3, max u1 u2, max u1 u2} M (Filter.Germ.{u1, u2} α l G) (Filter.Germ.{u1, u2} α l G) (instHSMul.{u3, max u1 u2} M (Filter.Germ.{u1, u2} α l G) (Filter.Germ.sMul.{u1, u3, u2} α l M G _inst_1)) n (Filter.Germ.ofFun.{u1, u2} α G l f))
+  forall {α : Type.{u1}} {l : Filter.{u1} α} {M : Type.{u3}} {G : Type.{u2}} [_inst_1 : SMul.{u3, u2} M G] (n : M) (f : α -> G), Eq.{max (succ u1) (succ u2)} (Filter.Germ.{u1, u2} α l G) (Filter.Germ.ofFun.{u1, u2} α G l (HSMul.hSMul.{u3, max u1 u2, max u1 u2} M (α -> G) (α -> G) (instHSMul.{u3, max u1 u2} M (α -> G) (Pi.instSMul.{u1, u2, u3} α M (fun (a._@.Mathlib.Order.Filter.Germ._hyg.3203 : α) => G) (fun (i : α) => _inst_1))) n f)) (HSMul.hSMul.{u3, max u1 u2, max u1 u2} M (Filter.Germ.{u1, u2} α l G) (Filter.Germ.{u1, u2} α l G) (instHSMul.{u3, max u1 u2} M (Filter.Germ.{u1, u2} α l G) (Filter.Germ.smul.{u1, u3, u2} α l M G _inst_1)) n (Filter.Germ.ofFun.{u1, u2} α G l f))
 Case conversion may be inaccurate. Consider using '#align filter.germ.coe_smul Filter.Germ.coe_smulₓ'. -/
 @[simp, norm_cast, to_additive]
 theorem coe_smul [SMul M G] (n : M) (f : α → G) : ↑(n • f) = (n • f : Germ l G) :=
@@ -616,7 +616,7 @@ theorem coe_smul [SMul M G] (n : M) (f : α → G) : ↑(n • f) = (n • f : G
 lean 3 declaration is
   forall {α : Type.{u1}} {l : Filter.{u1} α} {M : Type.{u2}} {G : Type.{u3}} [_inst_1 : SMul.{u2, u3} M G] (n : M) (a : G), Eq.{succ (max u1 u3)} (Filter.Germ.{u1, u3} α l G) ((fun (a : Type.{u3}) (b : Type.{max u1 u3}) [self : HasLiftT.{succ u3, succ (max u1 u3)} a b] => self.0) G (Filter.Germ.{u1, u3} α l G) (Filter.Germ.hasLiftT.{u1, u3} α G l) (SMul.smul.{u2, u3} M G _inst_1 n a)) (SMul.smul.{u2, max u1 u3} M (Filter.Germ.{u1, u3} α l G) (Filter.Germ.hasSmul.{u1, u2, u3} α l M G _inst_1) n ((fun (a : Type.{u3}) (b : Type.{max u1 u3}) [self : HasLiftT.{succ u3, succ (max u1 u3)} a b] => self.0) G (Filter.Germ.{u1, u3} α l G) (Filter.Germ.hasLiftT.{u1, u3} α G l) a))
 but is expected to have type
-  forall {α : Type.{u1}} {l : Filter.{u1} α} {M : Type.{u3}} {G : Type.{u2}} [_inst_1 : SMul.{u3, u2} M G] (n : M) (a : G), Eq.{max (succ u1) (succ u2)} (Filter.Germ.{u1, u2} α l G) (Filter.Germ.const.{u1, u2} α G l (HSMul.hSMul.{u3, u2, u2} M G G (instHSMul.{u3, u2} M G _inst_1) n a)) (HSMul.hSMul.{u3, max u1 u2, max u1 u2} M (Filter.Germ.{u1, u2} α l G) (Filter.Germ.{u1, u2} α l G) (instHSMul.{u3, max u1 u2} M (Filter.Germ.{u1, u2} α l G) (Filter.Germ.sMul.{u1, u3, u2} α l M G _inst_1)) n (Filter.Germ.const.{u1, u2} α G l a))
+  forall {α : Type.{u1}} {l : Filter.{u1} α} {M : Type.{u3}} {G : Type.{u2}} [_inst_1 : SMul.{u3, u2} M G] (n : M) (a : G), Eq.{max (succ u1) (succ u2)} (Filter.Germ.{u1, u2} α l G) (Filter.Germ.const.{u1, u2} α G l (HSMul.hSMul.{u3, u2, u2} M G G (instHSMul.{u3, u2} M G _inst_1) n a)) (HSMul.hSMul.{u3, max u1 u2, max u1 u2} M (Filter.Germ.{u1, u2} α l G) (Filter.Germ.{u1, u2} α l G) (instHSMul.{u3, max u1 u2} M (Filter.Germ.{u1, u2} α l G) (Filter.Germ.smul.{u1, u3, u2} α l M G _inst_1)) n (Filter.Germ.const.{u1, u2} α G l a))
 Case conversion may be inaccurate. Consider using '#align filter.germ.const_smul Filter.Germ.const_smulₓ'. -/
 @[simp, norm_cast, to_additive]
 theorem const_smul [SMul M G] (n : M) (a : G) : (↑(n • a) : Germ l G) = n • ↑a :=
@@ -934,14 +934,14 @@ theorem const_le_iff [LE β] [NeBot l] {x y : β} : (↑x : Germ l β) ≤ ↑y
 instance [Preorder β] : Preorder (Germ l β)
     where
   le := (· ≤ ·)
-  le_refl f := inductionOn f <| EventuallyLe.refl l
-  le_trans f₁ f₂ f₃ := inductionOn₃ f₁ f₂ f₃ fun f₁ f₂ f₃ => EventuallyLe.trans
+  le_refl f := inductionOn f <| EventuallyLE.refl l
+  le_trans f₁ f₂ f₃ := inductionOn₃ f₁ f₂ f₃ fun f₁ f₂ f₃ => EventuallyLE.trans
 
 instance [PartialOrder β] : PartialOrder (Germ l β) :=
   { Germ.preorder with
     le := (· ≤ ·)
     le_antisymm := fun f g =>
-      inductionOn₂ f g fun f g h₁ h₂ => (EventuallyLe.antisymm h₁ h₂).germ_eq }
+      inductionOn₂ f g fun f g h₁ h₂ => (EventuallyLE.antisymm h₁ h₂).germ_eq }
 
 instance [Bot β] : Bot (Germ l β) :=
   ⟨↑(⊥ : β)⟩

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

@@ -604,7 +604,7 @@ instance [Pow G M] : Pow (Germ l G) M :=
 lean 3 declaration is
   forall {α : Type.{u1}} {l : Filter.{u1} α} {M : Type.{u2}} {G : Type.{u3}} [_inst_1 : SMul.{u2, u3} M G] (n : M) (f : α -> G), Eq.{succ (max u1 u3)} (Filter.Germ.{u1, u3} α l G) ((fun (a : Type.{max u1 u3}) (b : Type.{max u1 u3}) [self : HasLiftT.{succ (max u1 u3), succ (max u1 u3)} a b] => self.0) (α -> G) (Filter.Germ.{u1, u3} α l G) (HasLiftT.mk.{succ (max u1 u3), succ (max u1 u3)} (α -> G) (Filter.Germ.{u1, u3} α l G) (CoeTCₓ.coe.{succ (max u1 u3), succ (max u1 u3)} (α -> G) (Filter.Germ.{u1, u3} α l G) (Filter.Germ.hasCoeT.{u1, u3} α G l))) (SMul.smul.{u2, max u1 u3} M (α -> G) (Function.hasSMul.{u1, u2, u3} α M G _inst_1) n f)) (SMul.smul.{u2, max u1 u3} M (Filter.Germ.{u1, u3} α l G) (Filter.Germ.hasSmul.{u1, u2, u3} α l M G _inst_1) n ((fun (a : Sort.{max (succ u1) (succ u3)}) (b : Type.{max u1 u3}) [self : HasLiftT.{max (succ u1) (succ u3), succ (max u1 u3)} a b] => self.0) (α -> G) (Filter.Germ.{u1, u3} α l G) (HasLiftT.mk.{max (succ u1) (succ u3), succ (max u1 u3)} (α -> G) (Filter.Germ.{u1, u3} α l G) (CoeTCₓ.coe.{max (succ u1) (succ u3), succ (max u1 u3)} (α -> G) (Filter.Germ.{u1, u3} α l G) (Filter.Germ.hasCoeT.{u1, u3} α G l))) f))
 but is expected to have type
-  forall {α : Type.{u1}} {l : Filter.{u1} α} {M : Type.{u3}} {G : Type.{u2}} [_inst_1 : SMul.{u3, u2} M G] (n : M) (f : α -> G), Eq.{max (succ u1) (succ u2)} (Filter.Germ.{u1, u2} α l G) (Filter.Germ.ofFun.{u1, u2} α G l (HSMul.hSMul.{u3, max u1 u2, max u1 u2} M (α -> G) (α -> G) (instHSMul.{u3, max u1 u2} M (α -> G) (Pi.instSMul.{u1, u2, u3} α M (fun (a._@.Mathlib.Order.Filter.Germ._hyg.3271 : α) => G) (fun (i : α) => _inst_1))) n f)) (HSMul.hSMul.{u3, max u1 u2, max u1 u2} M (Filter.Germ.{u1, u2} α l G) (Filter.Germ.{u1, u2} α l G) (instHSMul.{u3, max u1 u2} M (Filter.Germ.{u1, u2} α l G) (Filter.Germ.sMul.{u1, u3, u2} α l M G _inst_1)) n (Filter.Germ.ofFun.{u1, u2} α G l f))
+  forall {α : Type.{u1}} {l : Filter.{u1} α} {M : Type.{u3}} {G : Type.{u2}} [_inst_1 : SMul.{u3, u2} M G] (n : M) (f : α -> G), Eq.{max (succ u1) (succ u2)} (Filter.Germ.{u1, u2} α l G) (Filter.Germ.ofFun.{u1, u2} α G l (HSMul.hSMul.{u3, max u1 u2, max u1 u2} M (α -> G) (α -> G) (instHSMul.{u3, max u1 u2} M (α -> G) (Pi.instSMul.{u1, u2, u3} α M (fun (a._@.Mathlib.Order.Filter.Germ._hyg.3203 : α) => G) (fun (i : α) => _inst_1))) n f)) (HSMul.hSMul.{u3, max u1 u2, max u1 u2} M (Filter.Germ.{u1, u2} α l G) (Filter.Germ.{u1, u2} α l G) (instHSMul.{u3, max u1 u2} M (Filter.Germ.{u1, u2} α l G) (Filter.Germ.sMul.{u1, u3, u2} α l M G _inst_1)) n (Filter.Germ.ofFun.{u1, u2} α G l f))
 Case conversion may be inaccurate. Consider using '#align filter.germ.coe_smul Filter.Germ.coe_smulₓ'. -/
 @[simp, norm_cast, to_additive]
 theorem coe_smul [SMul M G] (n : M) (f : α → G) : ↑(n • f) = (n • f : Germ l G) :=
@@ -655,7 +655,7 @@ def coeMulHom [Monoid M] (l : Filter α) : (α → M) →* Germ l M :=
 lean 3 declaration is
   forall {α : Type.{u1}} {l : Filter.{u1} α} {M : Type.{u2}} [_inst_1 : Monoid.{u2} M], Eq.{max (max (succ u1) (succ u2)) (succ (max u1 u2))} ((fun (_x : MonoidHom.{max u1 u2, max u1 u2} (α -> M) (Filter.Germ.{u1, u2} α l M) (Pi.mulOneClass.{u1, u2} α (fun (ᾰ : α) => M) (fun (i : α) => Monoid.toMulOneClass.{u2} M _inst_1)) (Monoid.toMulOneClass.{max u1 u2} (Filter.Germ.{u1, u2} α l M) (Filter.Germ.monoid.{u1, u2} α l M _inst_1))) => (α -> M) -> (Filter.Germ.{u1, u2} α l M)) (Filter.Germ.coeMulHom.{u1, u2} α M _inst_1 l)) (coeFn.{succ (max u1 u2), succ (max u1 u2)} (MonoidHom.{max u1 u2, max u1 u2} (α -> M) (Filter.Germ.{u1, u2} α l M) (Pi.mulOneClass.{u1, u2} α (fun (ᾰ : α) => M) (fun (i : α) => Monoid.toMulOneClass.{u2} M _inst_1)) (Monoid.toMulOneClass.{max u1 u2} (Filter.Germ.{u1, u2} α l M) (Filter.Germ.monoid.{u1, u2} α l M _inst_1))) (fun (_x : MonoidHom.{max u1 u2, max u1 u2} (α -> M) (Filter.Germ.{u1, u2} α l M) (Pi.mulOneClass.{u1, u2} α (fun (ᾰ : α) => M) (fun (i : α) => Monoid.toMulOneClass.{u2} M _inst_1)) (Monoid.toMulOneClass.{max u1 u2} (Filter.Germ.{u1, u2} α l M) (Filter.Germ.monoid.{u1, u2} α l M _inst_1))) => (α -> M) -> (Filter.Germ.{u1, u2} α l M)) (MonoidHom.hasCoeToFun.{max u1 u2, max u1 u2} (α -> M) (Filter.Germ.{u1, u2} α l M) (Pi.mulOneClass.{u1, u2} α (fun (ᾰ : α) => M) (fun (i : α) => Monoid.toMulOneClass.{u2} M _inst_1)) (Monoid.toMulOneClass.{max u1 u2} (Filter.Germ.{u1, u2} α l M) (Filter.Germ.monoid.{u1, u2} α l M _inst_1))) (Filter.Germ.coeMulHom.{u1, u2} α M _inst_1 l)) ((fun (a : Sort.{max (succ u1) (succ u2)}) (b : Type.{max u1 u2}) [self : HasLiftT.{max (succ u1) (succ u2), succ (max u1 u2)} a b] => self.0) (α -> M) (Filter.Germ.{u1, u2} α l M) (HasLiftT.mk.{max (succ u1) (succ u2), succ (max u1 u2)} (α -> M) (Filter.Germ.{u1, u2} α l M) (CoeTCₓ.coe.{max (succ u1) (succ u2), succ (max u1 u2)} (α -> M) (Filter.Germ.{u1, u2} α l M) (Filter.Germ.hasCoeT.{u1, u2} α M l))))
 but is expected to have type
-  forall {α : Type.{u1}} {l : Filter.{u1} α} {M : Type.{u2}} [_inst_1 : Monoid.{u2} M], Eq.{max (succ u1) (succ u2)} (forall (a : α -> M), (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2398 : α -> M) => Filter.Germ.{u1, u2} α l M) a) (FunLike.coe.{max (succ u1) (succ u2), max (succ u1) (succ u2), max (succ u1) (succ u2)} (MonoidHom.{max u1 u2, max u2 u1} (α -> M) (Filter.Germ.{u1, u2} α l M) (Pi.mulOneClass.{u1, u2} α (fun (a._@.Mathlib.Order.Filter.Germ._hyg.3586 : α) => M) (fun (i : α) => Monoid.toMulOneClass.{u2} M _inst_1)) (Monoid.toMulOneClass.{max u1 u2} (Filter.Germ.{u1, u2} α l M) (Filter.Germ.monoid.{u1, u2} α l M _inst_1))) (α -> M) (fun (_x : α -> M) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2398 : α -> M) => Filter.Germ.{u1, u2} α l M) _x) (MulHomClass.toFunLike.{max u1 u2, max u1 u2, max u1 u2} (MonoidHom.{max u1 u2, max u2 u1} (α -> M) (Filter.Germ.{u1, u2} α l M) (Pi.mulOneClass.{u1, u2} α (fun (a._@.Mathlib.Order.Filter.Germ._hyg.3586 : α) => M) (fun (i : α) => Monoid.toMulOneClass.{u2} M _inst_1)) (Monoid.toMulOneClass.{max u1 u2} (Filter.Germ.{u1, u2} α l M) (Filter.Germ.monoid.{u1, u2} α l M _inst_1))) (α -> M) (Filter.Germ.{u1, u2} α l M) (MulOneClass.toMul.{max u1 u2} (α -> M) (Pi.mulOneClass.{u1, u2} α (fun (a._@.Mathlib.Order.Filter.Germ._hyg.3586 : α) => M) (fun (i : α) => Monoid.toMulOneClass.{u2} M _inst_1))) (MulOneClass.toMul.{max u1 u2} (Filter.Germ.{u1, u2} α l M) (Monoid.toMulOneClass.{max u1 u2} (Filter.Germ.{u1, u2} α l M) (Filter.Germ.monoid.{u1, u2} α l M _inst_1))) (MonoidHomClass.toMulHomClass.{max u1 u2, max u1 u2, max u1 u2} (MonoidHom.{max u1 u2, max u2 u1} (α -> M) (Filter.Germ.{u1, u2} α l M) (Pi.mulOneClass.{u1, u2} α (fun (a._@.Mathlib.Order.Filter.Germ._hyg.3586 : α) => M) (fun (i : α) => Monoid.toMulOneClass.{u2} M _inst_1)) (Monoid.toMulOneClass.{max u1 u2} (Filter.Germ.{u1, u2} α l M) (Filter.Germ.monoid.{u1, u2} α l M _inst_1))) (α -> M) (Filter.Germ.{u1, u2} α l M) (Pi.mulOneClass.{u1, u2} α (fun (a._@.Mathlib.Order.Filter.Germ._hyg.3586 : α) => M) (fun (i : α) => Monoid.toMulOneClass.{u2} M _inst_1)) (Monoid.toMulOneClass.{max u1 u2} (Filter.Germ.{u1, u2} α l M) (Filter.Germ.monoid.{u1, u2} α l M _inst_1)) (MonoidHom.monoidHomClass.{max u1 u2, max u1 u2} (α -> M) (Filter.Germ.{u1, u2} α l M) (Pi.mulOneClass.{u1, u2} α (fun (a._@.Mathlib.Order.Filter.Germ._hyg.3586 : α) => M) (fun (i : α) => Monoid.toMulOneClass.{u2} M _inst_1)) (Monoid.toMulOneClass.{max u1 u2} (Filter.Germ.{u1, u2} α l M) (Filter.Germ.monoid.{u1, u2} α l M _inst_1))))) (Filter.Germ.coeMulHom.{u1, u2} α M _inst_1 l)) (Filter.Germ.ofFun.{u1, u2} α M l)
+  forall {α : Type.{u1}} {l : Filter.{u1} α} {M : Type.{u2}} [_inst_1 : Monoid.{u2} M], Eq.{max (succ u1) (succ u2)} (forall (a : α -> M), (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2398 : α -> M) => Filter.Germ.{u1, u2} α l M) a) (FunLike.coe.{max (succ u1) (succ u2), max (succ u1) (succ u2), max (succ u1) (succ u2)} (MonoidHom.{max u1 u2, max u2 u1} (α -> M) (Filter.Germ.{u1, u2} α l M) (Pi.mulOneClass.{u1, u2} α (fun (a._@.Mathlib.Order.Filter.Germ._hyg.3518 : α) => M) (fun (i : α) => Monoid.toMulOneClass.{u2} M _inst_1)) (Monoid.toMulOneClass.{max u1 u2} (Filter.Germ.{u1, u2} α l M) (Filter.Germ.monoid.{u1, u2} α l M _inst_1))) (α -> M) (fun (_x : α -> M) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2398 : α -> M) => Filter.Germ.{u1, u2} α l M) _x) (MulHomClass.toFunLike.{max u1 u2, max u1 u2, max u1 u2} (MonoidHom.{max u1 u2, max u2 u1} (α -> M) (Filter.Germ.{u1, u2} α l M) (Pi.mulOneClass.{u1, u2} α (fun (a._@.Mathlib.Order.Filter.Germ._hyg.3518 : α) => M) (fun (i : α) => Monoid.toMulOneClass.{u2} M _inst_1)) (Monoid.toMulOneClass.{max u1 u2} (Filter.Germ.{u1, u2} α l M) (Filter.Germ.monoid.{u1, u2} α l M _inst_1))) (α -> M) (Filter.Germ.{u1, u2} α l M) (MulOneClass.toMul.{max u1 u2} (α -> M) (Pi.mulOneClass.{u1, u2} α (fun (a._@.Mathlib.Order.Filter.Germ._hyg.3518 : α) => M) (fun (i : α) => Monoid.toMulOneClass.{u2} M _inst_1))) (MulOneClass.toMul.{max u1 u2} (Filter.Germ.{u1, u2} α l M) (Monoid.toMulOneClass.{max u1 u2} (Filter.Germ.{u1, u2} α l M) (Filter.Germ.monoid.{u1, u2} α l M _inst_1))) (MonoidHomClass.toMulHomClass.{max u1 u2, max u1 u2, max u1 u2} (MonoidHom.{max u1 u2, max u2 u1} (α -> M) (Filter.Germ.{u1, u2} α l M) (Pi.mulOneClass.{u1, u2} α (fun (a._@.Mathlib.Order.Filter.Germ._hyg.3518 : α) => M) (fun (i : α) => Monoid.toMulOneClass.{u2} M _inst_1)) (Monoid.toMulOneClass.{max u1 u2} (Filter.Germ.{u1, u2} α l M) (Filter.Germ.monoid.{u1, u2} α l M _inst_1))) (α -> M) (Filter.Germ.{u1, u2} α l M) (Pi.mulOneClass.{u1, u2} α (fun (a._@.Mathlib.Order.Filter.Germ._hyg.3518 : α) => M) (fun (i : α) => Monoid.toMulOneClass.{u2} M _inst_1)) (Monoid.toMulOneClass.{max u1 u2} (Filter.Germ.{u1, u2} α l M) (Filter.Germ.monoid.{u1, u2} α l M _inst_1)) (MonoidHom.monoidHomClass.{max u1 u2, max u1 u2} (α -> M) (Filter.Germ.{u1, u2} α l M) (Pi.mulOneClass.{u1, u2} α (fun (a._@.Mathlib.Order.Filter.Germ._hyg.3518 : α) => M) (fun (i : α) => Monoid.toMulOneClass.{u2} M _inst_1)) (Monoid.toMulOneClass.{max u1 u2} (Filter.Germ.{u1, u2} α l M) (Filter.Germ.monoid.{u1, u2} α l M _inst_1))))) (Filter.Germ.coeMulHom.{u1, u2} α M _inst_1 l)) (Filter.Germ.ofFun.{u1, u2} α M l)
 Case conversion may be inaccurate. Consider using '#align filter.germ.coe_coe_mul_hom Filter.Germ.coe_coeMulHomₓ'. -/
 @[simp, to_additive]
 theorem coe_coeMulHom [Monoid M] : (coeMulHom l : (α → M) → Germ l M) = coe :=
@@ -789,7 +789,7 @@ def coeRingHom [Semiring R] (l : Filter α) : (α → R) →+* Germ l R :=
 lean 3 declaration is
   forall {α : Type.{u1}} {l : Filter.{u1} α} {R : Type.{u2}} [_inst_1 : Semiring.{u2} R], Eq.{max (max (succ u1) (succ u2)) (succ (max u1 u2))} ((fun (_x : RingHom.{max u1 u2, max u1 u2} (α -> R) (Filter.Germ.{u1, u2} α l R) (Pi.nonAssocSemiring.{u1, u2} α (fun (ᾰ : α) => R) (fun (i : α) => Semiring.toNonAssocSemiring.{u2} R _inst_1)) (Semiring.toNonAssocSemiring.{max u1 u2} (Filter.Germ.{u1, u2} α l R) (Filter.Germ.semiring.{u1, u2} α l R _inst_1))) => (α -> R) -> (Filter.Germ.{u1, u2} α l R)) (Filter.Germ.coeRingHom.{u1, u2} α R _inst_1 l)) (coeFn.{succ (max u1 u2), succ (max u1 u2)} (RingHom.{max u1 u2, max u1 u2} (α -> R) (Filter.Germ.{u1, u2} α l R) (Pi.nonAssocSemiring.{u1, u2} α (fun (ᾰ : α) => R) (fun (i : α) => Semiring.toNonAssocSemiring.{u2} R _inst_1)) (Semiring.toNonAssocSemiring.{max u1 u2} (Filter.Germ.{u1, u2} α l R) (Filter.Germ.semiring.{u1, u2} α l R _inst_1))) (fun (_x : RingHom.{max u1 u2, max u1 u2} (α -> R) (Filter.Germ.{u1, u2} α l R) (Pi.nonAssocSemiring.{u1, u2} α (fun (ᾰ : α) => R) (fun (i : α) => Semiring.toNonAssocSemiring.{u2} R _inst_1)) (Semiring.toNonAssocSemiring.{max u1 u2} (Filter.Germ.{u1, u2} α l R) (Filter.Germ.semiring.{u1, u2} α l R _inst_1))) => (α -> R) -> (Filter.Germ.{u1, u2} α l R)) (RingHom.hasCoeToFun.{max u1 u2, max u1 u2} (α -> R) (Filter.Germ.{u1, u2} α l R) (Pi.nonAssocSemiring.{u1, u2} α (fun (ᾰ : α) => R) (fun (i : α) => Semiring.toNonAssocSemiring.{u2} R _inst_1)) (Semiring.toNonAssocSemiring.{max u1 u2} (Filter.Germ.{u1, u2} α l R) (Filter.Germ.semiring.{u1, u2} α l R _inst_1))) (Filter.Germ.coeRingHom.{u1, u2} α R _inst_1 l)) ((fun (a : Sort.{max (succ u1) (succ u2)}) (b : Type.{max u1 u2}) [self : HasLiftT.{max (succ u1) (succ u2), succ (max u1 u2)} a b] => self.0) (α -> R) (Filter.Germ.{u1, u2} α l R) (HasLiftT.mk.{max (succ u1) (succ u2), succ (max u1 u2)} (α -> R) (Filter.Germ.{u1, u2} α l R) (CoeTCₓ.coe.{max (succ u1) (succ u2), succ (max u1 u2)} (α -> R) (Filter.Germ.{u1, u2} α l R) (Filter.Germ.hasCoeT.{u1, u2} α R l))))
 but is expected to have type
-  forall {α : Type.{u1}} {l : Filter.{u1} α} {R : Type.{u2}} [_inst_1 : Semiring.{u2} R], Eq.{max (succ u1) (succ u2)} (forall (a : α -> R), (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2398 : α -> R) => Filter.Germ.{u1, u2} α l R) a) (FunLike.coe.{max (succ u1) (succ u2), max (succ u1) (succ u2), max (succ u1) (succ u2)} (RingHom.{max u1 u2, max u2 u1} (α -> R) (Filter.Germ.{u1, u2} α l R) (Pi.nonAssocSemiring.{u1, u2} α (fun (a._@.Mathlib.Order.Filter.Germ._hyg.4987 : α) => R) (fun (i : α) => Semiring.toNonAssocSemiring.{u2} R _inst_1)) (Semiring.toNonAssocSemiring.{max u1 u2} (Filter.Germ.{u1, u2} α l R) (Filter.Germ.semiring.{u1, u2} α l R _inst_1))) (α -> R) (fun (_x : α -> R) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2398 : α -> R) => Filter.Germ.{u1, u2} α l R) _x) (MulHomClass.toFunLike.{max u1 u2, max u1 u2, max u1 u2} (RingHom.{max u1 u2, max u2 u1} (α -> R) (Filter.Germ.{u1, u2} α l R) (Pi.nonAssocSemiring.{u1, u2} α (fun (a._@.Mathlib.Order.Filter.Germ._hyg.4987 : α) => R) (fun (i : α) => Semiring.toNonAssocSemiring.{u2} R _inst_1)) (Semiring.toNonAssocSemiring.{max u1 u2} (Filter.Germ.{u1, u2} α l R) (Filter.Germ.semiring.{u1, u2} α l R _inst_1))) (α -> R) (Filter.Germ.{u1, u2} α l R) (NonUnitalNonAssocSemiring.toMul.{max u1 u2} (α -> R) (NonAssocSemiring.toNonUnitalNonAssocSemiring.{max u1 u2} (α -> R) (Pi.nonAssocSemiring.{u1, u2} α (fun (a._@.Mathlib.Order.Filter.Germ._hyg.4987 : α) => R) (fun (i : α) => Semiring.toNonAssocSemiring.{u2} R _inst_1)))) (NonUnitalNonAssocSemiring.toMul.{max u1 u2} (Filter.Germ.{u1, u2} α l R) (NonAssocSemiring.toNonUnitalNonAssocSemiring.{max u1 u2} (Filter.Germ.{u1, u2} α l R) (Semiring.toNonAssocSemiring.{max u1 u2} (Filter.Germ.{u1, u2} α l R) (Filter.Germ.semiring.{u1, u2} α l R _inst_1)))) (NonUnitalRingHomClass.toMulHomClass.{max u1 u2, max u1 u2, max u1 u2} (RingHom.{max u1 u2, max u2 u1} (α -> R) (Filter.Germ.{u1, u2} α l R) (Pi.nonAssocSemiring.{u1, u2} α (fun (a._@.Mathlib.Order.Filter.Germ._hyg.4987 : α) => R) (fun (i : α) => Semiring.toNonAssocSemiring.{u2} R _inst_1)) (Semiring.toNonAssocSemiring.{max u1 u2} (Filter.Germ.{u1, u2} α l R) (Filter.Germ.semiring.{u1, u2} α l R _inst_1))) (α -> R) (Filter.Germ.{u1, u2} α l R) (NonAssocSemiring.toNonUnitalNonAssocSemiring.{max u1 u2} (α -> R) (Pi.nonAssocSemiring.{u1, u2} α (fun (a._@.Mathlib.Order.Filter.Germ._hyg.4987 : α) => R) (fun (i : α) => Semiring.toNonAssocSemiring.{u2} R _inst_1))) (NonAssocSemiring.toNonUnitalNonAssocSemiring.{max u1 u2} (Filter.Germ.{u1, u2} α l R) (Semiring.toNonAssocSemiring.{max u1 u2} (Filter.Germ.{u1, u2} α l R) (Filter.Germ.semiring.{u1, u2} α l R _inst_1))) (RingHomClass.toNonUnitalRingHomClass.{max u1 u2, max u1 u2, max u1 u2} (RingHom.{max u1 u2, max u2 u1} (α -> R) (Filter.Germ.{u1, u2} α l R) (Pi.nonAssocSemiring.{u1, u2} α (fun (a._@.Mathlib.Order.Filter.Germ._hyg.4987 : α) => R) (fun (i : α) => Semiring.toNonAssocSemiring.{u2} R _inst_1)) (Semiring.toNonAssocSemiring.{max u1 u2} (Filter.Germ.{u1, u2} α l R) (Filter.Germ.semiring.{u1, u2} α l R _inst_1))) (α -> R) (Filter.Germ.{u1, u2} α l R) (Pi.nonAssocSemiring.{u1, u2} α (fun (a._@.Mathlib.Order.Filter.Germ._hyg.4987 : α) => R) (fun (i : α) => Semiring.toNonAssocSemiring.{u2} R _inst_1)) (Semiring.toNonAssocSemiring.{max u1 u2} (Filter.Germ.{u1, u2} α l R) (Filter.Germ.semiring.{u1, u2} α l R _inst_1)) (RingHom.instRingHomClassRingHom.{max u1 u2, max u1 u2} (α -> R) (Filter.Germ.{u1, u2} α l R) (Pi.nonAssocSemiring.{u1, u2} α (fun (a._@.Mathlib.Order.Filter.Germ._hyg.4987 : α) => R) (fun (i : α) => Semiring.toNonAssocSemiring.{u2} R _inst_1)) (Semiring.toNonAssocSemiring.{max u1 u2} (Filter.Germ.{u1, u2} α l R) (Filter.Germ.semiring.{u1, u2} α l R _inst_1)))))) (Filter.Germ.coeRingHom.{u1, u2} α R _inst_1 l)) (Filter.Germ.ofFun.{u1, u2} α R l)
+  forall {α : Type.{u1}} {l : Filter.{u1} α} {R : Type.{u2}} [_inst_1 : Semiring.{u2} R], Eq.{max (succ u1) (succ u2)} (forall (a : α -> R), (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2398 : α -> R) => Filter.Germ.{u1, u2} α l R) a) (FunLike.coe.{max (succ u1) (succ u2), max (succ u1) (succ u2), max (succ u1) (succ u2)} (RingHom.{max u1 u2, max u2 u1} (α -> R) (Filter.Germ.{u1, u2} α l R) (Pi.nonAssocSemiring.{u1, u2} α (fun (a._@.Mathlib.Order.Filter.Germ._hyg.4919 : α) => R) (fun (i : α) => Semiring.toNonAssocSemiring.{u2} R _inst_1)) (Semiring.toNonAssocSemiring.{max u1 u2} (Filter.Germ.{u1, u2} α l R) (Filter.Germ.semiring.{u1, u2} α l R _inst_1))) (α -> R) (fun (_x : α -> R) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2398 : α -> R) => Filter.Germ.{u1, u2} α l R) _x) (MulHomClass.toFunLike.{max u1 u2, max u1 u2, max u1 u2} (RingHom.{max u1 u2, max u2 u1} (α -> R) (Filter.Germ.{u1, u2} α l R) (Pi.nonAssocSemiring.{u1, u2} α (fun (a._@.Mathlib.Order.Filter.Germ._hyg.4919 : α) => R) (fun (i : α) => Semiring.toNonAssocSemiring.{u2} R _inst_1)) (Semiring.toNonAssocSemiring.{max u1 u2} (Filter.Germ.{u1, u2} α l R) (Filter.Germ.semiring.{u1, u2} α l R _inst_1))) (α -> R) (Filter.Germ.{u1, u2} α l R) (NonUnitalNonAssocSemiring.toMul.{max u1 u2} (α -> R) (NonAssocSemiring.toNonUnitalNonAssocSemiring.{max u1 u2} (α -> R) (Pi.nonAssocSemiring.{u1, u2} α (fun (a._@.Mathlib.Order.Filter.Germ._hyg.4919 : α) => R) (fun (i : α) => Semiring.toNonAssocSemiring.{u2} R _inst_1)))) (NonUnitalNonAssocSemiring.toMul.{max u1 u2} (Filter.Germ.{u1, u2} α l R) (NonAssocSemiring.toNonUnitalNonAssocSemiring.{max u1 u2} (Filter.Germ.{u1, u2} α l R) (Semiring.toNonAssocSemiring.{max u1 u2} (Filter.Germ.{u1, u2} α l R) (Filter.Germ.semiring.{u1, u2} α l R _inst_1)))) (NonUnitalRingHomClass.toMulHomClass.{max u1 u2, max u1 u2, max u1 u2} (RingHom.{max u1 u2, max u2 u1} (α -> R) (Filter.Germ.{u1, u2} α l R) (Pi.nonAssocSemiring.{u1, u2} α (fun (a._@.Mathlib.Order.Filter.Germ._hyg.4919 : α) => R) (fun (i : α) => Semiring.toNonAssocSemiring.{u2} R _inst_1)) (Semiring.toNonAssocSemiring.{max u1 u2} (Filter.Germ.{u1, u2} α l R) (Filter.Germ.semiring.{u1, u2} α l R _inst_1))) (α -> R) (Filter.Germ.{u1, u2} α l R) (NonAssocSemiring.toNonUnitalNonAssocSemiring.{max u1 u2} (α -> R) (Pi.nonAssocSemiring.{u1, u2} α (fun (a._@.Mathlib.Order.Filter.Germ._hyg.4919 : α) => R) (fun (i : α) => Semiring.toNonAssocSemiring.{u2} R _inst_1))) (NonAssocSemiring.toNonUnitalNonAssocSemiring.{max u1 u2} (Filter.Germ.{u1, u2} α l R) (Semiring.toNonAssocSemiring.{max u1 u2} (Filter.Germ.{u1, u2} α l R) (Filter.Germ.semiring.{u1, u2} α l R _inst_1))) (RingHomClass.toNonUnitalRingHomClass.{max u1 u2, max u1 u2, max u1 u2} (RingHom.{max u1 u2, max u2 u1} (α -> R) (Filter.Germ.{u1, u2} α l R) (Pi.nonAssocSemiring.{u1, u2} α (fun (a._@.Mathlib.Order.Filter.Germ._hyg.4919 : α) => R) (fun (i : α) => Semiring.toNonAssocSemiring.{u2} R _inst_1)) (Semiring.toNonAssocSemiring.{max u1 u2} (Filter.Germ.{u1, u2} α l R) (Filter.Germ.semiring.{u1, u2} α l R _inst_1))) (α -> R) (Filter.Germ.{u1, u2} α l R) (Pi.nonAssocSemiring.{u1, u2} α (fun (a._@.Mathlib.Order.Filter.Germ._hyg.4919 : α) => R) (fun (i : α) => Semiring.toNonAssocSemiring.{u2} R _inst_1)) (Semiring.toNonAssocSemiring.{max u1 u2} (Filter.Germ.{u1, u2} α l R) (Filter.Germ.semiring.{u1, u2} α l R _inst_1)) (RingHom.instRingHomClassRingHom.{max u1 u2, max u1 u2} (α -> R) (Filter.Germ.{u1, u2} α l R) (Pi.nonAssocSemiring.{u1, u2} α (fun (a._@.Mathlib.Order.Filter.Germ._hyg.4919 : α) => R) (fun (i : α) => Semiring.toNonAssocSemiring.{u2} R _inst_1)) (Semiring.toNonAssocSemiring.{max u1 u2} (Filter.Germ.{u1, u2} α l R) (Filter.Germ.semiring.{u1, u2} α l R _inst_1)))))) (Filter.Germ.coeRingHom.{u1, u2} α R _inst_1 l)) (Filter.Germ.ofFun.{u1, u2} α R l)
 Case conversion may be inaccurate. Consider using '#align filter.germ.coe_coe_ring_hom Filter.Germ.coe_coeRingHomₓ'. -/
 @[simp]
 theorem coe_coeRingHom [Semiring R] : (coeRingHom l : (α → R) → Germ l R) = coe :=

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

Fix a few names and deduplicate the AddCommGroup ℤ instance

@@ -98,7 +98,7 @@ variable {ε : α → Type*}
 instance coeTC : CoeTC ((a : _) → ε a) (l.Product ε) :=
   ⟨@Quotient.mk' _ (productSetoid _ ε)⟩
 
-instance inhabited [(a : _) → Inhabited (ε a)] : Inhabited (l.Product ε) :=
+instance instInhabited [(a : _) → Inhabited (ε a)] : Inhabited (l.Product ε) :=
   ⟨(↑fun a => (default : ε a) : l.Product ε)⟩
 
 end Product
@@ -361,16 +361,13 @@ theorem liftRel_const_iff [NeBot l] {r : β → γ → Prop} {x : β} {y : γ} :
   @eventually_const _ _ _ (r x y)
 #align filter.germ.lift_rel_const_iff Filter.Germ.liftRel_const_iff
 
-instance inhabited [Inhabited β] : Inhabited (Germ l β) :=
-  ⟨↑(default : β)⟩
+instance instInhabited [Inhabited β] : Inhabited (Germ l β) := ⟨↑(default : β)⟩
 
 section Monoid
 
 variable {M : Type*} {G : Type*}
 
-@[to_additive]
-instance mul [Mul M] : Mul (Germ l M) :=
-  ⟨map₂ (· * ·)⟩
+@[to_additive] instance instMul [Mul M] : Mul (Germ l M) := ⟨map₂ (· * ·)⟩
 
 @[to_additive (attr := simp, norm_cast)]
 theorem coe_mul [Mul M] (f g : α → M) : ↑(f * g) = (f * g : Germ l M) :=
@@ -378,9 +375,7 @@ theorem coe_mul [Mul M] (f g : α → M) : ↑(f * g) = (f * g : Germ l M) :=
 #align filter.germ.coe_mul Filter.Germ.coe_mul
 #align filter.germ.coe_add Filter.Germ.coe_add
 
-@[to_additive]
-instance one [One M] : One (Germ l M) :=
-  ⟨↑(1 : M)⟩
+@[to_additive] instance instOne [One M] : One (Germ l M) := ⟨↑(1 : M)⟩
 
 @[to_additive (attr := simp, norm_cast)]
 theorem coe_one [One M] : ↑(1 : α → M) = (1 : Germ l M) :=
@@ -389,12 +384,12 @@ theorem coe_one [One M] : ↑(1 : α → M) = (1 : Germ l M) :=
 #align filter.germ.coe_zero Filter.Germ.coe_zero
 
 @[to_additive]
-instance semigroup [Semigroup M] : Semigroup (Germ l M) :=
+instance instSemigroup [Semigroup M] : Semigroup (Germ l M) :=
   { mul_assoc := fun a b c => Quotient.inductionOn₃' a b c
       fun _ _ _ => congrArg ofFun <| mul_assoc .. }
 
 @[to_additive]
-instance commSemigroup [CommSemigroup M] : CommSemigroup (Germ l M) :=
+instance instCommSemigroup [CommSemigroup M] : CommSemigroup (Germ l M) :=
   { mul_comm := Quotient.ind₂' fun _ _ => congrArg ofFun <| mul_comm .. }
 
 @[to_additive]
@@ -413,25 +408,23 @@ instance instIsRightCancelMul [Mul M] [IsRightCancelMul M] : IsRightCancelMul (G
 instance instIsCancelMul [Mul M] [IsCancelMul M] : IsCancelMul (Germ l M) where
 
 @[to_additive]
-instance leftCancelSemigroup [LeftCancelSemigroup M] : LeftCancelSemigroup (Germ l M) :=
-  { Germ.semigroup with mul_left_cancel := fun _ _ _ => mul_left_cancel }
+instance instLeftCancelSemigroup [LeftCancelSemigroup M] : LeftCancelSemigroup (Germ l M) where
+  mul_left_cancel _ _ _ := mul_left_cancel
 
 @[to_additive]
-instance rightCancelSemigroup [RightCancelSemigroup M] : RightCancelSemigroup (Germ l M) :=
-  { Germ.semigroup with mul_right_cancel := fun _ _ _ => mul_right_cancel }
+instance instRightCancelSemigroup [RightCancelSemigroup M] : RightCancelSemigroup (Germ l M) where
+  mul_right_cancel _ _ _ := mul_right_cancel
 
 @[to_additive]
-instance mulOneClass [MulOneClass M] : MulOneClass (Germ l M) :=
+instance instMulOneClass [MulOneClass M] : MulOneClass (Germ l M) :=
   { one_mul := Quotient.ind' fun _ => congrArg ofFun <| one_mul _
     mul_one := Quotient.ind' fun _ => congrArg ofFun <| mul_one _ }
 
 @[to_additive]
-instance smul [SMul M G] : SMul M (Germ l G) :=
-  ⟨fun n => map (n • ·)⟩
+instance instSMul [SMul M G] : SMul M (Germ l G) where smul n := map (n • ·)
 
-@[to_additive existing smul]
-instance pow [Pow G M] : Pow (Germ l G) M :=
-  ⟨fun f n => map (· ^ n) f⟩
+@[to_additive existing instSMul]
+instance instPow [Pow G M] : Pow (Germ l G) M where pow f n := map (· ^ n) f
 
 @[to_additive (attr := simp, norm_cast)]
 theorem coe_smul [SMul M G] (n : M) (f : α → G) : ↑(n • f) = n • (f : Germ l G) :=
@@ -457,11 +450,11 @@ theorem const_pow [Pow G M] (a : G) (n : M) : (↑(a ^ n) : Germ l G) = (↑a :
 
 -- TODO: #7432
 @[to_additive]
-instance monoid [Monoid M] : Monoid (Germ l M) :=
+instance instMonoid [Monoid M] : Monoid (Germ l M) :=
   { Function.Surjective.monoid ofFun (surjective_quot_mk _) (by rfl)
       (fun _ _ => by rfl) fun _ _ => by rfl with
-    toSemigroup := semigroup
-    toOne := one
+    toSemigroup := instSemigroup
+    toOne := instOne
     npow := fun n a => a ^ n }
 
 /-- Coercion from functions to germs as a monoid homomorphism. -/
@@ -478,11 +471,10 @@ theorem coe_coeMulHom [Monoid M] : (coeMulHom l : (α → M) → Germ l M) = ofF
 #align filter.germ.coe_coe_add_hom Filter.Germ.coe_coeAddHom
 
 @[to_additive]
-instance commMonoid [CommMonoid M] : CommMonoid (Germ l M) :=
+instance instCommMonoid [CommMonoid M] : CommMonoid (Germ l M) :=
   { mul_comm := mul_comm }
 
-instance natCast [NatCast M] : NatCast (Germ l M) where
-  natCast n := (n : α → M)
+instance instNatCast [NatCast M] : NatCast (Germ l M) where natCast n := (n : α → M)
 
 @[simp]
 theorem natCast_def [NatCast M] (n : ℕ) : ((fun _ ↦ n : α → M) : Germ l M) = n := rfl
@@ -502,8 +494,7 @@ theorem const_ofNat [NatCast M] (n : ℕ) [n.AtLeastTwo] :
     ((no_index (OfNat.ofNat n : M)) : Germ l M) = OfNat.ofNat n :=
   rfl
 
-instance intCast [IntCast M] : IntCast (Germ l M) where
-  intCast n := (n : α → M)
+instance instIntCast [IntCast M] : IntCast (Germ l M) where intCast n := (n : α → M)
 
 @[simp]
 theorem intCast_def [IntCast M] (n : ℤ) : ((fun _ ↦ n : α → M) : Germ l M) = n := rfl
@@ -512,17 +503,14 @@ theorem intCast_def [IntCast M] (n : ℤ) : ((fun _ ↦ n : α → M) : Germ l M
 @[deprecated] alias coe_nat := natCast_def
 @[deprecated] alias coe_int := intCast_def
 
-instance addMonoidWithOne [AddMonoidWithOne M] : AddMonoidWithOne (Germ l M) :=
-  { natCast, addMonoid, one with
-    natCast_zero := congrArg ofFun <| by simp; rfl
-    natCast_succ := fun _ => congrArg ofFun <| by simp [Function.comp]; rfl }
+instance instAddMonoidWithOne [AddMonoidWithOne M] : AddMonoidWithOne (Germ l M) where
+  natCast_zero := congrArg ofFun <| by simp; rfl
+  natCast_succ _ := congrArg ofFun <| by simp [Function.comp]; rfl
 
-instance addCommMonoidWithOne [AddCommMonoidWithOne M] : AddCommMonoidWithOne (Germ l M) :=
+instance instAddCommMonoidWithOne [AddCommMonoidWithOne M] : AddCommMonoidWithOne (Germ l M) :=
   { add_comm := add_comm }
 
-@[to_additive]
-instance inv [Inv G] : Inv (Germ l G) :=
-  ⟨map Inv.inv⟩
+@[to_additive] instance instInv [Inv G] : Inv (Germ l G) := ⟨map Inv.inv⟩
 
 @[to_additive (attr := simp, norm_cast)]
 theorem coe_inv [Inv G] (f : α → G) : ↑f⁻¹ = (f⁻¹ : Germ l G) :=
@@ -536,9 +524,7 @@ theorem const_inv [Inv G] (a : G) : (↑(a⁻¹) : Germ l G) = (↑a)⁻¹ :=
 #align filter.germ.const_inv Filter.Germ.const_inv
 #align filter.germ.const_neg Filter.Germ.const_neg
 
-@[to_additive]
-instance div [Div M] : Div (Germ l M) :=
-  ⟨map₂ (· / ·)⟩
+@[to_additive] instance instDiv [Div M] : Div (Germ l M) := ⟨map₂ (· / ·)⟩
 
 @[to_additive (attr := simp, norm_cast)]
 theorem coe_div [Div M] (f g : α → M) : ↑(f / g) = (f / g : Germ l M) :=
@@ -553,49 +539,48 @@ theorem const_div [Div M] (a b : M) : (↑(a / b) : Germ l M) = ↑a / ↑b :=
 #align filter.germ.const_sub Filter.Germ.const_sub
 
 @[to_additive]
-instance involutiveInv [InvolutiveInv G] : InvolutiveInv (Germ l G) :=
+instance instInvolutiveInv [InvolutiveInv G] : InvolutiveInv (Germ l G) :=
   { inv_inv := Quotient.ind' fun _ => congrArg ofFun<| inv_inv _ }
 
-instance hasDistribNeg [Mul G] [HasDistribNeg G] : HasDistribNeg (Germ l G) :=
+instance instHasDistribNeg [Mul G] [HasDistribNeg G] : HasDistribNeg (Germ l G) :=
   { neg_mul := Quotient.ind₂' fun _ _ => congrArg ofFun <| neg_mul ..
     mul_neg := Quotient.ind₂' fun _ _ => congrArg ofFun <| mul_neg .. }
 
 @[to_additive]
-instance invOneClass [InvOneClass G] : InvOneClass (Germ l G) :=
+instance instInvOneClass [InvOneClass G] : InvOneClass (Germ l G) :=
   ⟨congr_arg ofFun inv_one⟩
 
 @[to_additive subNegMonoid]
-instance divInvMonoid [DivInvMonoid G] : DivInvMonoid (Germ l G) :=
-  { monoid, inv, div with
-    zpow := fun z f => f ^ z
-    zpow_zero' := Quotient.ind' fun _ => congrArg ofFun <|
-      funext fun _ => DivInvMonoid.zpow_zero' _
-    zpow_succ' := fun _ => Quotient.ind' fun _ => congrArg ofFun <|
-      funext fun _ => DivInvMonoid.zpow_succ' ..
-    zpow_neg' := fun _ => Quotient.ind' fun _ => congrArg ofFun <|
-      funext fun _ => DivInvMonoid.zpow_neg' ..
-    div_eq_mul_inv := Quotient.ind₂' fun _ _ => congrArg ofFun <|
-      div_eq_mul_inv .. }
+instance instDivInvMonoid [DivInvMonoid G] : DivInvMonoid (Germ l G) where
+  zpow z f := f ^ z
+  zpow_zero' := Quotient.ind' fun _ => congrArg ofFun <|
+    funext fun _ => DivInvMonoid.zpow_zero' _
+  zpow_succ' _ := Quotient.ind' fun _ => congrArg ofFun <|
+    funext fun _ => DivInvMonoid.zpow_succ' ..
+  zpow_neg' _ := Quotient.ind' fun _ => congrArg ofFun <|
+    funext fun _ => DivInvMonoid.zpow_neg' ..
+  div_eq_mul_inv := Quotient.ind₂' fun _ _ ↦ congrArg ofFun <| div_eq_mul_inv ..
 
 @[to_additive]
-instance divisionMonoid [DivisionMonoid G] : DivisionMonoid (Germ l G) where
+instance instDivisionMonoid [DivisionMonoid G] : DivisionMonoid (Germ l G) where
   inv_inv := inv_inv
   mul_inv_rev x y := inductionOn₂ x y fun _ _ ↦ congr_arg ofFun <| mul_inv_rev _ _
   inv_eq_of_mul x y := inductionOn₂ x y fun _ _ h ↦ coe_eq.2 <| (coe_eq.1 h).mono fun _ ↦
     DivisionMonoid.inv_eq_of_mul _ _
 
 @[to_additive]
-instance group [Group G] : Group (Germ l G) :=
+instance instGroup [Group G] : Group (Germ l G) :=
   { mul_left_inv := Quotient.ind' fun _ => congrArg ofFun <| mul_left_inv _ }
 
 @[to_additive]
-instance commGroup [CommGroup G] : CommGroup (Germ l G) :=
+instance instCommGroup [CommGroup G] : CommGroup (Germ l G) :=
   { mul_comm := mul_comm }
 
-instance addGroupWithOne [AddGroupWithOne G] : AddGroupWithOne (Germ l G) :=
-  { intCast, addMonoidWithOne, addGroup with
-    intCast_ofNat := fun _ => congrArg ofFun <| by simp
-    intCast_negSucc := fun _ => congrArg ofFun <| by simp [Function.comp]; rfl }
+instance instAddGroupWithOne [AddGroupWithOne G] : AddGroupWithOne (Germ l G) where
+  __ := instAddMonoidWithOne
+  __ := instAddGroup
+  intCast_ofNat _ := congrArg ofFun <| by simp
+  intCast_negSucc _ := congrArg ofFun <| by simp [Function.comp]; rfl
 
 end Monoid
 
@@ -603,63 +588,76 @@ section Ring
 
 variable {R : Type*}
 
-instance nontrivial [Nontrivial R] [NeBot l] : Nontrivial (Germ l R) :=
+instance instNontrivial [Nontrivial R] [NeBot l] : Nontrivial (Germ l R) :=
   let ⟨x, y, h⟩ := exists_pair_ne R
   ⟨⟨↑x, ↑y, mt const_inj.1 h⟩⟩
-#align filter.germ.nontrivial Filter.Germ.nontrivial
+#align filter.germ.nontrivial Filter.Germ.instNontrivial
 
-instance mulZeroClass [MulZeroClass R] : MulZeroClass (Germ l R) :=
+instance instMulZeroClass [MulZeroClass R] : MulZeroClass (Germ l R) :=
   { zero_mul := Quotient.ind' fun _ => congrArg ofFun <| zero_mul _
     mul_zero := Quotient.ind' fun _ => congrArg ofFun <| mul_zero _ }
 
-instance mulZeroOneClass [MulZeroOneClass R] : MulZeroOneClass (Germ l R) :=
-  { mulZeroClass, mulOneClass with }
+instance instMulZeroOneClass [MulZeroOneClass R] : MulZeroOneClass (Germ l R) where
+  __ := instMulZeroClass
+  __ := instMulOneClass
 
-instance monoidWithZero [MonoidWithZero R] : MonoidWithZero (Germ l R) :=
-  { monoid, mulZeroClass with }
+instance instMonoidWithZero [MonoidWithZero R] : MonoidWithZero (Germ l R) where
+  __ := instMonoid
+  __ := instMulZeroClass
 
-instance distrib [Distrib R] : Distrib (Germ l R) :=
-  { left_distrib := fun a b c => Quotient.inductionOn₃' a b c
-      fun _ _ _ => congrArg ofFun <| left_distrib ..
-    right_distrib := fun a b c => Quotient.inductionOn₃' a b c
-      fun _ _ _ => congrArg ofFun <| right_distrib .. }
+instance instDistrib [Distrib R] : Distrib (Germ l R) where
+  left_distrib a b c := Quotient.inductionOn₃' a b c fun _ _ _ ↦ congrArg ofFun <| left_distrib ..
+  right_distrib a b c := Quotient.inductionOn₃' a b c fun _ _ _ ↦ congrArg ofFun <| right_distrib ..
 
-instance nonUnitalNonAssocSemiring [NonUnitalNonAssocSemiring R] :
-    NonUnitalNonAssocSemiring (Germ l R) :=
-  { addCommMonoid, distrib, mulZeroClass with }
+instance instNonUnitalNonAssocSemiring [NonUnitalNonAssocSemiring R] :
+    NonUnitalNonAssocSemiring (Germ l R) where
+  __ := instAddCommMonoid
+  __ := instDistrib
+  __ := instMulZeroClass
 
-instance nonUnitalSemiring [NonUnitalSemiring R] : NonUnitalSemiring (Germ l R) :=
+instance instNonUnitalSemiring [NonUnitalSemiring R] : NonUnitalSemiring (Germ l R) :=
   { mul_assoc := mul_assoc }
 
-instance nonAssocSemiring [NonAssocSemiring R] : NonAssocSemiring (Germ l R) :=
-  { nonUnitalNonAssocSemiring, mulZeroOneClass, addMonoidWithOne with }
+instance instNonAssocSemiring [NonAssocSemiring R] : NonAssocSemiring (Germ l R) where
+  __ := instNonUnitalNonAssocSemiring
+  __ := instMulZeroOneClass
+  __ := instAddMonoidWithOne
 
-instance nonUnitalNonAssocRing [NonUnitalNonAssocRing R] :
-    NonUnitalNonAssocRing (Germ l R) :=
-  { addCommGroup, nonUnitalNonAssocSemiring with }
+instance instNonUnitalNonAssocRing [NonUnitalNonAssocRing R] :
+    NonUnitalNonAssocRing (Germ l R) where
+  __ := instAddCommGroup
+  __ := instNonUnitalNonAssocSemiring
 
-instance nonUnitalRing [NonUnitalRing R] : NonUnitalRing (Germ l R) :=
+instance instNonUnitalRing [NonUnitalRing R] : NonUnitalRing (Germ l R) :=
   { mul_assoc := mul_assoc }
 
-instance nonAssocRing [NonAssocRing R] : NonAssocRing (Germ l R) :=
-  { nonUnitalNonAssocRing, nonAssocSemiring, addGroupWithOne with }
+instance instNonAssocRing [NonAssocRing R] : NonAssocRing (Germ l R) where
+  __ := instNonUnitalNonAssocRing
+  __ := instNonAssocSemiring
+  __ := instAddGroupWithOne
 
-instance semiring [Semiring R] : Semiring (Germ l R) :=
-  { nonUnitalSemiring, nonAssocSemiring, monoidWithZero with }
+instance instSemiring [Semiring R] : Semiring (Germ l R) where
+  __ := instNonUnitalSemiring
+  __ := instNonAssocSemiring
+  __ := instMonoidWithZero
 
-instance ring [Ring R] : Ring (Germ l R) :=
-  { semiring, addCommGroup, nonAssocRing with }
+instance instRing [Ring R] : Ring (Germ l R) where
+  __ := instSemiring
+  __ := instAddCommGroup
+  __ := instNonAssocRing
 
-instance nonUnitalCommSemiring [NonUnitalCommSemiring R] : NonUnitalCommSemiring (Germ l R) :=
+instance instNonUnitalCommSemiring [NonUnitalCommSemiring R] :
+    NonUnitalCommSemiring (Germ l R) :=
   { mul_comm := mul_comm }
 
-instance commSemiring [CommSemiring R] : CommSemiring (Germ l R) :=
+instance instCommSemiring [CommSemiring R] : CommSemiring (Germ l R) :=
   { mul_comm := mul_comm }
 
-instance nonUnitalCommRing [NonUnitalCommRing R] : NonUnitalCommRing (Germ l R) :=
-  { nonUnitalRing, commSemigroup with }
+instance instNonUnitalCommRing [NonUnitalCommRing R] : NonUnitalCommRing (Germ l R) where
+  __ := instNonUnitalRing
+  __ := instCommSemigroup
 
-instance commRing [CommRing R] : CommRing (Germ l R) :=
+instance instCommRing [CommRing R] : CommRing (Germ l R) :=
   { mul_comm := mul_comm }
 
 /-- Coercion `(α → R) → Germ l R` as a `RingHom`. -/
@@ -691,7 +689,7 @@ theorem coe_smul' [SMul M β] (c : α → M) (f : α → β) : ↑(c • f) = (c
 #align filter.germ.coe_vadd' Filter.Germ.coe_vadd'
 
 @[to_additive]
-instance mulAction [Monoid M] [MulAction M β] : MulAction M (Germ l β) where
+instance instMulAction [Monoid M] [MulAction M β] : MulAction M (Germ l β) where
   one_smul f :=
     inductionOn f fun f => by
       norm_cast
@@ -702,16 +700,16 @@ instance mulAction [Monoid M] [MulAction M β] : MulAction M (Germ l β) where
       simp [mul_smul]
 
 @[to_additive]
-instance mulAction' [Monoid M] [MulAction M β] : MulAction (Germ l M) (Germ l β) where
+instance instMulAction' [Monoid M] [MulAction M β] : MulAction (Germ l M) (Germ l β) where
   one_smul f := inductionOn f fun f => by simp only [← coe_one, ← coe_smul', one_smul]
   mul_smul c₁ c₂ f :=
     inductionOn₃ c₁ c₂ f fun c₁ c₂ f => by
       norm_cast
       simp [mul_smul]
-#align filter.germ.mul_action' Filter.Germ.mulAction'
-#align filter.germ.add_action' Filter.Germ.addAction'
+#align filter.germ.mul_action' Filter.Germ.instMulAction'
+#align filter.germ.add_action' Filter.Germ.instAddAction'
 
-instance distribMulAction [Monoid M] [AddMonoid N] [DistribMulAction M N] :
+instance instDistribMulAction [Monoid M] [AddMonoid N] [DistribMulAction M N] :
     DistribMulAction M (Germ l N) where
   smul_add c f g :=
     inductionOn₂ f g fun f g => by
@@ -719,16 +717,16 @@ instance distribMulAction [Monoid M] [AddMonoid N] [DistribMulAction M N] :
       simp [smul_add]
   smul_zero c := by simp only [← coe_zero, ← coe_smul, smul_zero]
 
-instance distribMulAction' [Monoid M] [AddMonoid N] [DistribMulAction M N] :
+instance instDistribMulAction' [Monoid M] [AddMonoid N] [DistribMulAction M N] :
     DistribMulAction (Germ l M) (Germ l N) where
   smul_add c f g :=
     inductionOn₃ c f g fun c f g => by
       norm_cast
       simp [smul_add]
   smul_zero c := inductionOn c fun c => by simp only [← coe_zero, ← coe_smul', smul_zero]
-#align filter.germ.distrib_mul_action' Filter.Germ.distribMulAction'
+#align filter.germ.distrib_mul_action' Filter.Germ.instDistribMulAction'
 
-instance module [Semiring R] [AddCommMonoid M] [Module R M] : Module R (Germ l M) where
+instance instModule [Semiring R] [AddCommMonoid M] [Module R M] : Module R (Germ l M) where
   add_smul c₁ c₂ f :=
     inductionOn f fun f => by
       norm_cast
@@ -738,18 +736,18 @@ instance module [Semiring R] [AddCommMonoid M] [Module R M] : Module R (Germ l M
       norm_cast
       simp [zero_smul, coe_zero]
 
-instance module' [Semiring R] [AddCommMonoid M] [Module R M] : Module (Germ l R) (Germ l M) where
+instance instModule' [Semiring R] [AddCommMonoid M] [Module R M] :
+    Module (Germ l R) (Germ l M) where
   add_smul c₁ c₂ f :=
     inductionOn₃ c₁ c₂ f fun c₁ c₂ f => by
       norm_cast
       simp [add_smul]
   zero_smul f := inductionOn f fun f => by simp only [← coe_zero, ← coe_smul', zero_smul]
-#align filter.germ.module' Filter.Germ.module'
+#align filter.germ.module' Filter.Germ.instModule'
 
 end Module
 
-instance le [LE β] : LE (Germ l β) :=
-  ⟨LiftRel (· ≤ ·)⟩
+instance instLE [LE β] : LE (Germ l β) := ⟨LiftRel (· ≤ ·)⟩
 
 theorem le_def [LE β] : ((· ≤ ·) : Germ l β → Germ l β → Prop) = LiftRel (· ≤ ·) :=
   rfl
@@ -773,22 +771,16 @@ theorem const_le_iff [LE β] [NeBot l] {x y : β} : (↑x : Germ l β) ≤ ↑y
   liftRel_const_iff
 #align filter.germ.const_le_iff Filter.Germ.const_le_iff
 
-instance preorder [Preorder β] : Preorder (Germ l β) where
+instance instPreorder [Preorder β] : Preorder (Germ l β) where
   le := (· ≤ ·)
   le_refl f := inductionOn f <| EventuallyLE.refl l
   le_trans f₁ f₂ f₃ := inductionOn₃ f₁ f₂ f₃ fun f₁ f₂ f₃ => EventuallyLE.trans
 
-instance partialOrder [PartialOrder β] : PartialOrder (Germ l β) :=
-  { Filter.Germ.preorder with
-    le := (· ≤ ·)
-    le_antisymm := fun f g =>
-      inductionOn₂ f g fun _ _ h₁ h₂ => (EventuallyLE.antisymm h₁ h₂).germ_eq }
-
-instance bot [Bot β] : Bot (Germ l β) :=
-  ⟨↑(⊥ : β)⟩
+instance instPartialOrder [PartialOrder β] : PartialOrder (Germ l β) where
+  le_antisymm f g := inductionOn₂ f g fun _ _ h₁ h₂ ↦ (EventuallyLE.antisymm h₁ h₂).germ_eq
 
-instance top [Top β] : Top (Germ l β) :=
-  ⟨↑(⊤ : β)⟩
+instance instBot [Bot β] : Bot (Germ l β) := ⟨↑(⊥ : β)⟩
+instance instTop [Top β] : Top (Germ l β) := ⟨↑(⊤ : β)⟩
 
 @[simp, norm_cast]
 theorem const_bot [Bot β] : (↑(⊥ : β) : Germ l β) = ⊥ :=
@@ -800,22 +792,18 @@ theorem const_top [Top β] : (↑(⊤ : β) : Germ l β) = ⊤ :=
   rfl
 #align filter.germ.const_top Filter.Germ.const_top
 
-instance orderBot [LE β] [OrderBot β] : OrderBot (Germ l β) where
-  bot := ⊥
+instance instOrderBot [LE β] [OrderBot β] : OrderBot (Germ l β) where
   bot_le f := inductionOn f fun _ => eventually_of_forall fun _ => bot_le
 
-instance orderTop [LE β] [OrderTop β] : OrderTop (Germ l β) where
-  top := ⊤
+instance instOrderTop [LE β] [OrderTop β] : OrderTop (Germ l β) where
   le_top f := inductionOn f fun _ => eventually_of_forall fun _ => le_top
 
-instance [LE β] [BoundedOrder β] : BoundedOrder (Germ l β) :=
-  { Filter.Germ.orderBot, Filter.Germ.orderTop with }
+instance instBoundedOrder [LE β] [BoundedOrder β] : BoundedOrder (Germ l β) where
+  __ := instOrderBot
+  __ := instOrderTop
 
-instance sup [Sup β] : Sup (Germ l β) :=
-  ⟨map₂ (· ⊔ ·)⟩
-
-instance inf [Inf β] : Inf (Germ l β) :=
-  ⟨map₂ (· ⊓ ·)⟩
+instance instSup [Sup β] : Sup (Germ l β) := ⟨map₂ (· ⊔ ·)⟩
+instance instInf [Inf β] : Inf (Germ l β) := ⟨map₂ (· ⊓ ·)⟩
 
 @[simp, norm_cast]
 theorem const_sup [Sup β] (a b : β) : ↑(a ⊔ b) = (↑a ⊔ ↑b : Germ l β) :=
@@ -827,54 +815,41 @@ theorem const_inf [Inf β] (a b : β) : ↑(a ⊓ b) = (↑a ⊓ ↑b : Germ l 
   rfl
 #align filter.germ.const_inf Filter.Germ.const_inf
 
-instance semilatticeSup [SemilatticeSup β] : SemilatticeSup (Germ l β) :=
-  { Germ.partialOrder with
-    sup := (· ⊔ ·)
-    le_sup_left := fun f g =>
-        inductionOn₂ f g fun _f _g => eventually_of_forall fun _x => le_sup_left
-    le_sup_right := fun f g =>
-      inductionOn₂ f g fun _f _g => eventually_of_forall fun _x => le_sup_right
-    sup_le := fun f₁ f₂ g =>
-      inductionOn₃ f₁ f₂ g fun _f₁ _f₂ _g h₁ h₂ => h₂.mp <| h₁.mono fun _x => sup_le }
-
-instance semilatticeInf [SemilatticeInf β] : SemilatticeInf (Germ l β) :=
-  { Germ.partialOrder with
-    inf := (· ⊓ ·)
-    inf_le_left := fun f g =>
-        inductionOn₂ f g fun _f _g => eventually_of_forall fun _x => inf_le_left
-    inf_le_right := fun f g =>
-      inductionOn₂ f g fun _f _g => eventually_of_forall fun _x => inf_le_right
-    le_inf := fun f₁ f₂ g =>
-      inductionOn₃ f₁ f₂ g fun _f₁ _f₂ _g h₁ h₂ => h₂.mp <| h₁.mono fun _x => le_inf }
-
-instance lattice [Lattice β] : Lattice (Germ l β) :=
-  { Germ.semilatticeSup, Germ.semilatticeInf with }
-
-instance distribLattice [DistribLattice β] : DistribLattice (Germ l β) :=
-  { Germ.semilatticeSup, Germ.semilatticeInf with
-    le_sup_inf := fun f g h =>
-      inductionOn₃ f g h fun _f _g _h => eventually_of_forall fun _ => le_sup_inf }
+instance instSemilatticeSup [SemilatticeSup β] : SemilatticeSup (Germ l β) where
+  le_sup_left f g := inductionOn₂ f g fun _f _g => eventually_of_forall fun _x ↦ le_sup_left
+  le_sup_right f g := inductionOn₂ f g fun _f _g ↦ eventually_of_forall fun _x ↦ le_sup_right
+  sup_le f₁ f₂ g := inductionOn₃ f₁ f₂ g fun _f₁ _f₂ _g h₁ h₂ ↦ h₂.mp <| h₁.mono fun _x ↦ sup_le
+
+instance instSemilatticeInf [SemilatticeInf β] : SemilatticeInf (Germ l β) where
+  inf_le_left f g := inductionOn₂ f g fun _f _g ↦ eventually_of_forall fun _x ↦ inf_le_left
+  inf_le_right f g := inductionOn₂ f g fun _f _g ↦ eventually_of_forall fun _x ↦ inf_le_right
+  le_inf f₁ f₂ g := inductionOn₃ f₁ f₂ g fun _f₁ _f₂ _g h₁ h₂ ↦ h₂.mp <| h₁.mono fun _x ↦ le_inf
+
+instance instLattice [Lattice β] : Lattice (Germ l β) where
+  __ := instSemilatticeSup
+  __ := instSemilatticeInf
+
+instance instDistribLattice [DistribLattice β] : DistribLattice (Germ l β) where
+  le_sup_inf f g h := inductionOn₃ f g h fun _f _g _h ↦ eventually_of_forall fun _ ↦ le_sup_inf
 
 @[to_additive]
-instance orderedCommMonoid [OrderedCommMonoid β] : OrderedCommMonoid (Germ l β) :=
-  { Germ.partialOrder, Germ.commMonoid with
-    mul_le_mul_left := fun f g =>
-      inductionOn₂ f g fun _f _g H h =>
-        inductionOn h fun _h => H.mono fun _x H => mul_le_mul_left' H _ }
+instance instOrderedCommMonoid [OrderedCommMonoid β] : OrderedCommMonoid (Germ l β) where
+  mul_le_mul_left f g := inductionOn₂ f g fun _f _g H h ↦ inductionOn h fun _h ↦ H.mono
+    fun _x H ↦ mul_le_mul_left' H _
 
 @[to_additive]
-instance orderedCancelCommMonoid [OrderedCancelCommMonoid β] :
-    OrderedCancelCommMonoid (Germ l β) :=
-  { Germ.orderedCommMonoid with
-    le_of_mul_le_mul_left := fun f g h =>
-      inductionOn₃ f g h fun _f _g _h H => H.mono fun _x => le_of_mul_le_mul_left' }
+instance instOrderedCancelCommMonoid [OrderedCancelCommMonoid β] :
+    OrderedCancelCommMonoid (Germ l β) where
+  le_of_mul_le_mul_left f g h := inductionOn₃ f g h fun _f _g _h H ↦ H.mono
+    fun _x ↦ le_of_mul_le_mul_left'
 
 @[to_additive]
-instance orderedCommGroup [OrderedCommGroup β] : OrderedCommGroup (Germ l β) :=
-  { Germ.orderedCancelCommMonoid, Germ.commGroup with }
+instance instOrderedCommGroup [OrderedCommGroup β] : OrderedCommGroup (Germ l β) where
+  __ := instOrderedCancelCommMonoid
+  __ := instCommGroup
 
 @[to_additive]
-instance existsMulOfLE [Mul β] [LE β] [ExistsMulOfLE β] : ExistsMulOfLE (Germ l β) where
+instance instExistsMulOfLE [Mul β] [LE β] [ExistsMulOfLE β] : ExistsMulOfLE (Germ l β) where
   exists_mul_of_le {x y} := inductionOn₂ x y fun f g (h : f ≤ᶠ[l] g) ↦ by
     classical
     choose c hc using fun x (hx : f x ≤ g x) ↦ exists_mul_of_le hx
@@ -883,34 +858,33 @@ instance existsMulOfLE [Mul β] [LE β] [ExistsMulOfLE β] : ExistsMulOfLE (Germ
     rw [dif_pos hx, hc]
 
 @[to_additive]
-instance CanonicallyOrderedCommMonoid [CanonicallyOrderedCommMonoid β] :
-    CanonicallyOrderedCommMonoid (Germ l β) :=
-  { orderedCommMonoid, orderBot, existsMulOfLE with
-    le_self_mul := fun x y ↦ inductionOn₂ x y fun _ _ ↦ eventually_of_forall fun _ ↦ le_self_mul }
-
-instance orderedSemiring [OrderedSemiring β] : OrderedSemiring (Germ l β) :=
-  { Germ.semiring,
-    Germ.orderedAddCommMonoid with
-    zero_le_one := const_le zero_le_one
-    mul_le_mul_of_nonneg_left := fun x y z =>
-      inductionOn₃ x y z fun _f _g _h hfg hh =>
-          hh.mp <| hfg.mono fun _a => mul_le_mul_of_nonneg_left
-    mul_le_mul_of_nonneg_right := fun x y z =>
-      inductionOn₃ x y z fun _f _g _h hfg hh =>
-          hh.mp <| hfg.mono fun _a => mul_le_mul_of_nonneg_right }
-
-instance orderedCommSemiring [OrderedCommSemiring β] : OrderedCommSemiring (Germ l β) :=
-  { Germ.orderedSemiring, Germ.commSemiring with }
-
-instance orderedRing [OrderedRing β] : OrderedRing (Germ l β) :=
-  { Germ.ring,
-    Germ.orderedAddCommGroup with
-    zero_le_one := const_le zero_le_one
-    mul_nonneg := fun x y =>
-      inductionOn₂ x y fun _f _g hf hg => hg.mp <| hf.mono fun _a => mul_nonneg }
-
-instance orderedCommRing [OrderedCommRing β] : OrderedCommRing (Germ l β) :=
-  { Germ.orderedRing, Germ.orderedCommSemiring with }
+instance instCanonicallyOrderedCommMonoid [CanonicallyOrderedCommMonoid β] :
+    CanonicallyOrderedCommMonoid (Germ l β) where
+  __ := instExistsMulOfLE
+  le_self_mul x y := inductionOn₂ x y fun _ _ ↦ eventually_of_forall fun _ ↦ le_self_mul
+
+instance instOrderedSemiring [OrderedSemiring β] : OrderedSemiring (Germ l β) where
+  __ := instSemiring
+  __ := instOrderedAddCommMonoid
+  zero_le_one := const_le zero_le_one
+  mul_le_mul_of_nonneg_left x y z := inductionOn₃ x y z fun _f _g _h hfg hh ↦ hh.mp <| hfg.mono
+    fun _a ↦ mul_le_mul_of_nonneg_left
+  mul_le_mul_of_nonneg_right x y z := inductionOn₃ x y z fun _f _g _h hfg hh ↦ hh.mp <| hfg.mono
+    fun _a ↦ mul_le_mul_of_nonneg_right
+
+instance instOrderedCommSemiring [OrderedCommSemiring β] : OrderedCommSemiring (Germ l β) where
+  __ := instOrderedSemiring
+  __ := instCommSemiring
+
+instance instOrderedRing [OrderedRing β] : OrderedRing (Germ l β) where
+  __ := instRing
+  __ := instOrderedAddCommGroup
+  __ := instOrderedSemiring
+  mul_nonneg x y := inductionOn₂ x y fun _f _g hf hg ↦ hg.mp <| hf.mono fun _a ↦ mul_nonneg
+
+instance instOrderedCommRing [OrderedCommRing β] : OrderedCommRing (Germ l β) where
+  __ := instOrderedRing
+  __ := instOrderedCommSemiring
 
 end Germ
 

This is less exhaustive than its sibling #11486 because edge cases are harder to classify. No fundamental difficulty, just me being a bit fast and lazy.

Reduce the diff of #11203

@@ -485,7 +485,7 @@ instance natCast [NatCast M] : NatCast (Germ l M) where
   natCast n := (n : α → M)
 
 @[simp]
-theorem coe_nat [NatCast M] (n : ℕ) : ((fun _ ↦ n : α → M) : Germ l M) = n := rfl
+theorem natCast_def [NatCast M] (n : ℕ) : ((fun _ ↦ n : α → M) : Germ l M) = n := rfl
 
 @[simp, norm_cast]
 theorem const_nat [NatCast M] (n : ℕ) : ((n : M) : Germ l M) = n := rfl
@@ -506,7 +506,11 @@ instance intCast [IntCast M] : IntCast (Germ l M) where
   intCast n := (n : α → M)
 
 @[simp]
-theorem coe_int [IntCast M] (n : ℤ) : ((fun _ ↦ n : α → M) : Germ l M) = n := rfl
+theorem intCast_def [IntCast M] (n : ℤ) : ((fun _ ↦ n : α → M) : Germ l M) = n := rfl
+
+-- 2024-04-05
+@[deprecated] alias coe_nat := natCast_def
+@[deprecated] alias coe_int := intCast_def
 
 instance addMonoidWithOne [AddMonoidWithOne M] : AddMonoidWithOne (Germ l M) :=
   { natCast, addMonoid, one with

Fixes #11441.

@@ -688,71 +688,57 @@ theorem coe_smul' [SMul M β] (c : α → M) (f : α → β) : ↑(c • f) = (c
 
 @[to_additive]
 instance mulAction [Monoid M] [MulAction M β] : MulAction M (Germ l β) where
-  -- Porting note (#11441): `rfl` required.
   one_smul f :=
     inductionOn f fun f => by
       norm_cast
-      simp only [one_smul]
-      rfl
+      simp [one_smul]
   mul_smul c₁ c₂ f :=
     inductionOn f fun f => by
       norm_cast
-      simp only [mul_smul]
-      rfl
+      simp [mul_smul]
 
 @[to_additive]
 instance mulAction' [Monoid M] [MulAction M β] : MulAction (Germ l M) (Germ l β) where
-  -- Porting note (#11441): `rfl` required.
   one_smul f := inductionOn f fun f => by simp only [← coe_one, ← coe_smul', one_smul]
   mul_smul c₁ c₂ f :=
     inductionOn₃ c₁ c₂ f fun c₁ c₂ f => by
       norm_cast
-      simp only [mul_smul]
-      rfl
+      simp [mul_smul]
 #align filter.germ.mul_action' Filter.Germ.mulAction'
 #align filter.germ.add_action' Filter.Germ.addAction'
 
 instance distribMulAction [Monoid M] [AddMonoid N] [DistribMulAction M N] :
     DistribMulAction M (Germ l N) where
-  -- Porting note (#11441): `rfl` required.
   smul_add c f g :=
     inductionOn₂ f g fun f g => by
       norm_cast
-      simp only [smul_add]
-      rfl
+      simp [smul_add]
   smul_zero c := by simp only [← coe_zero, ← coe_smul, smul_zero]
 
 instance distribMulAction' [Monoid M] [AddMonoid N] [DistribMulAction M N] :
     DistribMulAction (Germ l M) (Germ l N) where
-  -- Porting note (#11441): `rfl` required.
   smul_add c f g :=
     inductionOn₃ c f g fun c f g => by
       norm_cast
-      simp only [smul_add]
-      rfl
+      simp [smul_add]
   smul_zero c := inductionOn c fun c => by simp only [← coe_zero, ← coe_smul', smul_zero]
 #align filter.germ.distrib_mul_action' Filter.Germ.distribMulAction'
 
 instance module [Semiring R] [AddCommMonoid M] [Module R M] : Module R (Germ l M) where
-  -- Porting note (#11441): `rfl` required.
   add_smul c₁ c₂ f :=
     inductionOn f fun f => by
       norm_cast
-      simp only [add_smul]
-      rfl
+      simp [add_smul]
   zero_smul f :=
     inductionOn f fun f => by
       norm_cast
-      simp only [zero_smul, coe_zero]
-      rfl
+      simp [zero_smul, coe_zero]
 
 instance module' [Semiring R] [AddCommMonoid M] [Module R M] : Module (Germ l R) (Germ l M) where
-  -- Porting note (#11441): `rfl` required.
   add_smul c₁ c₂ f :=
     inductionOn₃ c₁ c₂ f fun c₁ c₂ f => by
       norm_cast
-      simp only [add_smul]
-      rfl
+      simp [add_smul]
   zero_smul f := inductionOn f fun f => by simp only [← coe_zero, ← coe_smul', zero_smul]
 #align filter.germ.module' Filter.Germ.module'
 

Classifies by adding issue number #11441 to porting notes claiming:

rfl required.

@@ -688,7 +688,7 @@ theorem coe_smul' [SMul M β] (c : α → M) (f : α → β) : ↑(c • f) = (c
 
 @[to_additive]
 instance mulAction [Monoid M] [MulAction M β] : MulAction M (Germ l β) where
-  -- Porting note: `rfl` required.
+  -- Porting note (#11441): `rfl` required.
   one_smul f :=
     inductionOn f fun f => by
       norm_cast
@@ -702,7 +702,7 @@ instance mulAction [Monoid M] [MulAction M β] : MulAction M (Germ l β) where
 
 @[to_additive]
 instance mulAction' [Monoid M] [MulAction M β] : MulAction (Germ l M) (Germ l β) where
-  -- Porting note: `rfl` required.
+  -- Porting note (#11441): `rfl` required.
   one_smul f := inductionOn f fun f => by simp only [← coe_one, ← coe_smul', one_smul]
   mul_smul c₁ c₂ f :=
     inductionOn₃ c₁ c₂ f fun c₁ c₂ f => by
@@ -714,7 +714,7 @@ instance mulAction' [Monoid M] [MulAction M β] : MulAction (Germ l M) (Germ l 
 
 instance distribMulAction [Monoid M] [AddMonoid N] [DistribMulAction M N] :
     DistribMulAction M (Germ l N) where
-  -- Porting note: `rfl` required.
+  -- Porting note (#11441): `rfl` required.
   smul_add c f g :=
     inductionOn₂ f g fun f g => by
       norm_cast
@@ -724,7 +724,7 @@ instance distribMulAction [Monoid M] [AddMonoid N] [DistribMulAction M N] :
 
 instance distribMulAction' [Monoid M] [AddMonoid N] [DistribMulAction M N] :
     DistribMulAction (Germ l M) (Germ l N) where
-  -- Porting note: `rfl` required.
+  -- Porting note (#11441): `rfl` required.
   smul_add c f g :=
     inductionOn₃ c f g fun c f g => by
       norm_cast
@@ -734,7 +734,7 @@ instance distribMulAction' [Monoid M] [AddMonoid N] [DistribMulAction M N] :
 #align filter.germ.distrib_mul_action' Filter.Germ.distribMulAction'
 
 instance module [Semiring R] [AddCommMonoid M] [Module R M] : Module R (Germ l M) where
-  -- Porting note: `rfl` required.
+  -- Porting note (#11441): `rfl` required.
   add_smul c₁ c₂ f :=
     inductionOn f fun f => by
       norm_cast
@@ -747,7 +747,7 @@ instance module [Semiring R] [AddCommMonoid M] [Module R M] : Module R (Germ l M
       rfl
 
 instance module' [Semiring R] [AddCommMonoid M] [Module R M] : Module (Germ l R) (Germ l M) where
-  -- Porting note: `rfl` required.
+  -- Porting note (#11441): `rfl` required.
   add_smul c₁ c₂ f :=
     inductionOn₃ c₁ c₂ f fun c₁ c₂ f => by
       norm_cast

Classifies by adding issue number #10959 porting notes claiming anything semantically equivalent to:

• "simp cannot prove this"
• "simp used to be able to close this goal"
• "simp can't handle this"
• "simp used to work here"

@@ -267,7 +267,7 @@ theorem coe_compTendsto (f : α → β) {lc : Filter γ} {g : γ → α} (hg : T
   rfl
 #align filter.germ.coe_comp_tendsto Filter.Germ.coe_compTendsto
 
-@[simp, nolint simpNF] -- Porting note: simp cannot prove this
+@[simp, nolint simpNF] -- Porting note (#10959): simp cannot prove this
 theorem compTendsto'_coe (f : Germ l β) {lc : Filter γ} {g : γ → α} (hg : Tendsto g lc l) :
     f.compTendsto' _ hg.germ_tendsto = f.compTendsto g hg :=
   rfl

From sphere-eversion; I'm just upstreaming it.

Co-authored by: @PatrickMassot (original author)

@@ -64,11 +64,6 @@ theorem const_eventuallyEq [NeBot l] {a b : β} : ((fun _ => a) =ᶠ[l] fun _ =>
   @const_eventuallyEq' _ _ _ _ a b
 #align filter.const_eventually_eq Filter.const_eventuallyEq
 
-theorem EventuallyEq.comp_tendsto {f' : α → β} (H : f =ᶠ[l] f') {g : γ → α} {lc : Filter γ}
-    (hg : Tendsto g lc l) : f ∘ g =ᶠ[lc] f' ∘ g :=
-  hg.eventually H
-#align filter.eventually_eq.comp_tendsto Filter.EventuallyEq.comp_tendsto
-
 /-- Setoid used to define the space of germs. -/
 def germSetoid (l : Filter α) (β : Type*) : Setoid (α → β) where
   r := EventuallyEq l
@@ -123,6 +118,26 @@ def const {l : Filter α} (b : β) : (Germ l β) := ofFun fun _ => b
 instance coeTC : CoeTC β (Germ l β) :=
   ⟨const⟩
 
+/-- A germ `P` of functions `α → β` is constant w.r.t. `l`. -/
+def IsConstant {l : Filter α} (P : Germ l β) : Prop :=
+  P.liftOn (fun f ↦ ∃ b : β, f =ᶠ[l] (fun _ ↦ b)) <| by
+    suffices ∀ f g : α → β, ∀ b : β, f =ᶠ[l] g → (f =ᶠ[l] fun _ ↦ b) → (g =ᶠ[l] fun _ ↦ b) from
+      fun f g h ↦ propext ⟨fun ⟨b, hb⟩ ↦ ⟨b, this f g b h hb⟩, fun ⟨b, hb⟩ ↦ ⟨b, h.trans hb⟩⟩
+    exact fun f g b hfg hf ↦ (hfg.symm).trans hf
+
+theorem isConstant_coe {l : Filter α} {b} (h : ∀ x', f x' = b) : (↑f : Germ l β).IsConstant :=
+  ⟨b, eventually_of_forall (fun x ↦ h x)⟩
+
+@[simp]
+theorem isConstant_coe_const {l : Filter α} {b : β} : (fun _ : α ↦ b : Germ l β).IsConstant := by
+  use b
+
+/-- If `f : α → β` is constant w.r.t. `l` and `g : β → γ`, then `g ∘ f : α → γ` also is. -/
+lemma isConstant_comp {l : Filter α} {f : α → β} {g : β → γ}
+    (h : (f : Germ l β).IsConstant) : ((g ∘ f) : Germ l γ).IsConstant := by
+  obtain ⟨b, hb⟩ := h
+  exact ⟨g b, hb.fun_comp g⟩
+
 @[simp]
 theorem quot_mk_eq_coe (l : Filter α) (f : α → β) : Quot.mk _ f = (f : Germ l β) :=
   rfl
@@ -257,6 +272,24 @@ theorem compTendsto'_coe (f : Germ l β) {lc : Filter γ} {g : γ → α} (hg :
     f.compTendsto' _ hg.germ_tendsto = f.compTendsto g hg :=
   rfl
 #align filter.germ.comp_tendsto'_coe Filter.Germ.compTendsto'_coe
+
+theorem Filter.Tendsto.congr_germ {f g : β → γ} {l : Filter α} {l' : Filter β} (h : f =ᶠ[l'] g)
+    {φ : α → β} (hφ : Tendsto φ l l') : (f ∘ φ : Germ l γ) = g ∘ φ :=
+  EventuallyEq.germ_eq (h.comp_tendsto hφ)
+
+lemma isConstant_comp_tendsto {lc : Filter γ} {g : γ → α}
+    (hf : (f : Germ l β).IsConstant) (hg : Tendsto g lc l) : IsConstant (f ∘ g : Germ lc β) := by
+  rcases hf with ⟨b, hb⟩
+  exact ⟨b, hb.comp_tendsto hg⟩
+
+/-- If a germ `f : Germ l β` is constant, where `l : Filter α`,
+and a function `g : γ → α` tends to `l` along `lc : Filter γ`,
+the germ of the composition `f ∘ g` is also constant. -/
+lemma isConstant_compTendsto {f : Germ l β} {lc : Filter γ} {g : γ → α}
+    (hf : f.IsConstant) (hg : Tendsto g lc l) : (f.compTendsto g hg).IsConstant := by
+  rcases Quotient.exists_rep f with ⟨f, rfl⟩
+  exact isConstant_comp_tendsto hf hg
+
 @[simp, norm_cast]
 theorem const_inj [NeBot l] {a b : β} : (↑a : Germ l β) = ↑b ↔ a = b :=
   coe_eq.trans const_eventuallyEq

Subset of #9319

@@ -532,11 +532,11 @@ instance divInvMonoid [DivInvMonoid G] : DivInvMonoid (Germ l G) :=
   { monoid, inv, div with
     zpow := fun z f => f ^ z
     zpow_zero' := Quotient.ind' fun _ => congrArg ofFun <|
-      funext <| fun _ => DivInvMonoid.zpow_zero' _
+      funext fun _ => DivInvMonoid.zpow_zero' _
     zpow_succ' := fun _ => Quotient.ind' fun _ => congrArg ofFun <|
-      funext <| fun _ => DivInvMonoid.zpow_succ' ..
+      funext fun _ => DivInvMonoid.zpow_succ' ..
     zpow_neg' := fun _ => Quotient.ind' fun _ => congrArg ofFun <|
-      funext <| fun _ => DivInvMonoid.zpow_neg' ..
+      funext fun _ => DivInvMonoid.zpow_neg' ..
     div_eq_mul_inv := Quotient.ind₂' fun _ _ => congrArg ofFun <|
       div_eq_mul_inv .. }
 
@@ -855,7 +855,7 @@ instance existsMulOfLE [Mul β] [LE β] [ExistsMulOfLE β] : ExistsMulOfLE (Germ
   exists_mul_of_le {x y} := inductionOn₂ x y fun f g (h : f ≤ᶠ[l] g) ↦ by
     classical
     choose c hc using fun x (hx : f x ≤ g x) ↦ exists_mul_of_le hx
-    refine ⟨ofFun <| fun x ↦ if hx : f x ≤ g x then c x hx else f x, coe_eq.2 ?_⟩
+    refine ⟨ofFun fun x ↦ if hx : f x ≤ g x then c x hx else f x, coe_eq.2 ?_⟩
     filter_upwards [h] with x hx
     rw [dif_pos hx, hc]
 

I used the regex \(\(· (.) ·\) (.)\), replacing with ($2 $1 ·).

@@ -182,7 +182,7 @@ alias ⟨_, _root_.Filter.EventuallyEq.germ_eq⟩ := coe_eq
 
 /-- Lift a function `β → γ` to a function `Germ l β → Germ l γ`. -/
 def map (op : β → γ) : Germ l β → Germ l γ :=
-  map' ((· ∘ ·) op) fun _ _ H => H.mono fun _ H => congr_arg op H
+  map' (op ∘ ·) fun _ _ H => H.mono fun _ H => congr_arg op H
 #align filter.germ.map Filter.Germ.map
 
 @[simp]

Co-authored-by: timotree3 <timorcb@gmail.com>

Co-authored-by: timotree3 <timorcb@gmail.com>

@@ -457,14 +457,16 @@ theorem coe_nat [NatCast M] (n : ℕ) : ((fun _ ↦ n : α → M) : Germ l M) =
 @[simp, norm_cast]
 theorem const_nat [NatCast M] (n : ℕ) : ((n : M) : Germ l M) = n := rfl
 
+-- See note [no_index around OfNat.ofNat]
 @[simp, norm_cast]
 theorem coe_ofNat [NatCast M] (n : ℕ) [n.AtLeastTwo] :
-    ((OfNat.ofNat n : α → M) : Germ l M) = OfNat.ofNat n :=
+    ((no_index (OfNat.ofNat n : α → M)) : Germ l M) = OfNat.ofNat n :=
   rfl
 
+-- See note [no_index around OfNat.ofNat]
 @[simp, norm_cast]
 theorem const_ofNat [NatCast M] (n : ℕ) [n.AtLeastTwo] :
-    ((OfNat.ofNat n : M) : Germ l M) = OfNat.ofNat n :=
+    ((no_index (OfNat.ofNat n : M)) : Germ l M) = OfNat.ofNat n :=
   rfl
 
 instance intCast [IntCast M] : IntCast (Germ l M) where

This is not exhaustive

@@ -364,19 +364,28 @@ instance semigroup [Semigroup M] : Semigroup (Germ l M) :=
 instance commSemigroup [CommSemigroup M] : CommSemigroup (Germ l M) :=
   { mul_comm := Quotient.ind₂' fun _ _ => congrArg ofFun <| mul_comm .. }
 
+@[to_additive]
+instance instIsLeftCancelMul [Mul M] [IsLeftCancelMul M] : IsLeftCancelMul (Germ l M) where
+  mul_left_cancel f₁ f₂ f₃ :=
+    inductionOn₃ f₁ f₂ f₃ fun _f₁ _f₂ _f₃ H =>
+      coe_eq.2 ((coe_eq.1 H).mono fun _x => mul_left_cancel)
+
+@[to_additive]
+instance instIsRightCancelMul [Mul M] [IsRightCancelMul M] : IsRightCancelMul (Germ l M) where
+  mul_right_cancel f₁ f₂ f₃ :=
+    inductionOn₃ f₁ f₂ f₃ fun _f₁ _f₂ _f₃ H =>
+      coe_eq.2 <| (coe_eq.1 H).mono fun _x => mul_right_cancel
+
+@[to_additive]
+instance instIsCancelMul [Mul M] [IsCancelMul M] : IsCancelMul (Germ l M) where
+
 @[to_additive]
 instance leftCancelSemigroup [LeftCancelSemigroup M] : LeftCancelSemigroup (Germ l M) :=
-  { Germ.semigroup with
-    mul_left_cancel := fun f₁ f₂ f₃ =>
-      inductionOn₃ f₁ f₂ f₃ fun _f₁ _f₂ _f₃ H =>
-        coe_eq.2 ((coe_eq.1 H).mono fun _x => mul_left_cancel) }
+  { Germ.semigroup with mul_left_cancel := fun _ _ _ => mul_left_cancel }
 
 @[to_additive]
 instance rightCancelSemigroup [RightCancelSemigroup M] : RightCancelSemigroup (Germ l M) :=
-  { Germ.semigroup with
-    mul_right_cancel := fun f₁ f₂ f₃ =>
-      inductionOn₃ f₁ f₂ f₃ fun _f₁ _f₂ _f₃ H =>
-        coe_eq.2 <| (coe_eq.1 H).mono fun _x => mul_right_cancel }
+  { Germ.semigroup with mul_right_cancel := fun _ _ _ => mul_right_cancel }
 
 @[to_additive]
 instance mulOneClass [MulOneClass M] : MulOneClass (Germ l M) :=

Co-authored-by: Moritz Firsching <firsching@google.com>

@@ -829,7 +829,7 @@ instance orderedCommMonoid [OrderedCommMonoid β] : OrderedCommMonoid (Germ l β
         inductionOn h fun _h => H.mono fun _x H => mul_le_mul_left' H _ }
 
 @[to_additive]
-instance orderedCancelCommMonoid [OrderedCancelCommMonoid β]  :
+instance orderedCancelCommMonoid [OrderedCancelCommMonoid β] :
     OrderedCancelCommMonoid (Germ l β) :=
   { Germ.orderedCommMonoid with
     le_of_mul_le_mul_left := fun f g h =>

We replace uses of Function.Surjective.x with terms constructed using direct inheritance from parents.

@@ -357,11 +357,12 @@ theorem coe_one [One M] : ↑(1 : α → M) = (1 : Germ l M) :=
 
 @[to_additive]
 instance semigroup [Semigroup M] : Semigroup (Germ l M) :=
-  Function.Surjective.semigroup ofFun (surjective_quot_mk _) fun a b => coe_mul a b
+  { mul_assoc := fun a b c => Quotient.inductionOn₃' a b c
+      fun _ _ _ => congrArg ofFun <| mul_assoc .. }
 
 @[to_additive]
 instance commSemigroup [CommSemigroup M] : CommSemigroup (Germ l M) :=
-  Function.Surjective.commSemigroup ofFun (surjective_quot_mk _) fun a b => coe_mul a b
+  { mul_comm := Quotient.ind₂' fun _ _ => congrArg ofFun <| mul_comm .. }
 
 @[to_additive]
 instance leftCancelSemigroup [LeftCancelSemigroup M] : LeftCancelSemigroup (Germ l M) :=
@@ -379,7 +380,8 @@ instance rightCancelSemigroup [RightCancelSemigroup M] : RightCancelSemigroup (G
 
 @[to_additive]
 instance mulOneClass [MulOneClass M] : MulOneClass (Germ l M) :=
-  Function.Surjective.mulOneClass ofFun (surjective_quot_mk _) rfl fun _ _ ↦ rfl
+  { one_mul := Quotient.ind' fun _ => congrArg ofFun <| one_mul _
+    mul_one := Quotient.ind' fun _ => congrArg ofFun <| mul_one _ }
 
 @[to_additive]
 instance smul [SMul M G] : SMul M (Germ l G) :=
@@ -411,9 +413,14 @@ theorem const_pow [Pow G M] (a : G) (n : M) : (↑(a ^ n) : Germ l G) = (↑a :
   rfl
 #align filter.germ.const_pow Filter.Germ.const_pow
 
+-- TODO: #7432
 @[to_additive]
 instance monoid [Monoid M] : Monoid (Germ l M) :=
-  Function.Surjective.monoid ofFun (surjective_quot_mk _) rfl (fun _ _ => rfl) fun _ _ => rfl
+  { Function.Surjective.monoid ofFun (surjective_quot_mk _) (by rfl)
+      (fun _ _ => by rfl) fun _ _ => by rfl with
+    toSemigroup := semigroup
+    toOne := one
+    npow := fun n a => a ^ n }
 
 /-- Coercion from functions to germs as a monoid homomorphism. -/
 @[to_additive "Coercion from functions to germs as an additive monoid homomorphism."]
@@ -430,9 +437,9 @@ theorem coe_coeMulHom [Monoid M] : (coeMulHom l : (α → M) → Germ l M) = ofF
 
 @[to_additive]
 instance commMonoid [CommMonoid M] : CommMonoid (Germ l M) :=
-  Function.Surjective.commMonoid ofFun (surjective_quot_mk _) rfl (fun _ _ => rfl) fun _ _ => rfl
+  { mul_comm := mul_comm }
 
-instance [NatCast M] : NatCast (Germ l M) where
+instance natCast [NatCast M] : NatCast (Germ l M) where
   natCast n := (n : α → M)
 
 @[simp]
@@ -451,20 +458,19 @@ theorem const_ofNat [NatCast M] (n : ℕ) [n.AtLeastTwo] :
     ((OfNat.ofNat n : M) : Germ l M) = OfNat.ofNat n :=
   rfl
 
-instance [IntCast M] : IntCast (Germ l M) where
+instance intCast [IntCast M] : IntCast (Germ l M) where
   intCast n := (n : α → M)
 
 @[simp]
 theorem coe_int [IntCast M] (n : ℤ) : ((fun _ ↦ n : α → M) : Germ l M) = n := rfl
 
 instance addMonoidWithOne [AddMonoidWithOne M] : AddMonoidWithOne (Germ l M) :=
-  Function.Surjective.addMonoidWithOne ofFun (surjective_quot_mk _) rfl rfl (fun _ _ ↦ rfl)
-    (fun _ _ ↦ rfl) fun _ ↦ rfl
-
-instance addCommMonoidWithOne [AddCommMonoidWithOne M] : AddCommMonoidWithOne (Germ l M) where
-  toAddMonoidWithOne := addMonoidWithOne
-  __ := addCommSemigroup
+  { natCast, addMonoid, one with
+    natCast_zero := congrArg ofFun <| by simp; rfl
+    natCast_succ := fun _ => congrArg ofFun <| by simp [Function.comp]; rfl }
 
+instance addCommMonoidWithOne [AddCommMonoidWithOne M] : AddCommMonoidWithOne (Germ l M) :=
+  { add_comm := add_comm }
 
 @[to_additive]
 instance inv [Inv G] : Inv (Germ l G) :=
@@ -500,10 +506,11 @@ theorem const_div [Div M] (a b : M) : (↑(a / b) : Germ l M) = ↑a / ↑b :=
 
 @[to_additive]
 instance involutiveInv [InvolutiveInv G] : InvolutiveInv (Germ l G) :=
-  Function.Surjective.involutiveInv ofFun (surjective_quot_mk _) fun _ ↦ rfl
+  { inv_inv := Quotient.ind' fun _ => congrArg ofFun<| inv_inv _ }
 
 instance hasDistribNeg [Mul G] [HasDistribNeg G] : HasDistribNeg (Germ l G) :=
-  Function.Surjective.hasDistribNeg ofFun (surjective_quot_mk _) (fun _ ↦ rfl) fun _ _ ↦ rfl
+  { neg_mul := Quotient.ind₂' fun _ _ => congrArg ofFun <| neg_mul ..
+    mul_neg := Quotient.ind₂' fun _ _ => congrArg ofFun <| mul_neg .. }
 
 @[to_additive]
 instance invOneClass [InvOneClass G] : InvOneClass (Germ l G) :=
@@ -511,8 +518,16 @@ instance invOneClass [InvOneClass G] : InvOneClass (Germ l G) :=
 
 @[to_additive subNegMonoid]
 instance divInvMonoid [DivInvMonoid G] : DivInvMonoid (Germ l G) :=
-  Function.Surjective.divInvMonoid ofFun (surjective_quot_mk _) rfl (fun _ _ => rfl) (fun _ => rfl)
-    (fun _ _ => rfl) (fun _ _ => rfl) fun _ _ => rfl
+  { monoid, inv, div with
+    zpow := fun z f => f ^ z
+    zpow_zero' := Quotient.ind' fun _ => congrArg ofFun <|
+      funext <| fun _ => DivInvMonoid.zpow_zero' _
+    zpow_succ' := fun _ => Quotient.ind' fun _ => congrArg ofFun <|
+      funext <| fun _ => DivInvMonoid.zpow_succ' ..
+    zpow_neg' := fun _ => Quotient.ind' fun _ => congrArg ofFun <|
+      funext <| fun _ => DivInvMonoid.zpow_neg' ..
+    div_eq_mul_inv := Quotient.ind₂' fun _ _ => congrArg ofFun <|
+      div_eq_mul_inv .. }
 
 @[to_additive]
 instance divisionMonoid [DivisionMonoid G] : DivisionMonoid (Germ l G) where
@@ -521,16 +536,18 @@ instance divisionMonoid [DivisionMonoid G] : DivisionMonoid (Germ l G) where
   inv_eq_of_mul x y := inductionOn₂ x y fun _ _ h ↦ coe_eq.2 <| (coe_eq.1 h).mono fun _ ↦
     DivisionMonoid.inv_eq_of_mul _ _
 
-
 @[to_additive]
 instance group [Group G] : Group (Germ l G) :=
-  Function.Surjective.group ofFun (surjective_quot_mk _) rfl (fun _ _ ↦ rfl) (fun _ ↦ rfl)
-    (fun _ _ ↦ rfl) (fun _ _ ↦ rfl) (fun _ _ ↦ rfl)
+  { mul_left_inv := Quotient.ind' fun _ => congrArg ofFun <| mul_left_inv _ }
 
 @[to_additive]
 instance commGroup [CommGroup G] : CommGroup (Germ l G) :=
-  Function.Surjective.commGroup ofFun (surjective_quot_mk _) rfl (fun _ _ ↦ rfl) (fun _ ↦ rfl)
-    (fun _ _ ↦ rfl) (fun _ _ ↦ rfl) (fun _ _ ↦ rfl)
+  { mul_comm := mul_comm }
+
+instance addGroupWithOne [AddGroupWithOne G] : AddGroupWithOne (Germ l G) :=
+  { intCast, addMonoidWithOne, addGroup with
+    intCast_ofNat := fun _ => congrArg ofFun <| by simp
+    intCast_negSucc := fun _ => congrArg ofFun <| by simp [Function.comp]; rfl }
 
 end Monoid
 
@@ -544,70 +561,58 @@ instance nontrivial [Nontrivial R] [NeBot l] : Nontrivial (Germ l R) :=
 #align filter.germ.nontrivial Filter.Germ.nontrivial
 
 instance mulZeroClass [MulZeroClass R] : MulZeroClass (Germ l R) :=
-  Function.Surjective.mulZeroClass ofFun (surjective_quot_mk _) rfl fun _ _ ↦ rfl
+  { zero_mul := Quotient.ind' fun _ => congrArg ofFun <| zero_mul _
+    mul_zero := Quotient.ind' fun _ => congrArg ofFun <| mul_zero _ }
 
 instance mulZeroOneClass [MulZeroOneClass R] : MulZeroOneClass (Germ l R) :=
-  Function.Surjective.mulZeroOneClass ofFun (surjective_quot_mk _) rfl rfl fun _ _ ↦ rfl
+  { mulZeroClass, mulOneClass with }
 
 instance monoidWithZero [MonoidWithZero R] : MonoidWithZero (Germ l R) :=
-  Function.Surjective.monoidWithZero ofFun (surjective_quot_mk _) rfl rfl (fun _ _ ↦ rfl)
-    fun _ _ ↦ rfl
+  { monoid, mulZeroClass with }
 
 instance distrib [Distrib R] : Distrib (Germ l R) :=
-  Function.Surjective.distrib ofFun (surjective_quot_mk _) (fun _ _ ↦ rfl) fun _ _ ↦ rfl
+  { left_distrib := fun a b c => Quotient.inductionOn₃' a b c
+      fun _ _ _ => congrArg ofFun <| left_distrib ..
+    right_distrib := fun a b c => Quotient.inductionOn₃' a b c
+      fun _ _ _ => congrArg ofFun <| right_distrib .. }
 
 instance nonUnitalNonAssocSemiring [NonUnitalNonAssocSemiring R] :
     NonUnitalNonAssocSemiring (Germ l R) :=
-  Function.Surjective.nonUnitalNonAssocSemiring ofFun (surjective_quot_mk _) rfl (fun _ _ ↦ rfl)
-    (fun _ _ ↦ rfl) fun _ _ ↦ rfl
+  { addCommMonoid, distrib, mulZeroClass with }
 
 instance nonUnitalSemiring [NonUnitalSemiring R] : NonUnitalSemiring (Germ l R) :=
-  Function.Surjective.nonUnitalSemiring ofFun (surjective_quot_mk _) rfl (fun _ _ ↦ rfl)
-    (fun _ _ ↦ rfl) fun _ _ ↦ rfl
+  { mul_assoc := mul_assoc }
 
 instance nonAssocSemiring [NonAssocSemiring R] : NonAssocSemiring (Germ l R) :=
-  Function.Surjective.nonAssocSemiring ofFun (surjective_quot_mk _) rfl rfl (fun _ _ ↦ rfl)
-    (fun _ _ ↦ rfl) (fun _ _ ↦ rfl) fun _ ↦ rfl
+  { nonUnitalNonAssocSemiring, mulZeroOneClass, addMonoidWithOne with }
 
 instance nonUnitalNonAssocRing [NonUnitalNonAssocRing R] :
     NonUnitalNonAssocRing (Germ l R) :=
-  Function.Surjective.nonUnitalNonAssocRing ofFun (surjective_quot_mk _) rfl (fun _ _ ↦ rfl)
-    (fun _ _ ↦ rfl) (fun _ ↦ rfl) (fun _ _ ↦ rfl) (fun _ _ ↦ rfl) (fun _ _ ↦ rfl)
+  { addCommGroup, nonUnitalNonAssocSemiring with }
 
 instance nonUnitalRing [NonUnitalRing R] : NonUnitalRing (Germ l R) :=
-  Function.Surjective.nonUnitalRing ofFun (surjective_quot_mk _) rfl (fun _ _ ↦ rfl)
-    (fun _ _ ↦ rfl) (fun _ ↦ rfl) (fun _ _ ↦ rfl) (fun _ _ ↦ rfl) (fun _ _ ↦ rfl)
+  { mul_assoc := mul_assoc }
 
 instance nonAssocRing [NonAssocRing R] : NonAssocRing (Germ l R) :=
-  Function.Surjective.nonAssocRing ofFun (surjective_quot_mk _) rfl rfl (fun _ _ ↦ rfl)
-    (fun _ _ ↦ rfl) (fun _ ↦ rfl) (fun _ _ ↦ rfl) (fun _ _ ↦ rfl) (fun _ _ ↦ rfl)
-    (fun _ ↦ rfl) fun _ ↦ rfl
+  { nonUnitalNonAssocRing, nonAssocSemiring, addGroupWithOne with }
 
 instance semiring [Semiring R] : Semiring (Germ l R) :=
-  Function.Surjective.semiring ofFun (surjective_quot_mk _) rfl rfl (fun _ _ ↦ rfl)
-    (fun _ _ ↦ rfl) (fun _ _ ↦ rfl) (fun _ _ ↦ rfl) (fun _ ↦ rfl)
+  { nonUnitalSemiring, nonAssocSemiring, monoidWithZero with }
 
 instance ring [Ring R] : Ring (Germ l R) :=
-  Function.Surjective.ring ofFun (surjective_quot_mk _) rfl rfl (fun _ _ ↦ rfl) (fun _ _ ↦ rfl)
-    (fun _ ↦ rfl) (fun _ _ ↦ rfl) (fun _ _ ↦ rfl) (fun _ _ ↦ rfl) (fun _ _ ↦ rfl) (fun _ ↦ rfl)
-    (fun _ ↦ rfl)
+  { semiring, addCommGroup, nonAssocRing with }
 
 instance nonUnitalCommSemiring [NonUnitalCommSemiring R] : NonUnitalCommSemiring (Germ l R) :=
-  Function.Surjective.nonUnitalCommSemiring ofFun (surjective_quot_mk _) rfl (fun _ _ ↦ rfl)
-    (fun _ _ ↦ rfl) (fun _ _ ↦ rfl)
+  { mul_comm := mul_comm }
 
 instance commSemiring [CommSemiring R] : CommSemiring (Germ l R) :=
-  Function.Surjective.commSemiring ofFun (surjective_quot_mk _) rfl rfl (fun _ _ ↦ rfl)
-    (fun _ _ ↦ rfl) (fun _ _ ↦ rfl) (fun _ _ ↦ rfl) (fun _ ↦ rfl)
+  { mul_comm := mul_comm }
 
 instance nonUnitalCommRing [NonUnitalCommRing R] : NonUnitalCommRing (Germ l R) :=
-    Function.Surjective.nonUnitalCommRing ofFun (surjective_quot_mk _) rfl (fun _ _ ↦ rfl)
-      (fun _ _ ↦ rfl) (fun _ ↦ rfl) (fun _ _ ↦ rfl) (fun _ _ ↦ rfl) fun _ _ ↦ rfl
+  { nonUnitalRing, commSemigroup with }
 
 instance commRing [CommRing R] : CommRing (Germ l R) :=
-  Function.Surjective.commRing ofFun (surjective_quot_mk _) rfl rfl (fun _ _ ↦ rfl) (fun _ _ ↦ rfl)
-    (fun _ ↦ rfl) (fun _ _ ↦ rfl) (fun _ _ ↦ rfl) (fun _ _ ↦ rfl) (fun _ _ ↦ rfl) (fun _ ↦ rfl)
-    (fun _ ↦ rfl)
+  { mul_comm := mul_comm }
 
 /-- Coercion `(α → R) → Germ l R` as a `RingHom`. -/
 def coeRingHom [Semiring R] (l : Filter α) : (α → R) →+* Germ l R :=

Renames:

CanonicallyOrderedMonoid -> CanonicallyOrderedCommMonoid

CanonicallyOrderedAddMonoid -> CanonicallyOrderedAddCommMonoid

CanonicallyLinearOrderedMonoid -> CanonicallyLinearOrderedCommMonoid

CanonicallyLinearOrderedAddMonoid -> CanonicallyLinearOrderedAddCommMonoid

@@ -844,8 +844,8 @@ instance existsMulOfLE [Mul β] [LE β] [ExistsMulOfLE β] : ExistsMulOfLE (Germ
     rw [dif_pos hx, hc]
 
 @[to_additive]
-instance canonicallyOrderedMonoid [CanonicallyOrderedMonoid β] :
-    CanonicallyOrderedMonoid (Germ l β) :=
+instance CanonicallyOrderedCommMonoid [CanonicallyOrderedCommMonoid β] :
+    CanonicallyOrderedCommMonoid (Germ l β) :=
   { orderedCommMonoid, orderBot, existsMulOfLE with
     le_self_mul := fun x y ↦ inductionOn₂ x y fun _ _ ↦ eventually_of_forall fun _ ↦ le_self_mul }
 

This removes redundant field values of the form add := add for smaller terms and less unfolding during unification.

A list of all files containing a structure instance of the form { a1, ... with x1 := val, ... } where some xi is a field of some aj was generated by modifying the structure instance elaboration algorithm to print such overlaps to stdout in a custom toolchain.

Using that toolchain, I went through each file on the list and attempted to remove algebraic fields that overlapped and were redundant, eg add := add and not toFun (though some other ones did creep in). If things broke (which was the case in a couple of cases), I did not push further and reverted.

It is possible that pushing harder and trying to remove all redundant overlaps will yield further improvements.

@@ -366,7 +366,6 @@ instance commSemigroup [CommSemigroup M] : CommSemigroup (Germ l M) :=
 @[to_additive]
 instance leftCancelSemigroup [LeftCancelSemigroup M] : LeftCancelSemigroup (Germ l M) :=
   { Germ.semigroup with
-    mul := (· * ·)
     mul_left_cancel := fun f₁ f₂ f₃ =>
       inductionOn₃ f₁ f₂ f₃ fun _f₁ _f₂ _f₃ H =>
         coe_eq.2 ((coe_eq.1 H).mono fun _x => mul_left_cancel) }
@@ -374,7 +373,6 @@ instance leftCancelSemigroup [LeftCancelSemigroup M] : LeftCancelSemigroup (Germ
 @[to_additive]
 instance rightCancelSemigroup [RightCancelSemigroup M] : RightCancelSemigroup (Germ l M) :=
   { Germ.semigroup with
-    mul := (· * ·)
     mul_right_cancel := fun f₁ f₂ f₃ =>
       inductionOn₃ f₁ f₂ f₃ fun _f₁ _f₂ _f₃ H =>
         coe_eq.2 <| (coe_eq.1 H).mono fun _x => mul_right_cancel }

This makes it easier to refactor the order or inheritance structure of morphisms without having to change all of the anonymous constructors.

This is far from exhaustive.

@@ -419,8 +419,8 @@ instance monoid [Monoid M] : Monoid (Germ l M) :=
 
 /-- Coercion from functions to germs as a monoid homomorphism. -/
 @[to_additive "Coercion from functions to germs as an additive monoid homomorphism."]
-def coeMulHom [Monoid M] (l : Filter α) : (α → M) →* Germ l M :=
-  ⟨⟨ofFun, rfl⟩, fun _ _ => rfl⟩
+def coeMulHom [Monoid M] (l : Filter α) : (α → M) →* Germ l M where
+  toFun := ofFun; map_one' := rfl; map_mul' _ _ := rfl
 #align filter.germ.coe_mul_hom Filter.Germ.coeMulHom
 #align filter.germ.coe_add_hom Filter.Germ.coeAddHom
 

@@ -177,7 +177,7 @@ theorem coe_eq : (f : Germ l β) = g ↔ f =ᶠ[l] g :=
   Quotient.eq''
 #align filter.germ.coe_eq Filter.Germ.coe_eq
 
-alias coe_eq ↔ _ _root_.Filter.EventuallyEq.germ_eq
+alias ⟨_, _root_.Filter.EventuallyEq.germ_eq⟩ := coe_eq
 #align filter.eventually_eq.germ_eq Filter.EventuallyEq.germ_eq
 
 /-- Lift a function `β → γ` to a function `Germ l β → Germ l γ`. -/
@@ -224,7 +224,7 @@ theorem coe_tendsto {f : α → β} {lb : Filter β} : (f : Germ l β).Tendsto l
   Iff.rfl
 #align filter.germ.coe_tendsto Filter.Germ.coe_tendsto
 
-alias coe_tendsto ↔ _ _root_.Filter.Tendsto.germ_tendsto
+alias ⟨_, _root_.Filter.Tendsto.germ_tendsto⟩ := coe_tendsto
 #align filter.tendsto.germ_tendsto Filter.Tendsto.germ_tendsto
 
 /-- Given two germs `f : Germ l β`, and `g : Germ lc α`, where `l : Filter α`, if `g` tends to `l`,

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

This has nice performance benefits.

@@ -54,7 +54,7 @@ filter, germ
 
 namespace Filter
 
-variable {α β γ δ : Type _} {l : Filter α} {f g h : α → β}
+variable {α β γ δ : Type*} {l : Filter α} {f g h : α → β}
 
 theorem const_eventuallyEq' [NeBot l] {a b : β} : (∀ᶠ _ in l, a = b) ↔ a = b :=
   eventually_const
@@ -70,19 +70,19 @@ theorem EventuallyEq.comp_tendsto {f' : α → β} (H : f =ᶠ[l] f') {g : γ 
 #align filter.eventually_eq.comp_tendsto Filter.EventuallyEq.comp_tendsto
 
 /-- Setoid used to define the space of germs. -/
-def germSetoid (l : Filter α) (β : Type _) : Setoid (α → β) where
+def germSetoid (l : Filter α) (β : Type*) : Setoid (α → β) where
   r := EventuallyEq l
   iseqv := ⟨EventuallyEq.refl _, EventuallyEq.symm, EventuallyEq.trans⟩
 #align filter.germ_setoid Filter.germSetoid
 
 /-- The space of germs of functions `α → β` at a filter `l`. -/
-def Germ (l : Filter α) (β : Type _) : Type _ :=
+def Germ (l : Filter α) (β : Type*) : Type _ :=
   Quotient (germSetoid l β)
 #align filter.germ Filter.Germ
 
 /-- Setoid used to define the filter product. This is a dependent version of
   `Filter.germSetoid`. -/
-def productSetoid (l : Filter α) (ε : α → Type _) : Setoid ((a : _) → ε a) where
+def productSetoid (l : Filter α) (ε : α → Type*) : Setoid ((a : _) → ε a) where
   r f g := ∀ᶠ a in l, f a = g a
   iseqv :=
     ⟨fun _ => eventually_of_forall fun _ => rfl, fun h => h.mono fun _ => Eq.symm,
@@ -92,13 +92,13 @@ def productSetoid (l : Filter α) (ε : α → Type _) : Setoid ((a : _) → ε
 /-- The filter product `(a : α) → ε a` at a filter `l`. This is a dependent version of
   `Filter.Germ`. -/
 -- Porting note: removed @[protected]
-def Product (l : Filter α) (ε : α → Type _) : Type _ :=
+def Product (l : Filter α) (ε : α → Type*) : Type _ :=
   Quotient (productSetoid l ε)
 #align filter.product Filter.Product
 
 namespace Product
 
-variable {ε : α → Type _}
+variable {ε : α → Type*}
 
 instance coeTC : CoeTC ((a : _) → ε a) (l.Product ε) :=
   ⟨@Quotient.mk' _ (productSetoid _ ε)⟩
@@ -161,7 +161,7 @@ def map' {lc : Filter γ} (F : (α → β) → γ → δ) (hF : (l.EventuallyEq
 
 /-- Given a germ `f : Germ l β` and a function `F : (α → β) → γ` sending eventually equal functions
 to the same value, returns the value `F` takes on functions having germ `f` at `l`. -/
-def liftOn {γ : Sort _} (f : Germ l β) (F : (α → β) → γ) (hF : (l.EventuallyEq ⇒ (· = ·)) F F) :
+def liftOn {γ : Sort*} (f : Germ l β) (F : (α → β) → γ) (hF : (l.EventuallyEq ⇒ (· = ·)) F F) :
     γ :=
   Quotient.liftOn' f F hF
 #align filter.germ.lift_on Filter.Germ.liftOn
@@ -333,7 +333,7 @@ instance inhabited [Inhabited β] : Inhabited (Germ l β) :=
 
 section Monoid
 
-variable {M : Type _} {G : Type _}
+variable {M : Type*} {G : Type*}
 
 @[to_additive]
 instance mul [Mul M] : Mul (Germ l M) :=
@@ -538,7 +538,7 @@ end Monoid
 
 section Ring
 
-variable {R : Type _}
+variable {R : Type*}
 
 instance nontrivial [Nontrivial R] [NeBot l] : Nontrivial (Germ l R) :=
   let ⟨x, y, h⟩ := exists_pair_ne R
@@ -625,7 +625,7 @@ end Ring
 
 section Module
 
-variable {M N R : Type _}
+variable {M N R : Type*}
 
 @[to_additive]
 instance instSMul' [SMul M β] : SMul (Germ l M) (Germ l β) :=

@@ -628,10 +628,10 @@ section Module
 variable {M N R : Type _}
 
 @[to_additive]
-instance hasSmul' [SMul M β] : SMul (Germ l M) (Germ l β) :=
+instance instSMul' [SMul M β] : SMul (Germ l M) (Germ l β) :=
   ⟨map₂ (· • ·)⟩
-#align filter.germ.has_smul' Filter.Germ.hasSmul'
-#align filter.germ.has_vadd' Filter.Germ.hasVadd'
+#align filter.germ.has_smul' Filter.Germ.instSMul'
+#align filter.germ.has_vadd' Filter.Germ.instVAdd'
 
 @[to_additive (attr := simp, norm_cast)]
 theorem coe_smul' [SMul M β] (c : α → M) (f : α → β) : ↑(c • f) = (c : Germ l M) • (f : Germ l β) :=
@@ -736,8 +736,7 @@ theorem const_le_iff [LE β] [NeBot l] {x y : β} : (↑x : Germ l β) ≤ ↑y
   liftRel_const_iff
 #align filter.germ.const_le_iff Filter.Germ.const_le_iff
 
-instance preorder [Preorder β] : Preorder (Germ l β)
-    where
+instance preorder [Preorder β] : Preorder (Germ l β) where
   le := (· ≤ ·)
   le_refl f := inductionOn f <| EventuallyLE.refl l
   le_trans f₁ f₂ f₃ := inductionOn₃ f₁ f₂ f₃ fun f₁ f₂ f₃ => EventuallyLE.trans

Motivated by the Sphere Eversion Project.

@@ -379,6 +379,10 @@ instance rightCancelSemigroup [RightCancelSemigroup M] : RightCancelSemigroup (G
       inductionOn₃ f₁ f₂ f₃ fun _f₁ _f₂ _f₃ H =>
         coe_eq.2 <| (coe_eq.1 H).mono fun _x => mul_right_cancel }
 
+@[to_additive]
+instance mulOneClass [MulOneClass M] : MulOneClass (Germ l M) :=
+  Function.Surjective.mulOneClass ofFun (surjective_quot_mk _) rfl fun _ _ ↦ rfl
+
 @[to_additive]
 instance smul [SMul M G] : SMul M (Germ l G) :=
   ⟨fun n => map (n • ·)⟩
@@ -409,11 +413,7 @@ theorem const_pow [Pow G M] (a : G) (n : M) : (↑(a ^ n) : Germ l G) = (↑a :
   rfl
 #align filter.germ.const_pow Filter.Germ.const_pow
 
--- Porting note: `to_additive` can't generate this (firstMultArg bug).
-instance addMonoid [AddMonoid M] : AddMonoid (Germ l M) :=
-  Function.Surjective.addMonoid ofFun (surjective_quot_mk _) rfl (fun _ _ => rfl) fun _ _ => rfl
-
-@[to_additive existing]
+@[to_additive]
 instance monoid [Monoid M] : Monoid (Germ l M) :=
   Function.Surjective.monoid ofFun (surjective_quot_mk _) rfl (fun _ _ => rfl) fun _ _ => rfl
 
@@ -432,15 +432,41 @@ theorem coe_coeMulHom [Monoid M] : (coeMulHom l : (α → M) → Germ l M) = ofF
 
 @[to_additive]
 instance commMonoid [CommMonoid M] : CommMonoid (Germ l M) :=
-  { Germ.commSemigroup, Germ.monoid with
-    mul := (· * ·)
-    one := 1 }
+  Function.Surjective.commMonoid ofFun (surjective_quot_mk _) rfl (fun _ _ => rfl) fun _ _ => rfl
+
+instance [NatCast M] : NatCast (Germ l M) where
+  natCast n := (n : α → M)
+
+@[simp]
+theorem coe_nat [NatCast M] (n : ℕ) : ((fun _ ↦ n : α → M) : Germ l M) = n := rfl
+
+@[simp, norm_cast]
+theorem const_nat [NatCast M] (n : ℕ) : ((n : M) : Germ l M) = n := rfl
+
+@[simp, norm_cast]
+theorem coe_ofNat [NatCast M] (n : ℕ) [n.AtLeastTwo] :
+    ((OfNat.ofNat n : α → M) : Germ l M) = OfNat.ofNat n :=
+  rfl
+
+@[simp, norm_cast]
+theorem const_ofNat [NatCast M] (n : ℕ) [n.AtLeastTwo] :
+    ((OfNat.ofNat n : M) : Germ l M) = OfNat.ofNat n :=
+  rfl
+
+instance [IntCast M] : IntCast (Germ l M) where
+  intCast n := (n : α → M)
+
+@[simp]
+theorem coe_int [IntCast M] (n : ℤ) : ((fun _ ↦ n : α → M) : Germ l M) = n := rfl
 
 instance addMonoidWithOne [AddMonoidWithOne M] : AddMonoidWithOne (Germ l M) :=
-  { Germ.one, Germ.addMonoid with
-    natCast := fun n => ↑(n : M)
-    natCast_zero := congr_arg ((↑) : M → Germ l M) Nat.cast_zero
-    natCast_succ := fun _ => congr_arg ((↑) : M → Germ l M) (Nat.cast_succ _) }
+  Function.Surjective.addMonoidWithOne ofFun (surjective_quot_mk _) rfl rfl (fun _ _ ↦ rfl)
+    (fun _ _ ↦ rfl) fun _ ↦ rfl
+
+instance addCommMonoidWithOne [AddCommMonoidWithOne M] : AddCommMonoidWithOne (Germ l M) where
+  toAddMonoidWithOne := addMonoidWithOne
+  __ := addCommSemigroup
+
 
 @[to_additive]
 instance inv [Inv G] : Inv (Germ l G) :=
@@ -474,31 +500,39 @@ theorem const_div [Div M] (a b : M) : (↑(a / b) : Germ l M) = ↑a / ↑b :=
 #align filter.germ.const_div Filter.Germ.const_div
 #align filter.germ.const_sub Filter.Germ.const_sub
 
--- Porting note: `to_additive` can't generate this.
-instance subNegMonoid [SubNegMonoid G] : SubNegMonoid (Germ l G) :=
-  Function.Surjective.subNegMonoid ofFun (surjective_quot_mk _) rfl (fun _ _ => rfl) (fun _ => rfl)
-    (fun _ _ => rfl) (fun _ _ => rfl) fun _ _ => rfl
+@[to_additive]
+instance involutiveInv [InvolutiveInv G] : InvolutiveInv (Germ l G) :=
+  Function.Surjective.involutiveInv ofFun (surjective_quot_mk _) fun _ ↦ rfl
+
+instance hasDistribNeg [Mul G] [HasDistribNeg G] : HasDistribNeg (Germ l G) :=
+  Function.Surjective.hasDistribNeg ofFun (surjective_quot_mk _) (fun _ ↦ rfl) fun _ _ ↦ rfl
+
+@[to_additive]
+instance invOneClass [InvOneClass G] : InvOneClass (Germ l G) :=
+  ⟨congr_arg ofFun inv_one⟩
 
-@[to_additive existing subNegMonoid]
+@[to_additive subNegMonoid]
 instance divInvMonoid [DivInvMonoid G] : DivInvMonoid (Germ l G) :=
   Function.Surjective.divInvMonoid ofFun (surjective_quot_mk _) rfl (fun _ _ => rfl) (fun _ => rfl)
     (fun _ _ => rfl) (fun _ _ => rfl) fun _ _ => rfl
 
+@[to_additive]
+instance divisionMonoid [DivisionMonoid G] : DivisionMonoid (Germ l G) where
+  inv_inv := inv_inv
+  mul_inv_rev x y := inductionOn₂ x y fun _ _ ↦ congr_arg ofFun <| mul_inv_rev _ _
+  inv_eq_of_mul x y := inductionOn₂ x y fun _ _ h ↦ coe_eq.2 <| (coe_eq.1 h).mono fun _ ↦
+    DivisionMonoid.inv_eq_of_mul _ _
+
+
 @[to_additive]
 instance group [Group G] : Group (Germ l G) :=
-  { Germ.divInvMonoid with
-    mul := (· * ·)
-    one := 1
-    mul_left_inv := by
-      rintro ⟨f⟩
-      exact congr_arg (Quot.mk _) (mul_left_inv f) }
+  Function.Surjective.group ofFun (surjective_quot_mk _) rfl (fun _ _ ↦ rfl) (fun _ ↦ rfl)
+    (fun _ _ ↦ rfl) (fun _ _ ↦ rfl) (fun _ _ ↦ rfl)
 
 @[to_additive]
 instance commGroup [CommGroup G] : CommGroup (Germ l G) :=
-  { Germ.group, Germ.commMonoid with
-    mul := (· * ·)
-    one := 1
-    inv := Inv.inv }
+  Function.Surjective.commGroup ofFun (surjective_quot_mk _) rfl (fun _ _ ↦ rfl) (fun _ ↦ rfl)
+    (fun _ _ ↦ rfl) (fun _ _ ↦ rfl) (fun _ _ ↦ rfl)
 
 end Monoid
 
@@ -511,32 +545,71 @@ instance nontrivial [Nontrivial R] [NeBot l] : Nontrivial (Germ l R) :=
   ⟨⟨↑x, ↑y, mt const_inj.1 h⟩⟩
 #align filter.germ.nontrivial Filter.Germ.nontrivial
 
-instance mulZeroClass [MulZeroClass R] : MulZeroClass (Germ l R) where
-  zero := 0
-  mul := (· * ·)
-  mul_zero f :=
-    inductionOn f fun f => by
-      norm_cast
-      rw [mul_zero]
-  zero_mul f :=
-    inductionOn f fun f => by
-      norm_cast
-      rw [zero_mul]
+instance mulZeroClass [MulZeroClass R] : MulZeroClass (Germ l R) :=
+  Function.Surjective.mulZeroClass ofFun (surjective_quot_mk _) rfl fun _ _ ↦ rfl
 
-instance distrib [Distrib R] : Distrib (Germ l R) where
-  mul := (· * ·)
-  add := (· + ·)
-  left_distrib f g h :=
-    inductionOn₃ f g h fun f g h => by
-      norm_cast
-      rw [left_distrib]
-  right_distrib f g h :=
-    inductionOn₃ f g h fun f g h => by
-      norm_cast
-      rw [right_distrib]
+instance mulZeroOneClass [MulZeroOneClass R] : MulZeroOneClass (Germ l R) :=
+  Function.Surjective.mulZeroOneClass ofFun (surjective_quot_mk _) rfl rfl fun _ _ ↦ rfl
+
+instance monoidWithZero [MonoidWithZero R] : MonoidWithZero (Germ l R) :=
+  Function.Surjective.monoidWithZero ofFun (surjective_quot_mk _) rfl rfl (fun _ _ ↦ rfl)
+    fun _ _ ↦ rfl
+
+instance distrib [Distrib R] : Distrib (Germ l R) :=
+  Function.Surjective.distrib ofFun (surjective_quot_mk _) (fun _ _ ↦ rfl) fun _ _ ↦ rfl
+
+instance nonUnitalNonAssocSemiring [NonUnitalNonAssocSemiring R] :
+    NonUnitalNonAssocSemiring (Germ l R) :=
+  Function.Surjective.nonUnitalNonAssocSemiring ofFun (surjective_quot_mk _) rfl (fun _ _ ↦ rfl)
+    (fun _ _ ↦ rfl) fun _ _ ↦ rfl
+
+instance nonUnitalSemiring [NonUnitalSemiring R] : NonUnitalSemiring (Germ l R) :=
+  Function.Surjective.nonUnitalSemiring ofFun (surjective_quot_mk _) rfl (fun _ _ ↦ rfl)
+    (fun _ _ ↦ rfl) fun _ _ ↦ rfl
+
+instance nonAssocSemiring [NonAssocSemiring R] : NonAssocSemiring (Germ l R) :=
+  Function.Surjective.nonAssocSemiring ofFun (surjective_quot_mk _) rfl rfl (fun _ _ ↦ rfl)
+    (fun _ _ ↦ rfl) (fun _ _ ↦ rfl) fun _ ↦ rfl
+
+instance nonUnitalNonAssocRing [NonUnitalNonAssocRing R] :
+    NonUnitalNonAssocRing (Germ l R) :=
+  Function.Surjective.nonUnitalNonAssocRing ofFun (surjective_quot_mk _) rfl (fun _ _ ↦ rfl)
+    (fun _ _ ↦ rfl) (fun _ ↦ rfl) (fun _ _ ↦ rfl) (fun _ _ ↦ rfl) (fun _ _ ↦ rfl)
+
+instance nonUnitalRing [NonUnitalRing R] : NonUnitalRing (Germ l R) :=
+  Function.Surjective.nonUnitalRing ofFun (surjective_quot_mk _) rfl (fun _ _ ↦ rfl)
+    (fun _ _ ↦ rfl) (fun _ ↦ rfl) (fun _ _ ↦ rfl) (fun _ _ ↦ rfl) (fun _ _ ↦ rfl)
+
+instance nonAssocRing [NonAssocRing R] : NonAssocRing (Germ l R) :=
+  Function.Surjective.nonAssocRing ofFun (surjective_quot_mk _) rfl rfl (fun _ _ ↦ rfl)
+    (fun _ _ ↦ rfl) (fun _ ↦ rfl) (fun _ _ ↦ rfl) (fun _ _ ↦ rfl) (fun _ _ ↦ rfl)
+    (fun _ ↦ rfl) fun _ ↦ rfl
 
 instance semiring [Semiring R] : Semiring (Germ l R) :=
-  { Germ.addCommMonoid, Germ.monoid, Germ.distrib, Germ.mulZeroClass, Germ.addMonoidWithOne with }
+  Function.Surjective.semiring ofFun (surjective_quot_mk _) rfl rfl (fun _ _ ↦ rfl)
+    (fun _ _ ↦ rfl) (fun _ _ ↦ rfl) (fun _ _ ↦ rfl) (fun _ ↦ rfl)
+
+instance ring [Ring R] : Ring (Germ l R) :=
+  Function.Surjective.ring ofFun (surjective_quot_mk _) rfl rfl (fun _ _ ↦ rfl) (fun _ _ ↦ rfl)
+    (fun _ ↦ rfl) (fun _ _ ↦ rfl) (fun _ _ ↦ rfl) (fun _ _ ↦ rfl) (fun _ _ ↦ rfl) (fun _ ↦ rfl)
+    (fun _ ↦ rfl)
+
+instance nonUnitalCommSemiring [NonUnitalCommSemiring R] : NonUnitalCommSemiring (Germ l R) :=
+  Function.Surjective.nonUnitalCommSemiring ofFun (surjective_quot_mk _) rfl (fun _ _ ↦ rfl)
+    (fun _ _ ↦ rfl) (fun _ _ ↦ rfl)
+
+instance commSemiring [CommSemiring R] : CommSemiring (Germ l R) :=
+  Function.Surjective.commSemiring ofFun (surjective_quot_mk _) rfl rfl (fun _ _ ↦ rfl)
+    (fun _ _ ↦ rfl) (fun _ _ ↦ rfl) (fun _ _ ↦ rfl) (fun _ ↦ rfl)
+
+instance nonUnitalCommRing [NonUnitalCommRing R] : NonUnitalCommRing (Germ l R) :=
+    Function.Surjective.nonUnitalCommRing ofFun (surjective_quot_mk _) rfl (fun _ _ ↦ rfl)
+      (fun _ _ ↦ rfl) (fun _ ↦ rfl) (fun _ _ ↦ rfl) (fun _ _ ↦ rfl) fun _ _ ↦ rfl
+
+instance commRing [CommRing R] : CommRing (Germ l R) :=
+  Function.Surjective.commRing ofFun (surjective_quot_mk _) rfl rfl (fun _ _ ↦ rfl) (fun _ _ ↦ rfl)
+    (fun _ ↦ rfl) (fun _ _ ↦ rfl) (fun _ _ ↦ rfl) (fun _ _ ↦ rfl) (fun _ _ ↦ rfl) (fun _ ↦ rfl)
+    (fun _ ↦ rfl)
 
 /-- Coercion `(α → R) → Germ l R` as a `RingHom`. -/
 def coeRingHom [Semiring R] (l : Filter α) : (α → R) →+* Germ l R :=
@@ -548,15 +621,6 @@ theorem coe_coeRingHom [Semiring R] : (coeRingHom l : (α → R) → Germ l R) =
   rfl
 #align filter.germ.coe_coe_ring_hom Filter.Germ.coe_coeRingHom
 
-instance ring [Ring R] : Ring (Germ l R) :=
-  { Germ.addCommGroup, Germ.semiring with }
-
-instance commSemiring [CommSemiring R] : CommSemiring (Germ l R) :=
-  { Germ.semiring, Germ.commMonoid with }
-
-instance commRing [CommRing R] : CommRing (Germ l R) :=
-  { Germ.ring, Germ.commMonoid with }
-
 end Ring
 
 section Module
@@ -700,19 +764,118 @@ theorem const_top [Top β] : (↑(⊤ : β) : Germ l β) = ⊤ :=
   rfl
 #align filter.germ.const_top Filter.Germ.const_top
 
-instance orderBot [LE β] [OrderBot β] : OrderBot (Germ l β)
-    where
+instance orderBot [LE β] [OrderBot β] : OrderBot (Germ l β) where
   bot := ⊥
   bot_le f := inductionOn f fun _ => eventually_of_forall fun _ => bot_le
 
-instance orderTop [LE β] [OrderTop β] : OrderTop (Germ l β)
-    where
+instance orderTop [LE β] [OrderTop β] : OrderTop (Germ l β) where
   top := ⊤
   le_top f := inductionOn f fun _ => eventually_of_forall fun _ => le_top
 
 instance [LE β] [BoundedOrder β] : BoundedOrder (Germ l β) :=
   { Filter.Germ.orderBot, Filter.Germ.orderTop with }
 
+instance sup [Sup β] : Sup (Germ l β) :=
+  ⟨map₂ (· ⊔ ·)⟩
+
+instance inf [Inf β] : Inf (Germ l β) :=
+  ⟨map₂ (· ⊓ ·)⟩
+
+@[simp, norm_cast]
+theorem const_sup [Sup β] (a b : β) : ↑(a ⊔ b) = (↑a ⊔ ↑b : Germ l β) :=
+  rfl
+#align filter.germ.const_sup Filter.Germ.const_sup
+
+@[simp, norm_cast]
+theorem const_inf [Inf β] (a b : β) : ↑(a ⊓ b) = (↑a ⊓ ↑b : Germ l β) :=
+  rfl
+#align filter.germ.const_inf Filter.Germ.const_inf
+
+instance semilatticeSup [SemilatticeSup β] : SemilatticeSup (Germ l β) :=
+  { Germ.partialOrder with
+    sup := (· ⊔ ·)
+    le_sup_left := fun f g =>
+        inductionOn₂ f g fun _f _g => eventually_of_forall fun _x => le_sup_left
+    le_sup_right := fun f g =>
+      inductionOn₂ f g fun _f _g => eventually_of_forall fun _x => le_sup_right
+    sup_le := fun f₁ f₂ g =>
+      inductionOn₃ f₁ f₂ g fun _f₁ _f₂ _g h₁ h₂ => h₂.mp <| h₁.mono fun _x => sup_le }
+
+instance semilatticeInf [SemilatticeInf β] : SemilatticeInf (Germ l β) :=
+  { Germ.partialOrder with
+    inf := (· ⊓ ·)
+    inf_le_left := fun f g =>
+        inductionOn₂ f g fun _f _g => eventually_of_forall fun _x => inf_le_left
+    inf_le_right := fun f g =>
+      inductionOn₂ f g fun _f _g => eventually_of_forall fun _x => inf_le_right
+    le_inf := fun f₁ f₂ g =>
+      inductionOn₃ f₁ f₂ g fun _f₁ _f₂ _g h₁ h₂ => h₂.mp <| h₁.mono fun _x => le_inf }
+
+instance lattice [Lattice β] : Lattice (Germ l β) :=
+  { Germ.semilatticeSup, Germ.semilatticeInf with }
+
+instance distribLattice [DistribLattice β] : DistribLattice (Germ l β) :=
+  { Germ.semilatticeSup, Germ.semilatticeInf with
+    le_sup_inf := fun f g h =>
+      inductionOn₃ f g h fun _f _g _h => eventually_of_forall fun _ => le_sup_inf }
+
+@[to_additive]
+instance orderedCommMonoid [OrderedCommMonoid β] : OrderedCommMonoid (Germ l β) :=
+  { Germ.partialOrder, Germ.commMonoid with
+    mul_le_mul_left := fun f g =>
+      inductionOn₂ f g fun _f _g H h =>
+        inductionOn h fun _h => H.mono fun _x H => mul_le_mul_left' H _ }
+
+@[to_additive]
+instance orderedCancelCommMonoid [OrderedCancelCommMonoid β]  :
+    OrderedCancelCommMonoid (Germ l β) :=
+  { Germ.orderedCommMonoid with
+    le_of_mul_le_mul_left := fun f g h =>
+      inductionOn₃ f g h fun _f _g _h H => H.mono fun _x => le_of_mul_le_mul_left' }
+
+@[to_additive]
+instance orderedCommGroup [OrderedCommGroup β] : OrderedCommGroup (Germ l β) :=
+  { Germ.orderedCancelCommMonoid, Germ.commGroup with }
+
+@[to_additive]
+instance existsMulOfLE [Mul β] [LE β] [ExistsMulOfLE β] : ExistsMulOfLE (Germ l β) where
+  exists_mul_of_le {x y} := inductionOn₂ x y fun f g (h : f ≤ᶠ[l] g) ↦ by
+    classical
+    choose c hc using fun x (hx : f x ≤ g x) ↦ exists_mul_of_le hx
+    refine ⟨ofFun <| fun x ↦ if hx : f x ≤ g x then c x hx else f x, coe_eq.2 ?_⟩
+    filter_upwards [h] with x hx
+    rw [dif_pos hx, hc]
+
+@[to_additive]
+instance canonicallyOrderedMonoid [CanonicallyOrderedMonoid β] :
+    CanonicallyOrderedMonoid (Germ l β) :=
+  { orderedCommMonoid, orderBot, existsMulOfLE with
+    le_self_mul := fun x y ↦ inductionOn₂ x y fun _ _ ↦ eventually_of_forall fun _ ↦ le_self_mul }
+
+instance orderedSemiring [OrderedSemiring β] : OrderedSemiring (Germ l β) :=
+  { Germ.semiring,
+    Germ.orderedAddCommMonoid with
+    zero_le_one := const_le zero_le_one
+    mul_le_mul_of_nonneg_left := fun x y z =>
+      inductionOn₃ x y z fun _f _g _h hfg hh =>
+          hh.mp <| hfg.mono fun _a => mul_le_mul_of_nonneg_left
+    mul_le_mul_of_nonneg_right := fun x y z =>
+      inductionOn₃ x y z fun _f _g _h hfg hh =>
+          hh.mp <| hfg.mono fun _a => mul_le_mul_of_nonneg_right }
+
+instance orderedCommSemiring [OrderedCommSemiring β] : OrderedCommSemiring (Germ l β) :=
+  { Germ.orderedSemiring, Germ.commSemiring with }
+
+instance orderedRing [OrderedRing β] : OrderedRing (Germ l β) :=
+  { Germ.ring,
+    Germ.orderedAddCommGroup with
+    zero_le_one := const_le zero_le_one
+    mul_nonneg := fun x y =>
+      inductionOn₂ x y fun _f _g hf hg => hg.mp <| hf.mono fun _a => mul_nonneg }
+
+instance orderedCommRing [OrderedCommRing β] : OrderedCommRing (Germ l β) :=
+  { Germ.orderedRing, Germ.orderedCommSemiring with }
+
 end Germ
 
 end Filter

• depends on: #5966

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

@@ -2,15 +2,12 @@
 Copyright (c) 2020 Yury G. Kudryashov. All rights reserved.
 Released under Apache 2.0 license as described in the file LICENSE.
 Authors: Yury G. Kudryashov, Abhimanyu Pallavi Sudhir
-
-! This file was ported from Lean 3 source module order.filter.germ
-! leanprover-community/mathlib commit 1f0096e6caa61e9c849ec2adbd227e960e9dff58
-! Please do not edit these lines, except to modify the commit id
-! if you have ported upstream changes.
 -/
 import Mathlib.Order.Filter.Basic
 import Mathlib.Algebra.Module.Pi
 
+#align_import order.filter.germ from "leanprover-community/mathlib"@"1f0096e6caa61e9c849ec2adbd227e960e9dff58"
+
 /-!
 # Germ of a function at a filter
 

@@ -59,7 +59,7 @@ namespace Filter
 
 variable {α β γ δ : Type _} {l : Filter α} {f g h : α → β}
 
-theorem const_eventuallyEq' [NeBot l] {a b : β} : (∀ᶠ _x in l, a = b) ↔ a = b :=
+theorem const_eventuallyEq' [NeBot l] {a b : β} : (∀ᶠ _ in l, a = b) ↔ a = b :=
   eventually_const
 #align filter.const_eventually_eq' Filter.const_eventuallyEq'
 

@@ -678,14 +678,14 @@ theorem const_le_iff [LE β] [NeBot l] {x y : β} : (↑x : Germ l β) ≤ ↑y
 instance preorder [Preorder β] : Preorder (Germ l β)
     where
   le := (· ≤ ·)
-  le_refl f := inductionOn f <| EventuallyLe.refl l
-  le_trans f₁ f₂ f₃ := inductionOn₃ f₁ f₂ f₃ fun f₁ f₂ f₃ => EventuallyLe.trans
+  le_refl f := inductionOn f <| EventuallyLE.refl l
+  le_trans f₁ f₂ f₃ := inductionOn₃ f₁ f₂ f₃ fun f₁ f₂ f₃ => EventuallyLE.trans
 
 instance partialOrder [PartialOrder β] : PartialOrder (Germ l β) :=
   { Filter.Germ.preorder with
     le := (· ≤ ·)
     le_antisymm := fun f g =>
-      inductionOn₂ f g fun _ _ h₁ h₂ => (EventuallyLe.antisymm h₁ h₂).germ_eq }
+      inductionOn₂ f g fun _ _ h₁ h₂ => (EventuallyLE.antisymm h₁ h₂).germ_eq }
 
 instance bot [Bot β] : Bot (Germ l β) :=
   ⟨↑(⊥ : β)⟩

is_scalar_tower is now IsScalarTower etc.

As discussed on Zulip, this also renames sMulCommClass to smulCommClass. The later was already the majority spelling.

@@ -382,11 +382,11 @@ instance rightCancelSemigroup [RightCancelSemigroup M] : RightCancelSemigroup (G
       inductionOn₃ f₁ f₂ f₃ fun _f₁ _f₂ _f₃ H =>
         coe_eq.2 <| (coe_eq.1 H).mono fun _x => mul_right_cancel }
 
-@[to_additive vAdd]
-instance sMul [SMul M G] : SMul M (Germ l G) :=
+@[to_additive]
+instance smul [SMul M G] : SMul M (Germ l G) :=
   ⟨fun n => map (n • ·)⟩
 
-@[to_additive existing sMul]
+@[to_additive existing smul]
 instance pow [Pow G M] : Pow (Germ l G) M :=
   ⟨fun f n => map (· ^ n) f⟩
 

• Force the user to specify whether the additive declaration already exists.
• Will raise a linter error if the user specified it wrongly
• Requested on Zulip

@@ -382,14 +382,11 @@ instance rightCancelSemigroup [RightCancelSemigroup M] : RightCancelSemigroup (G
       inductionOn₃ f₁ f₂ f₃ fun _f₁ _f₂ _f₃ H =>
         coe_eq.2 <| (coe_eq.1 H).mono fun _x => mul_right_cancel }
 
-instance vAdd [VAdd M G] : VAdd M (Germ l G) :=
-  ⟨fun n => map ((· +ᵥ ·) n)⟩
-
-@[to_additive]
+@[to_additive vAdd]
 instance sMul [SMul M G] : SMul M (Germ l G) :=
   ⟨fun n => map (n • ·)⟩
 
-@[to_additive sMul]
+@[to_additive existing sMul]
 instance pow [Pow G M] : Pow (Germ l G) M :=
   ⟨fun f n => map (· ^ n) f⟩
 
@@ -415,11 +412,11 @@ theorem const_pow [Pow G M] (a : G) (n : M) : (↑(a ^ n) : Germ l G) = (↑a :
   rfl
 #align filter.germ.const_pow Filter.Germ.const_pow
 
--- Porting note: `to_additive` can't generate this.
+-- Porting note: `to_additive` can't generate this (firstMultArg bug).
 instance addMonoid [AddMonoid M] : AddMonoid (Germ l M) :=
   Function.Surjective.addMonoid ofFun (surjective_quot_mk _) rfl (fun _ _ => rfl) fun _ _ => rfl
 
-@[to_additive]
+@[to_additive existing]
 instance monoid [Monoid M] : Monoid (Germ l M) :=
   Function.Surjective.monoid ofFun (surjective_quot_mk _) rfl (fun _ _ => rfl) fun _ _ => rfl
 
@@ -485,7 +482,7 @@ instance subNegMonoid [SubNegMonoid G] : SubNegMonoid (Germ l G) :=
   Function.Surjective.subNegMonoid ofFun (surjective_quot_mk _) rfl (fun _ _ => rfl) (fun _ => rfl)
     (fun _ _ => rfl) (fun _ _ => rfl) fun _ _ => rfl
 
-@[to_additive subNegMonoid]
+@[to_additive existing subNegMonoid]
 instance divInvMonoid [DivInvMonoid G] : DivInvMonoid (Germ l G) :=
   Function.Surjective.divInvMonoid ofFun (surjective_quot_mk _) rfl (fun _ _ => rfl) (fun _ => rfl)
     (fun _ _ => rfl) (fun _ _ => rfl) fun _ _ => rfl

also names instances in Order.Filter.Germ

@@ -103,10 +103,10 @@ namespace Product
 
 variable {ε : α → Type _}
 
-instance : CoeTC ((a : _) → ε a) (l.Product ε) :=
+instance coeTC : CoeTC ((a : _) → ε a) (l.Product ε) :=
   ⟨@Quotient.mk' _ (productSetoid _ ε)⟩
 
-instance [(a : _) → Inhabited (ε a)] : Inhabited (l.Product ε) :=
+instance inhabited [(a : _) → Inhabited (ε a)] : Inhabited (l.Product ε) :=
   ⟨(↑fun a => (default : ε a) : l.Product ε)⟩
 
 end Product
@@ -123,7 +123,7 @@ instance : CoeTC (α → β) (Germ l β) :=
 @[coe] -- Porting note: removed `HasLiftT` instance
 def const {l : Filter α} (b : β) : (Germ l β) := ofFun fun _ => b
 
-instance : CoeTC β (Germ l β) :=
+instance coeTC : CoeTC β (Germ l β) :=
   ⟨const⟩
 
 @[simp]
@@ -331,7 +331,7 @@ theorem liftRel_const_iff [NeBot l] {r : β → γ → Prop} {x : β} {y : γ} :
   @eventually_const _ _ _ (r x y)
 #align filter.germ.lift_rel_const_iff Filter.Germ.liftRel_const_iff
 
-instance [Inhabited β] : Inhabited (Germ l β) :=
+instance inhabited [Inhabited β] : Inhabited (Germ l β) :=
   ⟨↑(default : β)⟩
 
 section Monoid
@@ -382,15 +382,15 @@ instance rightCancelSemigroup [RightCancelSemigroup M] : RightCancelSemigroup (G
       inductionOn₃ f₁ f₂ f₃ fun _f₁ _f₂ _f₃ H =>
         coe_eq.2 <| (coe_eq.1 H).mono fun _x => mul_right_cancel }
 
-instance [VAdd M G] : VAdd M (Germ l G) :=
+instance vAdd [VAdd M G] : VAdd M (Germ l G) :=
   ⟨fun n => map ((· +ᵥ ·) n)⟩
 
 @[to_additive]
-instance [SMul M G] : SMul M (Germ l G) :=
+instance sMul [SMul M G] : SMul M (Germ l G) :=
   ⟨fun n => map (n • ·)⟩
 
-@[to_additive instSMulGerm]
-instance [Pow G M] : Pow (Germ l G) M :=
+@[to_additive sMul]
+instance pow [Pow G M] : Pow (Germ l G) M :=
   ⟨fun f n => map (· ^ n) f⟩
 
 @[to_additive (attr := simp, norm_cast)]
@@ -449,7 +449,7 @@ instance addMonoidWithOne [AddMonoidWithOne M] : AddMonoidWithOne (Germ l M) :=
     natCast_succ := fun _ => congr_arg ((↑) : M → Germ l M) (Nat.cast_succ _) }
 
 @[to_additive]
-instance [Inv G] : Inv (Germ l G) :=
+instance inv [Inv G] : Inv (Germ l G) :=
   ⟨map Inv.inv⟩
 
 @[to_additive (attr := simp, norm_cast)]
@@ -582,7 +582,7 @@ theorem coe_smul' [SMul M β] (c : α → M) (f : α → β) : ↑(c • f) = (c
 #align filter.germ.coe_vadd' Filter.Germ.coe_vadd'
 
 @[to_additive]
-instance [Monoid M] [MulAction M β] : MulAction M (Germ l β) where
+instance mulAction [Monoid M] [MulAction M β] : MulAction M (Germ l β) where
   -- Porting note: `rfl` required.
   one_smul f :=
     inductionOn f fun f => by
@@ -653,7 +653,7 @@ instance module' [Semiring R] [AddCommMonoid M] [Module R M] : Module (Germ l R)
 
 end Module
 
-instance [LE β] : LE (Germ l β) :=
+instance le [LE β] : LE (Germ l β) :=
   ⟨LiftRel (· ≤ ·)⟩
 
 theorem le_def [LE β] : ((· ≤ ·) : Germ l β → Germ l β → Prop) = LiftRel (· ≤ ·) :=
@@ -678,22 +678,22 @@ theorem const_le_iff [LE β] [NeBot l] {x y : β} : (↑x : Germ l β) ≤ ↑y
   liftRel_const_iff
 #align filter.germ.const_le_iff Filter.Germ.const_le_iff
 
-instance [Preorder β] : Preorder (Germ l β)
+instance preorder [Preorder β] : Preorder (Germ l β)
     where
   le := (· ≤ ·)
   le_refl f := inductionOn f <| EventuallyLe.refl l
   le_trans f₁ f₂ f₃ := inductionOn₃ f₁ f₂ f₃ fun f₁ f₂ f₃ => EventuallyLe.trans
 
-instance [PartialOrder β] : PartialOrder (Germ l β) :=
-  { Filter.Germ.instPreorderGerm with
+instance partialOrder [PartialOrder β] : PartialOrder (Germ l β) :=
+  { Filter.Germ.preorder with
     le := (· ≤ ·)
     le_antisymm := fun f g =>
       inductionOn₂ f g fun _ _ h₁ h₂ => (EventuallyLe.antisymm h₁ h₂).germ_eq }
 
-instance [Bot β] : Bot (Germ l β) :=
+instance bot [Bot β] : Bot (Germ l β) :=
   ⟨↑(⊥ : β)⟩
 
-instance [Top β] : Top (Germ l β) :=
+instance top [Top β] : Top (Germ l β) :=
   ⟨↑(⊤ : β)⟩
 
 @[simp, norm_cast]
@@ -706,18 +706,18 @@ theorem const_top [Top β] : (↑(⊤ : β) : Germ l β) = ⊤ :=
   rfl
 #align filter.germ.const_top Filter.Germ.const_top
 
-instance [LE β] [OrderBot β] : OrderBot (Germ l β)
+instance orderBot [LE β] [OrderBot β] : OrderBot (Germ l β)
     where
   bot := ⊥
   bot_le f := inductionOn f fun _ => eventually_of_forall fun _ => bot_le
 
-instance [LE β] [OrderTop β] : OrderTop (Germ l β)
+instance orderTop [LE β] [OrderTop β] : OrderTop (Germ l β)
     where
   top := ⊤
   le_top f := inductionOn f fun _ => eventually_of_forall fun _ => le_top
 
 instance [LE β] [BoundedOrder β] : BoundedOrder (Germ l β) :=
-  { Filter.Germ.instOrderBotGermInstLEGerm, Filter.Germ.instOrderTopGermInstLEGerm with }
+  { Filter.Germ.orderBot, Filter.Germ.orderTop with }
 
 end Germ
 

Co-authored-by: Yury G. Kudryashov <urkud@urkud.name> Co-authored-by: Joachim Breitner <mail@joachim-breitner.de> Co-authored-by: Komyyy <pol_tta@outlook.jp> Co-authored-by: Pol_tta <52843868+Komyyy@users.noreply.github.com>