l3lab/ntp-mathlib huggingface dataset:
/-- The lifting property of the equalizer as an equivalence. -/
@[simps]
def liftEquiv :
    { φ : NormedAddGroupHom V₁ V // f.comp φ = g.comp φ } ≃ NormedAddGroupHom V₁ (f.equalizer g)
    where
  toFun φ := lift φ φ.prop
  invFun ψ := ⟨(ι f g).comp ψ, by rw [← comp_assoc, ← comp_assoc, comp_ι_eq]⟩
  left_inv φ := by simp
  right_inv ψ := by
    ext
    

Proof state:
case H.a
V : Type u_1
W : Type u_2
V₁ : Type u_3
V₂ : Type u_4
V₃ : Type u_5
inst✝⁷ : SeminormedAddCommGroup V
inst✝⁶ : SeminormedAddCommGroup W
inst✝⁵ : SeminormedAddCommGroup V₁
inst✝⁴ : SeminormedAddCommGroup V₂
inst✝³ : SeminormedAddCommGroup V₃
f : NormedAddGroupHom V W
W₁ : Type u_6
W₂ : Type u_7
W₃ : Type u_8
inst✝² : SeminormedAddCommGroup W₁
inst✝¹ : SeminormedAddCommGroup W₂
inst✝ : SeminormedAddCommGroup W₃
g : NormedAddGroupHom V W
f₁ g₁ : NormedAddGroupHom V₁ W₁
f₂ g₂ : NormedAddGroupHom V₂ W₂
f₃ g₃ : NormedAddGroupHom V₃ W₃
ψ : NormedAddGroupHom V₁ ↥(equalizer f g)
x✝ : V₁
⊢ ↑(((fun φ => lift ↑φ (_ : NormedAddGroupHom.comp f ↑φ = NormedAddGroupHom.comp g ↑φ))
          ((fun ψ =>
              { val := NormedAddGroupHom.comp (ι f g) ψ,
                property :=
                  (_ :
                    NormedAddGroupHom.comp f (NormedAddGroupHom.comp (ι f g) ψ) =
                      NormedAddGroupHom.comp g (NormedAddGroupHom.comp (ι f g) ψ)) })
            ψ))
        x✝) =
    ↑(ψ x✝)

Next tactic:
rfl
/-- Given `φ : NormedAddGroupHom V₁ V₂` and `ψ : NormedAddGroupHom W₁ W₂` such that
`ψ.comp f₁ = f₂.comp φ` and `ψ.comp g₁ = g₂.comp φ`, the induced morphism
`NormedAddGroupHom (f₁.equalizer g₁) (f₂.equalizer g₂)`. -/
def map (φ : NormedAddGroupHom V₁ V₂) (ψ : NormedAddGroupHom W₁ W₂) (hf : ψ.comp f₁ = f₂.comp φ)
    (hg : ψ.comp g₁ = g₂.comp φ) : NormedAddGroupHom (f₁.equalizer g₁) (f₂.equalizer g₂) :=
  lift (φ.comp <| ι _ _) <| by
    

Proof state:
V : Type u_1
W : Type u_2
V₁ : Type u_3
V₂ : Type u_4
V₃ : Type u_5
inst✝⁷ : SeminormedAddCommGroup V
inst✝⁶ : SeminormedAddCommGroup W
inst✝⁵ : SeminormedAddCommGroup V₁
inst✝⁴ : SeminormedAddCommGroup V₂
inst✝³ : SeminormedAddCommGroup V₃
f : NormedAddGroupHom V W
W₁ : Type u_6
W₂ : Type u_7
W₃ : Type u_8
inst✝² : SeminormedAddCommGroup W₁
inst✝¹ : SeminormedAddCommGroup W₂
inst✝ : SeminormedAddCommGroup W₃
g : NormedAddGroupHom V W
f₁ g₁ : NormedAddGroupHom V₁ W₁
f₂ g₂ : NormedAddGroupHom V₂ W₂
f₃ g₃ : NormedAddGroupHom V₃ W₃
φ : NormedAddGroupHom V₁ V₂
ψ : NormedAddGroupHom W₁ W₂
hf : NormedAddGroupHom.comp ψ f₁ = NormedAddGroupHom.comp f₂ φ
hg : NormedAddGroupHom.comp ψ g₁ = NormedAddGroupHom.comp g₂ φ
⊢ NormedAddGroupHom.comp f₂ (NormedAddGroupHom.comp φ (ι f₁ g₁)) =
    NormedAddGroupHom.comp g₂ (NormedAddGroupHom.comp φ (ι f₁ g₁))

Next tactic:
simp only [← comp_assoc, ← hf, ← hg]
/-- Given `φ : NormedAddGroupHom V₁ V₂` and `ψ : NormedAddGroupHom W₁ W₂` such that
`ψ.comp f₁ = f₂.comp φ` and `ψ.comp g₁ = g₂.comp φ`, the induced morphism
`NormedAddGroupHom (f₁.equalizer g₁) (f₂.equalizer g₂)`. -/
def map (φ : NormedAddGroupHom V₁ V₂) (ψ : NormedAddGroupHom W₁ W₂) (hf : ψ.comp f₁ = f₂.comp φ)
    (hg : ψ.comp g₁ = g₂.comp φ) : NormedAddGroupHom (f₁.equalizer g₁) (f₂.equalizer g₂) :=
  lift (φ.comp <| ι _ _) <| by
    simp only [← comp_assoc, ← hf, ← hg]
    

Proof state:
V : Type u_1
W : Type u_2
V₁ : Type u_3
V₂ : Type u_4
V₃ : Type u_5
inst✝⁷ : SeminormedAddCommGroup V
inst✝⁶ : SeminormedAddCommGroup W
inst✝⁵ : SeminormedAddCommGroup V₁
inst✝⁴ : SeminormedAddCommGroup V₂
inst✝³ : SeminormedAddCommGroup V₃
f : NormedAddGroupHom V W
W₁ : Type u_6
W₂ : Type u_7
W₃ : Type u_8
inst✝² : SeminormedAddCommGroup W₁
inst✝¹ : SeminormedAddCommGroup W₂
inst✝ : SeminormedAddCommGroup W₃
g : NormedAddGroupHom V W
f₁ g₁ : NormedAddGroupHom V₁ W₁
f₂ g₂ : NormedAddGroupHom V₂ W₂
f₃ g₃ : NormedAddGroupHom V₃ W₃
φ : NormedAddGroupHom V₁ V₂
ψ : NormedAddGroupHom W₁ W₂
hf : NormedAddGroupHom.comp ψ f₁ = NormedAddGroupHom.comp f₂ φ
hg : NormedAddGroupHom.comp ψ g₁ = NormedAddGroupHom.comp g₂ φ
⊢ NormedAddGroupHom.comp (NormedAddGroupHom.comp ψ f₁) (ι f₁ g₁) =
    NormedAddGroupHom.comp (NormedAddGroupHom.comp ψ g₁) (ι f₁ g₁)

Next tactic:
simp only [comp_assoc, comp_ι_eq f₁ g₁]
@[simp]
theorem map_id : map (f₂ := f₁) (g₂ := g₁) (id V₁) (id W₁) rfl rfl = id (f₁.equalizer g₁) := by
  

Proof state:
V : Type u_1
W : Type u_2
V₁ : Type u_3
V₂ : Type u_4
V₃ : Type u_5
inst✝⁷ : SeminormedAddCommGroup V
inst✝⁶ : SeminormedAddCommGroup W
inst✝⁵ : SeminormedAddCommGroup V₁
inst✝⁴ : SeminormedAddCommGroup V₂
inst✝³ : SeminormedAddCommGroup V₃
f : NormedAddGroupHom V W
W₁ : Type u_6
W₂ : Type u_7
W₃ : Type u_8
inst✝² : SeminormedAddCommGroup W₁
inst✝¹ : SeminormedAddCommGroup W₂
inst✝ : SeminormedAddCommGroup W₃
g : NormedAddGroupHom V W
f₁ g₁ : NormedAddGroupHom V₁ W₁
f₂ g₂ : NormedAddGroupHom V₂ W₂
f₃ g₃ : NormedAddGroupHom V₃ W₃
φ : NormedAddGroupHom V₁ V₂
ψ : NormedAddGroupHom W₁ W₂
φ' : NormedAddGroupHom V₂ V₃
ψ' : NormedAddGroupHom W₂ W₃
⊢ map (id V₁) (id W₁) (_ : NormedAddGroupHom.comp (id W₁) f₁ = NormedAddGroupHom.comp (id W₁) f₁)
      (_ : NormedAddGroupHom.comp (id W₁) g₁ = NormedAddGroupHom.comp (id W₁) g₁) =
    id ↥(equalizer f₁ g₁)

Next tactic:
ext
@[simp]
theorem map_id : map (f₂ := f₁) (g₂ := g₁) (id V₁) (id W₁) rfl rfl = id (f₁.equalizer g₁) := by
  ext
  

Proof state:
case H.a
V : Type u_1
W : Type u_2
V₁ : Type u_3
V₂ : Type u_4
V₃ : Type u_5
inst✝⁷ : SeminormedAddCommGroup V
inst✝⁶ : SeminormedAddCommGroup W
inst✝⁵ : SeminormedAddCommGroup V₁
inst✝⁴ : SeminormedAddCommGroup V₂
inst✝³ : SeminormedAddCommGroup V₃
f : NormedAddGroupHom V W
W₁ : Type u_6
W₂ : Type u_7
W₃ : Type u_8
inst✝² : SeminormedAddCommGroup W₁
inst✝¹ : SeminormedAddCommGroup W₂
inst✝ : SeminormedAddCommGroup W₃
g : NormedAddGroupHom V W
f₁ g₁ : NormedAddGroupHom V₁ W₁
f₂ g₂ : NormedAddGroupHom V₂ W₂
f₃ g₃ : NormedAddGroupHom V₃ W₃
φ : NormedAddGroupHom V₁ V₂
ψ : NormedAddGroupHom W₁ W₂
φ' : NormedAddGroupHom V₂ V₃
ψ' : NormedAddGroupHom W₂ W₃
x✝ : ↥(equalizer f₁ g₁)
⊢ ↑((map (id V₁) (id W₁) (_ : NormedAddGroupHom.comp (id W₁) f₁ = NormedAddGroupHom.comp (id W₁) f₁)
          (_ : NormedAddGroupHom.comp (id W₁) g₁ = NormedAddGroupHom.comp (id W₁) g₁))
        x✝) =
    ↑((id ↥(equalizer f₁ g₁)) x✝)

Next tactic:
rfl
theorem comm_sq₂ (hf : ψ.comp f₁ = f₂.comp φ) (hf' : ψ'.comp f₂ = f₃.comp φ') :
    (ψ'.comp ψ).comp f₁ = f₃.comp (φ'.comp φ) := by
  

Proof state:
V : Type u_1
W : Type u_2
V₁ : Type u_3
V₂ : Type u_4
V₃ : Type u_5
inst✝⁷ : SeminormedAddCommGroup V
inst✝⁶ : SeminormedAddCommGroup W
inst✝⁵ : SeminormedAddCommGroup V₁
inst✝⁴ : SeminormedAddCommGroup V₂
inst✝³ : SeminormedAddCommGroup V₃
f : NormedAddGroupHom V W
W₁ : Type u_6
W₂ : Type u_7
W₃ : Type u_8
inst✝² : SeminormedAddCommGroup W₁
inst✝¹ : SeminormedAddCommGroup W₂
inst✝ : SeminormedAddCommGroup W₃
g : NormedAddGroupHom V W
f₁ g₁ : NormedAddGroupHom V₁ W₁
f₂ g₂ : NormedAddGroupHom V₂ W₂
f₃ g₃ : NormedAddGroupHom V₃ W₃
φ : NormedAddGroupHom V₁ V₂
ψ : NormedAddGroupHom W₁ W₂
φ' : NormedAddGroupHom V₂ V₃
ψ' : NormedAddGroupHom W₂ W₃
hf : NormedAddGroupHom.comp ψ f₁ = NormedAddGroupHom.comp f₂ φ
hf' : NormedAddGroupHom.comp ψ' f₂ = NormedAddGroupHom.comp f₃ φ'
⊢ NormedAddGroupHom.comp (NormedAddGroupHom.comp ψ' ψ) f₁ = NormedAddGroupHom.comp f₃ (NormedAddGroupHom.comp φ' φ)

Next tactic:
rw [comp_assoc, hf, ← comp_assoc, hf', comp_assoc]
theorem map_comp_map (hf : ψ.comp f₁ = f₂.comp φ) (hg : ψ.comp g₁ = g₂.comp φ)
    (hf' : ψ'.comp f₂ = f₃.comp φ') (hg' : ψ'.comp g₂ = g₃.comp φ') :
    (map φ' ψ' hf' hg').comp (map φ ψ hf hg) =
      map (φ'.comp φ) (ψ'.comp ψ) (comm_sq₂ hf hf') (comm_sq₂ hg hg') := by
  

Proof state:
V : Type u_1
W : Type u_2
V₁ : Type u_3
V₂ : Type u_4
V₃ : Type u_5
inst✝⁷ : SeminormedAddCommGroup V
inst✝⁶ : SeminormedAddCommGroup W
inst✝⁵ : SeminormedAddCommGroup V₁
inst✝⁴ : SeminormedAddCommGroup V₂
inst✝³ : SeminormedAddCommGroup V₃
f : NormedAddGroupHom V W
W₁ : Type u_6
W₂ : Type u_7
W₃ : Type u_8
inst✝² : SeminormedAddCommGroup W₁
inst✝¹ : SeminormedAddCommGroup W₂
inst✝ : SeminormedAddCommGroup W₃
g : NormedAddGroupHom V W
f₁ g₁ : NormedAddGroupHom V₁ W₁
f₂ g₂ : NormedAddGroupHom V₂ W₂
f₃ g₃ : NormedAddGroupHom V₃ W₃
φ : NormedAddGroupHom V₁ V₂
ψ : NormedAddGroupHom W₁ W₂
φ' : NormedAddGroupHom V₂ V₃
ψ' : NormedAddGroupHom W₂ W₃
hf : NormedAddGroupHom.comp ψ f₁ = NormedAddGroupHom.comp f₂ φ
hg : NormedAddGroupHom.comp ψ g₁ = NormedAddGroupHom.comp g₂ φ
hf' : NormedAddGroupHom.comp ψ' f₂ = NormedAddGroupHom.comp f₃ φ'
hg' : NormedAddGroupHom.comp ψ' g₂ = NormedAddGroupHom.comp g₃ φ'
⊢ NormedAddGroupHom.comp (map φ' ψ' hf' hg') (map φ ψ hf hg) =
    map (NormedAddGroupHom.comp φ' φ) (NormedAddGroupHom.comp ψ' ψ)
      (_ :
        NormedAddGroupHom.comp (NormedAddGroupHom.comp ψ' ψ) f₁ =
          NormedAddGroupHom.comp f₃ (NormedAddGroupHom.comp φ' φ))
      (_ :
        NormedAddGroupHom.comp (NormedAddGroupHom.comp ψ' ψ) g₁ =
          NormedAddGroupHom.comp g₃ (NormedAddGroupHom.comp φ' φ))

Next tactic:
ext
theorem map_comp_map (hf : ψ.comp f₁ = f₂.comp φ) (hg : ψ.comp g₁ = g₂.comp φ)
    (hf' : ψ'.comp f₂ = f₃.comp φ') (hg' : ψ'.comp g₂ = g₃.comp φ') :
    (map φ' ψ' hf' hg').comp (map φ ψ hf hg) =
      map (φ'.comp φ) (ψ'.comp ψ) (comm_sq₂ hf hf') (comm_sq₂ hg hg') := by
  ext
  

Proof state:
case H.a
V : Type u_1
W : Type u_2
V₁ : Type u_3
V₂ : Type u_4
V₃ : Type u_5
inst✝⁷ : SeminormedAddCommGroup V
inst✝⁶ : SeminormedAddCommGroup W
inst✝⁵ : SeminormedAddCommGroup V₁
inst✝⁴ : SeminormedAddCommGroup V₂
inst✝³ : SeminormedAddCommGroup V₃
f : NormedAddGroupHom V W
W₁ : Type u_6
W₂ : Type u_7
W₃ : Type u_8
inst✝² : SeminormedAddCommGroup W₁
inst✝¹ : SeminormedAddCommGroup W₂
inst✝ : SeminormedAddCommGroup W₃
g : NormedAddGroupHom V W
f₁ g₁ : NormedAddGroupHom V₁ W₁
f₂ g₂ : NormedAddGroupHom V₂ W₂
f₃ g₃ : NormedAddGroupHom V₃ W₃
φ : NormedAddGroupHom V₁ V₂
ψ : NormedAddGroupHom W₁ W₂
φ' : NormedAddGroupHom V₂ V₃
ψ' : NormedAddGroupHom W₂ W₃
hf : NormedAddGroupHom.comp ψ f₁ = NormedAddGroupHom.comp f₂ φ
hg : NormedAddGroupHom.comp ψ g₁ = NormedAddGroupHom.comp g₂ φ
hf' : NormedAddGroupHom.comp ψ' f₂ = NormedAddGroupHom.comp f₃ φ'
hg' : NormedAddGroupHom.comp ψ' g₂ = NormedAddGroupHom.comp g₃ φ'
x✝ : ↥(equalizer f₁ g₁)
⊢ ↑((NormedAddGroupHom.comp (map φ' ψ' hf' hg') (map φ ψ hf hg)) x✝) =
    ↑((map (NormedAddGroupHom.comp φ' φ) (NormedAddGroupHom.comp ψ' ψ)
          (_ :
            NormedAddGroupHom.comp (NormedAddGroupHom.comp ψ' ψ) f₁ =
              NormedAddGroupHom.comp f₃ (NormedAddGroupHom.comp φ' φ))
          (_ :
            NormedAddGroupHom.comp (NormedAddGroupHom.comp ψ' ψ) g₁ =
              NormedAddGroupHom.comp g₃ (NormedAddGroupHom.comp φ' φ)))
        x✝)

Next tactic:
rfl
@[simp]
theorem map_id : map id = (id : Germ l β → Germ l β) := by
  

Proof state:
α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
l : Filter α
f g h : α → β
⊢ map id = id

Next tactic:
ext ⟨f⟩
@[simp]
theorem map_id : map id = (id : Germ l β → Germ l β) := by
  ext ⟨f⟩
  

Proof state:
case h.mk
α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
l : Filter α
f✝ g h : α → β
x✝ : Germ l β
f : α → β
⊢ map id (Quot.mk Setoid.r f) = id (Quot.mk Setoid.r f)

Next tactic:
rfl
/-- Lift a binary function `β → γ → δ` to a function `Germ l β → Germ l γ → Germ l δ`. -/
def map₂ (op : β → γ → δ) : Germ l β → Germ l γ → Germ l δ :=
  Quotient.map₂' (fun f g x => op (f x) (g x)) fun f f' Hf g g' Hg =>
    Hg.mp <| Hf.mono fun x Hf Hg => by 

Proof state:
α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
l : Filter α
f✝ g✝ h : α → β
op : β → γ → δ
f f' : α → β
Hf✝ : Setoid.r f f'
g g' : α → γ
Hg✝ : Setoid.r g g'
x : α
Hf : f x = f' x
Hg : g x = g' x
⊢ (fun f g x => op (f x) (g x)) f g x = (fun f g x => op (f x) (g x)) f' g' x

Next tactic:
simp only [Hf, Hg]
@[to_additive]
instance monoid [Monoid M] : Monoid (Germ l M) :=
  { Function.Surjective.monoid ofFun (surjective_quot_mk _) (by 

Proof state:
α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
l : Filter α
f g h : α → β
M : Type u_5
G : Type u_6
inst✝ : Monoid M
⊢ ↑1 = 1

Next tactic:
rfl
@[to_additive]
instance monoid [Monoid M] : Monoid (Germ l M) :=
  { Function.Surjective.monoid ofFun (surjective_quot_mk _) (by rfl)
      (fun _ _ => by 

Proof state:
α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
l : Filter α
f g h : α → β
M : Type u_5
G : Type u_6
inst✝ : Monoid M
x✝¹ x✝ : α → M
⊢ ↑(x✝¹ * x✝) = ↑x✝¹ * ↑x✝

Next tactic:
rfl
@[to_additive]
instance monoid [Monoid M] : Monoid (Germ l M) :=
  { Function.Surjective.monoid ofFun (surjective_quot_mk _) (by rfl)
      (fun _ _ => by rfl) fun _ _ => by 

Proof state:
α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
l : Filter α
f g h : α → β
M : Type u_5
G : Type u_6
inst✝ : Monoid M
x✝¹ : α → M
x✝ : ℕ
⊢ ↑(x✝¹ ^ x✝) = ↑x✝¹ ^ x✝

Next tactic:
rfl
instance addMonoidWithOne [AddMonoidWithOne M] : AddMonoidWithOne (Germ l M) :=
  { natCast, addMonoid, one with
    natCast_zero := congrArg ofFun <| by 

Proof state:
α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
l : Filter α
f g h : α → β
M : Type u_5
G : Type u_6
inst✝ : AddMonoidWithOne M
src✝² : NatCast (Germ l M) := natCast
src✝¹ : AddMonoid (Germ l M) := addMonoid
src✝ : One (Germ l M) := one
⊢ ↑0 = fun x => 0

Next tactic:
simp
instance addMonoidWithOne [AddMonoidWithOne M] : AddMonoidWithOne (Germ l M) :=
  { natCast, addMonoid, one with
    natCast_zero := congrArg ofFun <| by simp; 

Proof state:
α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
l : Filter α
f g h : α → β
M : Type u_5
G : Type u_6
inst✝ : AddMonoidWithOne M
src✝² : NatCast (Germ l M) := natCast
src✝¹ : AddMonoid (Germ l M) := addMonoid
src✝ : One (Germ l M) := one
⊢ 0 = fun x => 0

Next tactic:
rfl
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 

Proof state:
α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
l : Filter α
f g h : α → β
M : Type u_5
G : Type u_6
inst✝ : AddMonoidWithOne M
src✝² : NatCast (Germ l M) := natCast
src✝¹ : AddMonoid (Germ l M) := addMonoid
src✝ : One (Germ l M) := one
x✝ : ℕ
⊢ ↑(x✝ + 1) = (fun f g x => (fun x x_1 => x + x_1) (f x) (g x)) ↑x✝ fun x => 1

Next tactic:
simp [Function.comp]
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]; 

Proof state:
α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
l : Filter α
f g h : α → β
M : Type u_5
G : Type u_6
inst✝ : AddMonoidWithOne M
src✝² : NatCast (Germ l M) := natCast
src✝¹ : AddMonoid (Germ l M) := addMonoid
src✝ : One (Germ l M) := one
x✝ : ℕ
⊢ (fun x => ↑x✝) + 1 = fun x => ↑x✝ + 1

Next tactic:
rfl
instance addGroupWithOne [AddGroupWithOne G] : AddGroupWithOne (Germ l G) :=
  { intCast, addMonoidWithOne, addGroup with
    intCast_ofNat := fun _ => congrArg ofFun <| by 

Proof state:
α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
l : Filter α
f g h : α → β
M : Type u_5
G : Type u_6
inst✝ : AddGroupWithOne G
src✝² : IntCast (Germ l G) := intCast
src✝¹ : AddMonoidWithOne (Germ l G) := addMonoidWithOne
src✝ : AddGroup (Germ l G) := addGroup
x✝ : ℕ
⊢ ↑↑x✝ = ↑x✝

Next tactic:
simp
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 

Proof state:
α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
l : Filter α
f g h : α → β
M : Type u_5
G : Type u_6
inst✝ : AddGroupWithOne G
src✝² : IntCast (Germ l G) := intCast
src✝¹ : AddMonoidWithOne (Germ l G) := addMonoidWithOne
src✝ : AddGroup (Germ l G) := addGroup
x✝ : ℕ
⊢ ↑(Int.negSucc x✝) = (fun x => Neg.neg ∘ x) ↑(x✝ + 1)

Next tactic:
simp [Function.comp]
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]; 

Proof state:
α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
l : Filter α
f g h : α → β
M : Type u_5
G : Type u_6
inst✝ : AddGroupWithOne G
src✝² : IntCast (Germ l G) := intCast
src✝¹ : AddMonoidWithOne (Germ l G) := addMonoidWithOne
src✝ : AddGroup (Germ l G) := addGroup
x✝ : ℕ
⊢ (-1 + -fun x => ↑x✝) = fun x => -1 + -↑x✝

Next tactic:
rfl
@[to_additive]
instance mulAction [Monoid M] [MulAction M β] : MulAction M (Germ l β) where
  -- Porting note: `rfl` required.
  one_smul f :=
    inductionOn f fun f => by
      

Proof state:
α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
l : Filter α
f✝¹ g h : α → β
M : Type u_5
N : Type u_6
R : Type u_7
inst✝¹ : Monoid M
inst✝ : MulAction M β
f✝ : Germ l β
f : α → β
⊢ 1 • ↑f = ↑f

Next tactic:
norm_cast
@[to_additive]
instance mulAction [Monoid M] [MulAction M β] : MulAction M (Germ l β) where
  -- Porting note: `rfl` required.
  one_smul f :=
    inductionOn f fun f => by
      norm_cast
      

Proof state:
α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
l : Filter α
f✝¹ g h : α → β
M : Type u_5
N : Type u_6
R : Type u_7
inst✝¹ : Monoid M
inst✝ : MulAction M β
f✝ : Germ l β
f : α → β
⊢ 1 • f =ᶠ[l] f

Next tactic:
simp only [one_smul]
@[to_additive]
instance mulAction [Monoid M] [MulAction M β] : MulAction M (Germ l β) where
  -- Porting note: `rfl` required.
  one_smul f :=
    inductionOn f fun f => by
      norm_cast
      simp only [one_smul]
      

Proof state:
α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
l : Filter α
f✝¹ g h : α → β
M : Type u_5
N : Type u_6
R : Type u_7
inst✝¹ : Monoid M
inst✝ : MulAction M β
f✝ : Germ l β
f : α → β
⊢ f =ᶠ[l] f

Next tactic:
rfl
@[to_additive]
instance mulAction [Monoid M] [MulAction M β] : MulAction M (Germ l β) where
  -- Porting note: `rfl` required.
  one_smul f :=
    inductionOn f fun f => by
      norm_cast
      simp only [one_smul]
      rfl
  mul_smul c₁ c₂ f :=
    inductionOn f fun f => by
      

Proof state:
α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
l : Filter α
f✝¹ g h : α → β
M : Type u_5
N : Type u_6
R : Type u_7
inst✝¹ : Monoid M
inst✝ : MulAction M β
c₁ c₂ : M
f✝ : Germ l β
f : α → β
⊢ (c₁ * c₂) • ↑f = c₁ • c₂ • ↑f

Next tactic:
norm_cast
@[to_additive]
instance mulAction [Monoid M] [MulAction M β] : MulAction M (Germ l β) where
  -- Porting note: `rfl` required.
  one_smul f :=
    inductionOn f fun f => by
      norm_cast
      simp only [one_smul]
      rfl
  mul_smul c₁ c₂ f :=
    inductionOn f fun f => by
      norm_cast
      

Proof state:
α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
l : Filter α
f✝¹ g h : α → β
M : Type u_5
N : Type u_6
R : Type u_7
inst✝¹ : Monoid M
inst✝ : MulAction M β
c₁ c₂ : M
f✝ : Germ l β
f : α → β
⊢ (c₁ * c₂) • f =ᶠ[l] c₁ • c₂ • f

Next tactic:
simp only [mul_smul]
@[to_additive]
instance mulAction [Monoid M] [MulAction M β] : MulAction M (Germ l β) where
  -- Porting note: `rfl` required.
  one_smul f :=
    inductionOn f fun f => by
      norm_cast
      simp only [one_smul]
      rfl
  mul_smul c₁ c₂ f :=
    inductionOn f fun f => by
      norm_cast
      simp only [mul_smul]
      

Proof state:
α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
l : Filter α
f✝¹ g h : α → β
M : Type u_5
N : Type u_6
R : Type u_7
inst✝¹ : Monoid M
inst✝ : MulAction M β
c₁ c₂ : M
f✝ : Germ l β
f : α → β
⊢ c₁ • c₂ • f =ᶠ[l] c₁ • c₂ • f

Next tactic:
rfl
@[to_additive]
instance mulAction' [Monoid M] [MulAction M β] : MulAction (Germ l M) (Germ l β) where
  -- Porting note: `rfl` required.
  one_smul f := inductionOn f fun f => by 

Proof state:
α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
l : Filter α
f✝¹ g h : α → β
M : Type u_5
N : Type u_6
R : Type u_7
inst✝¹ : Monoid M
inst✝ : MulAction M β
f✝ : Germ l β
f : α → β
⊢ 1 • ↑f = ↑f

Next tactic:
simp only [← coe_one, ← coe_smul', one_smul]
@[to_additive]
instance mulAction' [Monoid M] [MulAction M β] : MulAction (Germ l M) (Germ l β) where
  -- Porting note: `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
      

Proof state:
α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
l : Filter α
f✝¹ g h : α → β
M : Type u_5
N : Type u_6
R : Type u_7
inst✝¹ : Monoid M
inst✝ : MulAction M β
c₁✝ c₂✝ : Germ l M
f✝ : Germ l β
c₁ c₂ : α → M
f : α → β
⊢ (↑c₁ * ↑c₂) • ↑f = ↑c₁ • ↑c₂ • ↑f

Next tactic:
norm_cast
@[to_additive]
instance mulAction' [Monoid M] [MulAction M β] : MulAction (Germ l M) (Germ l β) where
  -- Porting note: `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
      

Proof state:
α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
l : Filter α
f✝¹ g h : α → β
M : Type u_5
N : Type u_6
R : Type u_7
inst✝¹ : Monoid M
inst✝ : MulAction M β
c₁✝ c₂✝ : Germ l M
f✝ : Germ l β
c₁ c₂ : α → M
f : α → β
⊢ (c₁ * c₂) • f =ᶠ[l] c₁ • c₂ • f

Next tactic:
simp only [mul_smul]
@[to_additive]
instance mulAction' [Monoid M] [MulAction M β] : MulAction (Germ l M) (Germ l β) where
  -- Porting note: `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]
      

Proof state:
α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
l : Filter α
f✝¹ g h : α → β
M : Type u_5
N : Type u_6
R : Type u_7
inst✝¹ : Monoid M
inst✝ : MulAction M β
c₁✝ c₂✝ : Germ l M
f✝ : Germ l β
c₁ c₂ : α → M
f : α → β
⊢ c₁ • c₂ • f =ᶠ[l] c₁ • c₂ • f

Next tactic:
rfl
instance distribMulAction [Monoid M] [AddMonoid N] [DistribMulAction M N] :
    DistribMulAction M (Germ l N) where
  -- Porting note: `rfl` required.
  smul_add c f g :=
    inductionOn₂ f g fun f g => by
      norm_cast
      simp only [smul_add]
      rfl
  smul_zero c := by 

Proof state:
α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
l : Filter α
f g h : α → β
M : Type u_5
N : Type u_6
R : Type u_7
inst✝² : Monoid M
inst✝¹ : AddMonoid N
inst✝ : DistribMulAction M N
c : M
⊢ c • 0 = 0

Next tactic:
simp only [← coe_zero, ← coe_smul, smul_zero]
instance distribMulAction [Monoid M] [AddMonoid N] [DistribMulAction M N] :
    DistribMulAction M (Germ l N) where
  -- Porting note: `rfl` required.
  smul_add c f g :=
    inductionOn₂ f g fun f g => by
      

Proof state:
α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
l : Filter α
f✝¹ g✝¹ h : α → β
M : Type u_5
N : Type u_6
R : Type u_7
inst✝² : Monoid M
inst✝¹ : AddMonoid N
inst✝ : DistribMulAction M N
c : M
f✝ g✝ : Germ l N
f g : α → N
⊢ c • (↑f + ↑g) = c • ↑f + c • ↑g

Next tactic:
norm_cast
instance distribMulAction [Monoid M] [AddMonoid N] [DistribMulAction M N] :
    DistribMulAction M (Germ l N) where
  -- Porting note: `rfl` required.
  smul_add c f g :=
    inductionOn₂ f g fun f g => by
      norm_cast
      

Proof state:
α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
l : Filter α
f✝¹ g✝¹ h : α → β
M : Type u_5
N : Type u_6
R : Type u_7
inst✝² : Monoid M
inst✝¹ : AddMonoid N
inst✝ : DistribMulAction M N
c : M
f✝ g✝ : Germ l N
f g : α → N
⊢ c • (f + g) =ᶠ[l] c • f + c • g

Next tactic:
simp only [smul_add]
instance distribMulAction [Monoid M] [AddMonoid N] [DistribMulAction M N] :
    DistribMulAction M (Germ l N) where
  -- Porting note: `rfl` required.
  smul_add c f g :=
    inductionOn₂ f g fun f g => by
      norm_cast
      simp only [smul_add]
      

Proof state:
α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
l : Filter α
f✝¹ g✝¹ h : α → β
M : Type u_5
N : Type u_6
R : Type u_7
inst✝² : Monoid M
inst✝¹ : AddMonoid N
inst✝ : DistribMulAction M N
c : M
f✝ g✝ : Germ l N
f g : α → N
⊢ c • f + c • g =ᶠ[l] c • f + c • g

Next tactic:
rfl