File: Mathlib/Order/Filter/Germ/Basic.lean

full_name: Filter.const_eventuallyEq'
code: theorem const_eventuallyEq' [NeBot l] {a b : β} : (∀ᶠ _ in l, a = b) ↔ a = b 
goal: (∀ᶠ (x : α) in l, a = b) ↔ a = b

full_name: Filter.const_eventuallyEq
code: theorem const_eventuallyEq [NeBot l] {a b : β} : ((fun _ => a) =ᶠ[l] fun _ => b) ↔ a = b 
goal: ((fun x => a) =ᶠ[l] fun x => b) ↔ a = b

full_name: Filter.germSetoid
code: /-- Setoid used to define the space of germs. -/
def germSetoid (l : Filter α) (β : Type*) : Setoid (α → β) 
goal: Setoid (α → β)

full_name: Filter.Germ
code: /-- The space of germs of functions `α → β` at a filter `l`. -/
def Germ (l : Filter α) (β : Type*) : Type _ 
goal: Type (max u_1 u_5)

full_name: Filter.productSetoid
code: /-- Setoid used to define the filter product. This is a dependent version of
  `Filter.germSetoid`. -/
def productSetoid (l : Filter α) (ε : α → Type*) : Setoid ((a : _) → ε a) 
goal: Setoid ((a : α) → ε a)

full_name: Filter.Product
code: /-- 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 _ 
goal: Type (max u_1 u_5)

full_name: Filter.Product.coeTC
code: instance coeTC : CoeTC ((a : _) → ε a) (l.Product ε) 
goal: CoeTC ((a : α) → ε a) (l.Product ε)

full_name: Filter.Product.instInhabited
code: instance instInhabited [(a : _) → Inhabited (ε a)] : Inhabited (l.Product ε) 
goal: Inhabited (l.Product ε)

full_name: Filter.Germ.ofFun
code: @[coe]
def ofFun : (α → β) → (Germ l β) 
goal: (α → β) → l.Germ β

full_name: Filter.Germ.instCoeTCForall
code: instance : CoeTC (α → β) (Germ l β) 
goal: CoeTC (α → β) (l.Germ β)

full_name: Filter.Germ.const
code: @[coe] -- Porting note: removed `HasLiftT` instance
def const {l : Filter α} (b : β) : (Germ l β) 
goal: l.Germ β

full_name: Filter.Germ.coeTC
code: instance coeTC : CoeTC β (Germ l β) 
goal: CoeTC β (l.Germ β)

full_name: Filter.Germ.IsConstant
code: /-- A germ `P` of functions `α → β` is constant w.r.t. `l`. -/
def IsConstant {l : Filter α} (P : Germ l β) : Prop 
goal: Prop

full_name: Filter.Germ.isConstant_coe
code: theorem isConstant_coe {l : Filter α} {b} (h : ∀ x', f x' = b) : (↑f : Germ l β).IsConstant 
goal: (↑f).IsConstant

full_name: Filter.Germ.isConstant_coe_const
code: @[simp]
theorem isConstant_coe_const {l : Filter α} {b : β} : (fun _ : α ↦ b : Germ l β).IsConstant 
goal: (↑fun x => b).IsConstant

full_name: Filter.Germ.isConstant_comp
code: /-- 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 
goal: (↑(g ∘ f)).IsConstant

full_name: Filter.Germ.quot_mk_eq_coe
code: @[simp]
theorem quot_mk_eq_coe (l : Filter α) (f : α → β) : Quot.mk _ f = (f : Germ l β) 
goal: Quot.mk Setoid.r f = ↑f

full_name: Filter.Germ.mk'_eq_coe
code: @[simp]
theorem mk'_eq_coe (l : Filter α) (f : α → β) :
    @Quotient.mk' _ (germSetoid _ _) f = (f : Germ l β) 
goal: Quotient.mk' f = ↑f

full_name: Filter.Germ.inductionOn
code: @[elab_as_elim]
theorem inductionOn (f : Germ l β) {p : Germ l β → Prop} (h : ∀ f : α → β, p f) : p f 
goal: p f

full_name: Filter.Germ.inductionOn₂
code: @[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 
goal: p f g

full_name: Filter.Germ.inductionOn₃
code: @[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 
goal: p f g h

full_name: Filter.Germ.map'
code: /-- Given a map `F : (α → β) → (γ → δ)` that sends functions eventually equal at `l` to functions
eventually equal at `lc`, returns a map from `Germ l β` to `Germ lc δ`. -/
def map' {lc : Filter γ} (F : (α → β) → γ → δ) (hF : (l.EventuallyEq ⇒ lc.EventuallyEq) F F) :
    Germ l β → Germ lc δ 
goal: l.Germ β → lc.Germ δ

full_name: Filter.Germ.liftOn
code: /-- 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) :
    γ 
goal: γ

full_name: Filter.Germ.map'_coe
code: @[simp]
theorem map'_coe {lc : Filter γ} (F : (α → β) → γ → δ) (hF : (l.EventuallyEq ⇒ lc.EventuallyEq) F F)
    (f : α → β) : map' F hF f = F f 
goal: Filter.Germ.map' F hF ↑f = ↑(F f)

full_name: Filter.Germ.coe_eq
code: @[simp, norm_cast]
theorem coe_eq : (f : Germ l β) = g ↔ f =ᶠ[l] g 
goal: ↑f = ↑g ↔ f =ᶠ[l] g

full_name: Filter.Germ.map
code: /-- Lift a function `β → γ` to a function `Germ l β → Germ l γ`. -/
def map (op : β → γ) : Germ l β → Germ l γ 
goal: l.Germ β → l.Germ γ

full_name: Filter.Germ.map_coe
code: @[simp]
theorem map_coe (op : β → γ) (f : α → β) : map op (f : Germ l β) = op ∘ f 
goal: Filter.Germ.map op ↑f = ↑(op ∘ f)

full_name: Filter.Germ.map_id
code: @[simp]
theorem map_id : map id = (id : Germ l β → Germ l β) 
goal: Filter.Germ.map id = id

full_name: Filter.Germ.map_map
code: theorem map_map (op₁ : γ → δ) (op₂ : β → γ) (f : Germ l β) :
    map op₁ (map op₂ f) = map (op₁ ∘ op₂) f 
goal: Filter.Germ.map op₁ (Filter.Germ.map op₂ f) = Filter.Germ.map (op₁ ∘ op₂) f

full_name: Filter.Germ.map₂
code: /-- Lift a binary function `β → γ → δ` to a function `Germ l β → Germ l γ → Germ l δ`. -/
def map₂ (op : β → γ → δ) : Germ l β → Germ l γ → Germ l δ 
goal: l.Germ β → l.Germ γ → l.Germ δ

full_name: Filter.Germ.map₂_coe
code: @[simp]
theorem map₂_coe (op : β → γ → δ) (f : α → β) (g : α → γ) :
    map₂ op (f : Germ l β) g = fun x => op (f x) (g x) 
goal: Filter.Germ.map₂ op ↑f ↑g = ↑fun x => op (f x) (g x)

full_name: Filter.Germ.Tendsto
code: /-- A germ at `l` of maps from `α` to `β` tends to `lb : Filter β` if it is represented by a map
which tends to `lb` along `l`. -/
protected def Tendsto (f : Germ l β) (lb : Filter β) : Prop 
goal: Prop

full_name: Filter.Germ.coe_tendsto
code: @[simp, norm_cast]
theorem coe_tendsto {f : α → β} {lb : Filter β} : (f : Germ l β).Tendsto lb ↔ Tendsto f l lb 
goal: (↑f).Tendsto lb ↔ Filter.Tendsto f l lb

full_name: Filter.Germ.compTendsto'
code: /-- Given two germs `f : Germ l β`, and `g : Germ lc α`, where `l : Filter α`, if `g` tends to `l`,
then the composition `f ∘ g` is well-defined as a germ at `lc`. -/
def compTendsto' (f : Germ l β) {lc : Filter γ} (g : Germ lc α) (hg : g.Tendsto l) : Germ lc β 
goal: lc.Germ β

full_name: Filter.Germ.coe_compTendsto'
code: @[simp]
theorem coe_compTendsto' (f : α → β) {lc : Filter γ} {g : Germ lc α} (hg : g.Tendsto l) :
    (f : Germ l β).compTendsto' g hg = g.map f 
goal: (↑f).compTendsto' g hg = Filter.Germ.map f g

full_name: Filter.Germ.compTendsto
code: /-- Given a germ `f : Germ l β` and a function `g : γ → α`, where `l : Filter α`, if `g` tends
to `l` along `lc : Filter γ`, then the composition `f ∘ g` is well-defined as a germ at `lc`. -/
def compTendsto (f : Germ l β) {lc : Filter γ} (g : γ → α) (hg : Tendsto g lc l) : Germ lc β 
goal: lc.Germ β

full_name: Filter.Germ.coe_compTendsto
code: @[simp]
theorem coe_compTendsto (f : α → β) {lc : Filter γ} {g : γ → α} (hg : Tendsto g lc l) :
    (f : Germ l β).compTendsto g hg = f ∘ g 
goal: (↑f).compTendsto g hg = ↑(f ∘ g)

full_name: Filter.Germ.compTendsto'_coe
code: @[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 
goal: f.compTendsto' ↑g ⋯ = f.compTendsto g hg

full_name: Filter.Germ.Filter.Tendsto.congr_germ
code: theorem Filter.Tendsto.congr_germ {f g : β → γ} {l : Filter α} {l' : Filter β} (h : f =ᶠ[l'] g)
    {φ : α → β} (hφ : Tendsto φ l l') : (f ∘ φ : Germ l γ) = g ∘ φ 
goal: ↑(f ∘ φ) = ↑(g ∘ φ)

full_name: Filter.Germ.isConstant_comp_tendsto
code: lemma isConstant_comp_tendsto {lc : Filter γ} {g : γ → α}
    (hf : (f : Germ l β).IsConstant) (hg : Tendsto g lc l) : IsConstant (f ∘ g : Germ lc β) 
goal: (↑(f ∘ g)).IsConstant

full_name: Filter.Germ.isConstant_compTendsto
code: /-- 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 
goal: (f.compTendsto g hg).IsConstant

full_name: Filter.Germ.const_inj
code: @[simp, norm_cast]
theorem const_inj [NeBot l] {a b : β} : (↑a : Germ l β) = ↑b ↔ a = b 
goal: ↑a = ↑b ↔ a = b

full_name: Filter.Germ.map_const
code: @[simp]
theorem map_const (l : Filter α) (a : β) (f : β → γ) : (↑a : Germ l β).map f = ↑(f a) 
goal: Filter.Germ.map f ↑a = ↑(f a)

full_name: Filter.Germ.map₂_const
code: @[simp]
theorem map₂_const (l : Filter α) (b : β) (c : γ) (f : β → γ → δ) :
    map₂ f (↑b : Germ l β) ↑c = ↑(f b c) 
goal: Filter.Germ.map₂ f ↑b ↑c = ↑(f b c)

full_name: Filter.Germ.const_compTendsto
code: @[simp]
theorem const_compTendsto {l : Filter α} (b : β) {lc : Filter γ} {g : γ → α} (hg : Tendsto g lc l) :
    (↑b : Germ l β).compTendsto g hg = ↑b 
goal: (↑b).compTendsto g hg = ↑b

full_name: Filter.Germ.const_compTendsto'
code: @[simp]
theorem const_compTendsto' {l : Filter α} (b : β) {lc : Filter γ} {g : Germ lc α}
    (hg : g.Tendsto l) : (↑b : Germ l β).compTendsto' g hg = ↑b 
goal: (↑b).compTendsto' g hg = ↑b

full_name: Filter.Germ.LiftPred
code: /-- Lift a predicate on `β` to `Germ l β`. -/
def LiftPred (p : β → Prop) (f : Germ l β) : Prop 
goal: Prop

full_name: Filter.Germ.liftPred_coe
code: @[simp]
theorem liftPred_coe {p : β → Prop} {f : α → β} : LiftPred p (f : Germ l β) ↔ ∀ᶠ x in l, p (f x) 
goal: Filter.Germ.LiftPred p ↑f ↔ ∀ᶠ (x : α) in l, p (f x)

full_name: Filter.Germ.liftPred_const
code: theorem liftPred_const {p : β → Prop} {x : β} (hx : p x) : LiftPred p (↑x : Germ l β) 
goal: Filter.Germ.LiftPred p ↑x

full_name: Filter.Germ.liftPred_const_iff
code: @[simp]
theorem liftPred_const_iff [NeBot l] {p : β → Prop} {x : β} : LiftPred p (↑x : Germ l β) ↔ p x 
goal: Filter.Germ.LiftPred p ↑x ↔ p x

full_name: Filter.Germ.LiftRel
code: /-- Lift a relation `r : β → γ → Prop` to `Germ l β → Germ l γ → Prop`. -/
def LiftRel (r : β → γ → Prop) (f : Germ l β) (g : Germ l γ) : Prop 
goal: Prop

full_name: Filter.Germ.liftRel_coe
code: @[simp]
theorem liftRel_coe {r : β → γ → Prop} {f : α → β} {g : α → γ} :
    LiftRel r (f : Germ l β) g ↔ ∀ᶠ x in l, r (f x) (g x) 
goal: Filter.Germ.LiftRel r ↑f ↑g ↔ ∀ᶠ (x : α) in l, r (f x) (g x)

full_name: Filter.Germ.liftRel_const
code: theorem liftRel_const {r : β → γ → Prop} {x : β} {y : γ} (h : r x y) :
    LiftRel r (↑x : Germ l β) ↑y 
goal: Filter.Germ.LiftRel r ↑x ↑y

full_name: Filter.Germ.liftRel_const_iff
code: @[simp]
theorem liftRel_const_iff [NeBot l] {r : β → γ → Prop} {x : β} {y : γ} :
    LiftRel r (↑x : Germ l β) ↑y ↔ r x y 
goal: Filter.Germ.LiftRel r ↑x ↑y ↔ r x y

full_name: Filter.Germ.instInhabited
code: instance instInhabited [Inhabited β] : Inhabited (Germ l β) 
goal: Inhabited (l.Germ β)

full_name: Filter.Germ.instAdd
code: @[to_additive] instance instMul [Mul M] : Mul (Germ l M) 
goal: Add (l.Germ M)

full_name: Filter.Germ.instMul
code: @[to_additive] instance instMul [Mul M] : Mul (Germ l M) 
goal: Mul (l.Germ M)

full_name: Filter.Germ.coe_add
code: @[to_additive (attr := simp, norm_cast)]
theorem coe_mul [Mul M] (f g : α → M) : ↑(f * g) = (f * g : Germ l M) 
goal: ↑(f + g) = ↑f + ↑g

full_name: Filter.Germ.coe_mul
code: @[to_additive (attr := simp, norm_cast)]
theorem coe_mul [Mul M] (f g : α → M) : ↑(f * g) = (f * g : Germ l M) 
goal: ↑(f * g) = ↑f * ↑g

full_name: Filter.Germ.instZero
code: @[to_additive] instance instOne [One M] : One (Germ l M) 
goal: Zero (l.Germ M)

full_name: Filter.Germ.instOne
code: @[to_additive] instance instOne [One M] : One (Germ l M) 
goal: One (l.Germ M)

full_name: Filter.Germ.coe_zero
code: @[to_additive (attr := simp, norm_cast)]
theorem coe_one [One M] : ↑(1 : α → M) = (1 : Germ l M) 
goal: ↑0 = 0

full_name: Filter.Germ.coe_one
code: @[to_additive (attr := simp, norm_cast)]
theorem coe_one [One M] : ↑(1 : α → M) = (1 : Germ l M) 
goal: ↑1 = 1

full_name: Filter.Germ.instSemigroup
code: @[to_additive]
instance instSemigroup [Semigroup M] : Semigroup (Germ l M) 
goal: Semigroup (l.Germ M)

full_name: Filter.Germ.instAddSemigroup
code: @[to_additive]
instance instSemigroup [Semigroup M] : Semigroup (Germ l M) 
goal: AddSemigroup (l.Germ M)

full_name: Filter.Germ.instAddCommSemigroup
code: @[to_additive]
instance instCommSemigroup [CommSemigroup M] : CommSemigroup (Germ l M) 
goal: AddCommSemigroup (l.Germ M)

full_name: Filter.Germ.instCommSemigroup
code: @[to_additive]
instance instCommSemigroup [CommSemigroup M] : CommSemigroup (Germ l M) 
goal: CommSemigroup (l.Germ M)

full_name: Filter.Germ.instIsLeftCancelMul
code: @[to_additive]
instance instIsLeftCancelMul [Mul M] [IsLeftCancelMul M] : IsLeftCancelMul (Germ l M) 
goal: IsLeftCancelMul (l.Germ M)

full_name: Filter.Germ.instIsAddLeftCancel
code: @[to_additive]
instance instIsLeftCancelMul [Mul M] [IsLeftCancelMul M] : IsLeftCancelMul (Germ l M) 
goal: IsLeftCancelAdd (l.Germ M)

full_name: Filter.Germ.instIsRightCancelMul
code: @[to_additive]
instance instIsRightCancelMul [Mul M] [IsRightCancelMul M] : IsRightCancelMul (Germ l M) 
goal: IsRightCancelMul (l.Germ M)

full_name: Filter.Germ.instIsAddRightCancel
code: @[to_additive]
instance instIsRightCancelMul [Mul M] [IsRightCancelMul M] : IsRightCancelMul (Germ l M) 
goal: IsRightCancelAdd (l.Germ M)

full_name: Filter.Germ.instIsAddCancel
code: @[to_additive]
instance instIsCancelMul [Mul M] [IsCancelMul M] : IsCancelMul (Germ l M) 
goal: IsCancelAdd (l.Germ M)

full_name: Filter.Germ.instIsCancelMul
code: @[to_additive]
instance instIsCancelMul [Mul M] [IsCancelMul M] : IsCancelMul (Germ l M) 
goal: IsCancelMul (l.Germ M)

full_name: Filter.Germ.instAddLeftCancelSemigroup
code: @[to_additive]
instance instLeftCancelSemigroup [LeftCancelSemigroup M] : LeftCancelSemigroup (Germ l M) 
goal: AddLeftCancelSemigroup (l.Germ M)

full_name: Filter.Germ.instLeftCancelSemigroup
code: @[to_additive]
instance instLeftCancelSemigroup [LeftCancelSemigroup M] : LeftCancelSemigroup (Germ l M) 
goal: LeftCancelSemigroup (l.Germ M)

full_name: Filter.Germ.instAddRightCancelSemigroup
code: @[to_additive]
instance instRightCancelSemigroup [RightCancelSemigroup M] : RightCancelSemigroup (Germ l M) 
goal: AddRightCancelSemigroup (l.Germ M)

full_name: Filter.Germ.instRightCancelSemigroup
code: @[to_additive]
instance instRightCancelSemigroup [RightCancelSemigroup M] : RightCancelSemigroup (Germ l M) 
goal: RightCancelSemigroup (l.Germ M)

full_name: Filter.Germ.instMulOneClass
code: @[to_additive]
instance instMulOneClass [MulOneClass M] : MulOneClass (Germ l M) 
goal: MulOneClass (l.Germ M)

full_name: Filter.Germ.instAddZeroClass
code: @[to_additive]
instance instMulOneClass [MulOneClass M] : MulOneClass (Germ l M) 
goal: AddZeroClass (l.Germ M)

full_name: Filter.Germ.instVAdd
code: @[to_additive]
instance instSMul [SMul M G] : SMul M (Germ l G) 
goal: VAdd M (l.Germ G)

full_name: Filter.Germ.instSMul
code: @[to_additive]
instance instSMul [SMul M G] : SMul M (Germ l G) 
goal: SMul M (l.Germ G)

full_name: Filter.Germ.instPow
code: @[to_additive existing instSMul]
instance instPow [Pow G M] : Pow (Germ l G) M 
goal: Pow (l.Germ G) M

full_name: Filter.Germ.coe_vadd
code: @[to_additive (attr := simp, norm_cast)]
theorem coe_smul [SMul M G] (n : M) (f : α → G) : ↑(n • f) = n • (f : Germ l G) 
goal: ↑(n +ᵥ f) = n +ᵥ ↑f

full_name: Filter.Germ.coe_smul
code: @[to_additive (attr := simp, norm_cast)]
theorem coe_smul [SMul M G] (n : M) (f : α → G) : ↑(n • f) = n • (f : Germ l G) 
goal: ↑(n • f) = n • ↑f

full_name: Filter.Germ.const_smul
code: @[to_additive (attr := simp, norm_cast)]
theorem const_smul [SMul M G] (n : M) (a : G) : (↑(n • a) : Germ l G) = n • (↑a : Germ l G) 
goal: ↑(n • a) = n • ↑a

full_name: Filter.Germ.const_vadd
code: @[to_additive (attr := simp, norm_cast)]
theorem const_smul [SMul M G] (n : M) (a : G) : (↑(n • a) : Germ l G) = n • (↑a : Germ l G) 
goal: ↑(n +ᵥ a) = n +ᵥ ↑a

full_name: Filter.Germ.coe_pow
code: @[to_additive (attr := simp, norm_cast)]
theorem coe_pow [Pow G M] (f : α → G) (n : M) : ↑(f ^ n) = (f : Germ l G) ^ n 
goal: ↑(f ^ n) = ↑f ^ n

full_name: Filter.Germ.coe_nsmul
code: @[to_additive (attr := simp, norm_cast)]
theorem coe_pow [Pow G M] (f : α → G) (n : M) : ↑(f ^ n) = (f : Germ l G) ^ n 
goal: ↑(n • f) = n • ↑f

full_name: Filter.Germ.const_pow
code: @[to_additive (attr := simp, norm_cast)]
theorem const_pow [Pow G M] (a : G) (n : M) : (↑(a ^ n) : Germ l G) = (↑a : Germ l G) ^ n 
goal: ↑(a ^ n) = ↑a ^ n

full_name: Filter.Germ.const_nsmul
code: @[to_additive (attr := simp, norm_cast)]
theorem const_pow [Pow G M] (a : G) (n : M) : (↑(a ^ n) : Germ l G) = (↑a : Germ l G) ^ n 
goal: ↑(n • a) = n • ↑a

full_name: Filter.Germ.instMonoid
code: @[to_additive]
instance instMonoid [Monoid M] : Monoid (Germ l M) 
goal: Monoid (l.Germ M)

full_name: Filter.Germ.instAddMonoid
code: @[to_additive]
instance instMonoid [Monoid M] : Monoid (Germ l M) 
goal: AddMonoid (l.Germ M)

full_name: Filter.Germ.coeAddHom
code: /-- 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 
goal: (α → M) →+ l.Germ M

full_name: Filter.Germ.coeMulHom
code: /-- 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 
goal: (α → M) →* l.Germ M

full_name: Filter.Germ.coe_coeMulHom
code: @[to_additive (attr := simp)]
theorem coe_coeMulHom [Monoid M] : (coeMulHom l : (α → M) → Germ l M) = ofFun 
goal: ⇑(Filter.Germ.coeMulHom l) = Filter.Germ.ofFun

full_name: Filter.Germ.coe_coeAddHom
code: @[to_additive (attr := simp)]
theorem coe_coeMulHom [Monoid M] : (coeMulHom l : (α → M) → Germ l M) = ofFun 
goal: ⇑(Filter.Germ.coeAddHom l) = Filter.Germ.ofFun

full_name: Filter.Germ.instCommMonoid
code: @[to_additive]
instance instCommMonoid [CommMonoid M] : CommMonoid (Germ l M) 
goal: CommMonoid (l.Germ M)

full_name: Filter.Germ.instAddCommMonoid
code: @[to_additive]
instance instCommMonoid [CommMonoid M] : CommMonoid (Germ l M) 
goal: AddCommMonoid (l.Germ M)

full_name: Filter.Germ.instNatCast
code: instance instNatCast [NatCast M] : NatCast (Germ l M) 
goal: NatCast (l.Germ M)

full_name: Filter.Germ.natCast_def
code: @[simp]
theorem natCast_def [NatCast M] (n : ℕ) : ((fun _ ↦ n : α → M) : Germ l M) = n 
goal: (↑fun x => ↑n) = ↑n

full_name: Filter.Germ.const_nat
code: @[simp, norm_cast]
theorem const_nat [NatCast M] (n : ℕ) : ((n : M) : Germ l M) = n 
goal: ↑↑n = ↑n

full_name: Filter.Germ.coe_ofNat
code: @[simp, norm_cast]
theorem coe_ofNat [NatCast M] (n : ℕ) [n.AtLeastTwo] :
    ((no_index (OfNat.ofNat n : α → M)) : Germ l M) = OfNat.ofNat n 
goal: ↑(OfNat.ofNat n) = OfNat.ofNat n

full_name: Filter.Germ.const_ofNat
code: @[simp, norm_cast]
theorem const_ofNat [NatCast M] (n : ℕ) [n.AtLeastTwo] :
    ((no_index (OfNat.ofNat n : M)) : Germ l M) = OfNat.ofNat n 
goal: ↑(OfNat.ofNat n) = OfNat.ofNat n

full_name: Filter.Germ.instIntCast
code: instance instIntCast [IntCast M] : IntCast (Germ l M) 
goal: IntCast (l.Germ M)

full_name: Filter.Germ.intCast_def
code: @[simp]
theorem intCast_def [IntCast M] (n : ℤ) : ((fun _ ↦ n : α → M) : Germ l M) = n 
goal: (↑fun x => ↑n) = ↑n

full_name: Filter.Germ.instAddMonoidWithOne
code: instance instAddMonoidWithOne [AddMonoidWithOne M] : AddMonoidWithOne (Germ l M) 
goal: AddMonoidWithOne (l.Germ M)

full_name: Filter.Germ.instAddCommMonoidWithOne
code: instance instAddCommMonoidWithOne [AddCommMonoidWithOne M] : AddCommMonoidWithOne (Germ l M) 
goal: AddCommMonoidWithOne (l.Germ M)

full_name: Filter.Germ.instInv
code: @[to_additive] instance instInv [Inv G] : Inv (Germ l G) 
goal: Inv (l.Germ G)

full_name: Filter.Germ.instNeg
code: @[to_additive] instance instInv [Inv G] : Inv (Germ l G) 
goal: Neg (l.Germ G)

full_name: Filter.Germ.coe_neg
code: @[to_additive (attr := simp, norm_cast)]
theorem coe_inv [Inv G] (f : α → G) : ↑f⁻¹ = (f⁻¹ : Germ l G) 
goal: ↑(-f) = -↑f

full_name: Filter.Germ.coe_inv
code: @[to_additive (attr := simp, norm_cast)]
theorem coe_inv [Inv G] (f : α → G) : ↑f⁻¹ = (f⁻¹ : Germ l G) 
goal: ↑f⁻¹ = (↑f)⁻¹

full_name: Filter.Germ.const_neg
code: @[to_additive (attr := simp, norm_cast)]
theorem const_inv [Inv G] (a : G) : (↑(a⁻¹) : Germ l G) = (↑a)⁻¹ 
goal: ↑(-a) = -↑a

full_name: Filter.Germ.const_inv
code: @[to_additive (attr := simp, norm_cast)]
theorem const_inv [Inv G] (a : G) : (↑(a⁻¹) : Germ l G) = (↑a)⁻¹ 
goal: ↑a⁻¹ = (↑a)⁻¹

full_name: Filter.Germ.instDiv
code: @[to_additive] instance instDiv [Div M] : Div (Germ l M) 
goal: Div (l.Germ M)

full_name: Filter.Germ.instSub
code: @[to_additive] instance instDiv [Div M] : Div (Germ l M) 
goal: Sub (l.Germ M)

full_name: Filter.Germ.coe_div
code: @[to_additive (attr := simp, norm_cast)]
theorem coe_div [Div M] (f g : α → M) : ↑(f / g) = (f / g : Germ l M) 
goal: ↑(f / g) = ↑f / ↑g

full_name: Filter.Germ.coe_sub
code: @[to_additive (attr := simp, norm_cast)]
theorem coe_div [Div M] (f g : α → M) : ↑(f / g) = (f / g : Germ l M) 
goal: ↑(f - g) = ↑f - ↑g

full_name: Filter.Germ.const_sub
code: @[to_additive (attr := simp, norm_cast)]
theorem const_div [Div M] (a b : M) : (↑(a / b) : Germ l M) = ↑a / ↑b 
goal: ↑(a - b) = ↑a - ↑b

full_name: Filter.Germ.const_div
code: @[to_additive (attr := simp, norm_cast)]
theorem const_div [Div M] (a b : M) : (↑(a / b) : Germ l M) = ↑a / ↑b 
goal: ↑(a / b) = ↑a / ↑b

full_name: Filter.Germ.instInvolutiveInv
code: @[to_additive]
instance instInvolutiveInv [InvolutiveInv G] : InvolutiveInv (Germ l G) 
goal: InvolutiveInv (l.Germ G)

full_name: Filter.Germ.instInvolutiveNeg
code: @[to_additive]
instance instInvolutiveInv [InvolutiveInv G] : InvolutiveInv (Germ l G) 
goal: InvolutiveNeg (l.Germ G)

full_name: Filter.Germ.instHasDistribNeg
code: instance instHasDistribNeg [Mul G] [HasDistribNeg G] : HasDistribNeg (Germ l G) 
goal: HasDistribNeg (l.Germ G)

full_name: Filter.Germ.instInvOneClass
code: @[to_additive]
instance instInvOneClass [InvOneClass G] : InvOneClass (Germ l G) 
goal: InvOneClass (l.Germ G)

full_name: Filter.Germ.instNegZeroClass
code: @[to_additive]
instance instInvOneClass [InvOneClass G] : InvOneClass (Germ l G) 
goal: NegZeroClass (l.Germ G)

full_name: Filter.Germ.subNegMonoid
code: @[to_additive subNegMonoid]
instance instDivInvMonoid [DivInvMonoid G] : DivInvMonoid (Germ l G) 
goal: SubNegMonoid (l.Germ G)

full_name: Filter.Germ.instDivInvMonoid
code: @[to_additive subNegMonoid]
instance instDivInvMonoid [DivInvMonoid G] : DivInvMonoid (Germ l G) 
goal: DivInvMonoid (l.Germ G)

full_name: Filter.Germ.instDivisionAddMonoid
code: @[to_additive]
instance instDivisionMonoid [DivisionMonoid G] : DivisionMonoid (Germ l G) 
goal: SubtractionMonoid (l.Germ G)

full_name: Filter.Germ.instDivisionMonoid
code: @[to_additive]
instance instDivisionMonoid [DivisionMonoid G] : DivisionMonoid (Germ l G) 
goal: DivisionMonoid (l.Germ G)

full_name: Filter.Germ.instGroup
code: @[to_additive]
instance instGroup [Group G] : Group (Germ l G) 
goal: Group (l.Germ G)

full_name: Filter.Germ.instAddGroup
code: @[to_additive]
instance instGroup [Group G] : Group (Germ l G) 
goal: AddGroup (l.Germ G)

full_name: Filter.Germ.instCommGroup
code: @[to_additive]
instance instCommGroup [CommGroup G] : CommGroup (Germ l G) 
goal: CommGroup (l.Germ G)

full_name: Filter.Germ.instAddCommGroup
code: @[to_additive]
instance instCommGroup [CommGroup G] : CommGroup (Germ l G) 
goal: AddCommGroup (l.Germ G)

full_name: Filter.Germ.instAddGroupWithOne
code: instance instAddGroupWithOne [AddGroupWithOne G] : AddGroupWithOne (Germ l G) 
goal: AddGroupWithOne (l.Germ G)

full_name: Filter.Germ.instNontrivial
code: instance instNontrivial [Nontrivial R] [NeBot l] : Nontrivial (Germ l R) 
goal: Nontrivial (l.Germ R)

full_name: Filter.Germ.instMulZeroClass
code: instance instMulZeroClass [MulZeroClass R] : MulZeroClass (Germ l R) 
goal: MulZeroClass (l.Germ R)

full_name: Filter.Germ.instMulZeroOneClass
code: instance instMulZeroOneClass [MulZeroOneClass R] : MulZeroOneClass (Germ l R) 
goal: MulZeroOneClass (l.Germ R)

full_name: Filter.Germ.instMonoidWithZero
code: instance instMonoidWithZero [MonoidWithZero R] : MonoidWithZero (Germ l R) 
goal: MonoidWithZero (l.Germ R)

full_name: Filter.Germ.instDistrib
code: instance instDistrib [Distrib R] : Distrib (Germ l R) 
goal: Distrib (l.Germ R)

full_name: Filter.Germ.instNonUnitalNonAssocSemiring
code: instance instNonUnitalNonAssocSemiring [NonUnitalNonAssocSemiring R] :
    NonUnitalNonAssocSemiring (Germ l R) 
goal: NonUnitalNonAssocSemiring (l.Germ R)

full_name: Filter.Germ.instNonUnitalSemiring
code: instance instNonUnitalSemiring [NonUnitalSemiring R] : NonUnitalSemiring (Germ l R) 
goal: NonUnitalSemiring (l.Germ R)

full_name: Filter.Germ.instNonAssocSemiring
code: instance instNonAssocSemiring [NonAssocSemiring R] : NonAssocSemiring (Germ l R) 
goal: NonAssocSemiring (l.Germ R)

full_name: Filter.Germ.instNonUnitalNonAssocRing
code: instance instNonUnitalNonAssocRing [NonUnitalNonAssocRing R] :
    NonUnitalNonAssocRing (Germ l R) 
goal: NonUnitalNonAssocRing (l.Germ R)

full_name: Filter.Germ.instNonUnitalRing
code: instance instNonUnitalRing [NonUnitalRing R] : NonUnitalRing (Germ l R) 
goal: NonUnitalRing (l.Germ R)

full_name: Filter.Germ.instNonAssocRing
code: instance instNonAssocRing [NonAssocRing R] : NonAssocRing (Germ l R) 
goal: NonAssocRing (l.Germ R)

full_name: Filter.Germ.instSemiring
code: instance instSemiring [Semiring R] : Semiring (Germ l R) 
goal: Semiring (l.Germ R)

full_name: Filter.Germ.instRing
code: instance instRing [Ring R] : Ring (Germ l R) 
goal: Ring (l.Germ R)

full_name: Filter.Germ.instNonUnitalCommSemiring
code: instance instNonUnitalCommSemiring [NonUnitalCommSemiring R] :
    NonUnitalCommSemiring (Germ l R) 
goal: NonUnitalCommSemiring (l.Germ R)

full_name: Filter.Germ.instCommSemiring
code: instance instCommSemiring [CommSemiring R] : CommSemiring (Germ l R) 
goal: CommSemiring (l.Germ R)

full_name: Filter.Germ.instNonUnitalCommRing
code: instance instNonUnitalCommRing [NonUnitalCommRing R] : NonUnitalCommRing (Germ l R) 
goal: NonUnitalCommRing (l.Germ R)

full_name: Filter.Germ.instCommRing
code: instance instCommRing [CommRing R] : CommRing (Germ l R) 
goal: CommRing (l.Germ R)

full_name: Filter.Germ.coeRingHom
code: /-- Coercion `(α → R) → Germ l R` as a `RingHom`. -/
def coeRingHom [Semiring R] (l : Filter α) : (α → R) →+* Germ l R 
goal: (α → R) →+* l.Germ R

full_name: Filter.Germ.coe_coeRingHom
code: @[simp]
theorem coe_coeRingHom [Semiring R] : (coeRingHom l : (α → R) → Germ l R) = ofFun 
goal: ⇑(Filter.Germ.coeRingHom l) = Filter.Germ.ofFun

full_name: Filter.Germ.instVAdd'
code: @[to_additive]
instance instSMul' [SMul M β] : SMul (Germ l M) (Germ l β) 
goal: VAdd (l.Germ M) (l.Germ β)

full_name: Filter.Germ.instSMul'
code: @[to_additive]
instance instSMul' [SMul M β] : SMul (Germ l M) (Germ l β) 
goal: SMul (l.Germ M) (l.Germ β)

full_name: Filter.Germ.coe_vadd'
code: @[to_additive (attr := simp, norm_cast)]
theorem coe_smul' [SMul M β] (c : α → M) (f : α → β) : ↑(c • f) = (c : Germ l M) • (f : Germ l β) 
goal: ↑(c +ᵥ f) = ↑c +ᵥ ↑f

full_name: Filter.Germ.coe_smul'
code: @[to_additive (attr := simp, norm_cast)]
theorem coe_smul' [SMul M β] (c : α → M) (f : α → β) : ↑(c • f) = (c : Germ l M) • (f : Germ l β) 
goal: ↑(c • f) = ↑c • ↑f

full_name: Filter.Germ.instAddAction
code: @[to_additive]
instance instMulAction [Monoid M] [MulAction M β] : MulAction M (Germ l β) 
goal: AddAction M (l.Germ β)

full_name: Filter.Germ.instMulAction
code: @[to_additive]
instance instMulAction [Monoid M] [MulAction M β] : MulAction M (Germ l β) 
goal: MulAction M (l.Germ β)

full_name: Filter.Germ.instMulAction'
code: @[to_additive]
instance instMulAction' [Monoid M] [MulAction M β] : MulAction (Germ l M) (Germ l β) 
goal: MulAction (l.Germ M) (l.Germ β)

full_name: Filter.Germ.instAddAction'
code: @[to_additive]
instance instMulAction' [Monoid M] [MulAction M β] : MulAction (Germ l M) (Germ l β) 
goal: AddAction (l.Germ M) (l.Germ β)

full_name: Filter.Germ.instDistribMulAction
code: instance instDistribMulAction [Monoid M] [AddMonoid N] [DistribMulAction M N] :
    DistribMulAction M (Germ l N) 
goal: DistribMulAction M (l.Germ N)

full_name: Filter.Germ.instDistribMulAction'
code: instance instDistribMulAction' [Monoid M] [AddMonoid N] [DistribMulAction M N] :
    DistribMulAction (Germ l M) (Germ l N) 
goal: DistribMulAction (l.Germ M) (l.Germ N)

full_name: Filter.Germ.instModule
code: instance instModule [Semiring R] [AddCommMonoid M] [Module R M] : Module R (Germ l M) 
goal: Module R (l.Germ M)

full_name: Filter.Germ.instModule'
code: instance instModule' [Semiring R] [AddCommMonoid M] [Module R M] :
    Module (Germ l R) (Germ l M) 
goal: Module (l.Germ R) (l.Germ M)

full_name: Filter.Germ.instLE
code: instance instLE [LE β] : LE (Germ l β) 
goal: LE (l.Germ β)

full_name: Filter.Germ.le_def
code: theorem le_def [LE β] : ((· ≤ ·) : Germ l β → Germ l β → Prop) = LiftRel (· ≤ ·) 
goal: (fun x x_1 => x ≤ x_1) = Filter.Germ.LiftRel fun x x_1 => x ≤ x_1

full_name: Filter.Germ.coe_le
code: @[simp]
theorem coe_le [LE β] : (f : Germ l β) ≤ g ↔ f ≤ᶠ[l] g 
goal: ↑f ≤ ↑g ↔ f ≤ᶠ[l] g

full_name: Filter.Germ.coe_nonneg
code: theorem coe_nonneg [LE β] [Zero β] {f : α → β} : 0 ≤ (f : Germ l β) ↔ ∀ᶠ x in l, 0 ≤ f x 
goal: 0 ≤ ↑f ↔ ∀ᶠ (x : α) in l, 0 ≤ f x

full_name: Filter.Germ.const_le
code: theorem const_le [LE β] {x y : β} : x ≤ y → (↑x : Germ l β) ≤ ↑y 
goal: x ≤ y → ↑x ≤ ↑y

full_name: Filter.Germ.const_le_iff
code: @[simp, norm_cast]
theorem const_le_iff [LE β] [NeBot l] {x y : β} : (↑x : Germ l β) ≤ ↑y ↔ x ≤ y 
goal: ↑x ≤ ↑y ↔ x ≤ y

full_name: Filter.Germ.instPreorder
code: instance instPreorder [Preorder β] : Preorder (Germ l β) 
goal: Preorder (l.Germ β)

full_name: Filter.Germ.instPartialOrder
code: instance instPartialOrder [PartialOrder β] : PartialOrder (Germ l β) 
goal: PartialOrder (l.Germ β)

full_name: Filter.Germ.instBot
code: instance instBot [Bot β] : Bot (Germ l β) 
goal: Bot (l.Germ β)

full_name: Filter.Germ.instTop
code: instance instTop [Top β] : Top (Germ l β) 
goal: Top (l.Germ β)

full_name: Filter.Germ.const_bot
code: @[simp, norm_cast]
theorem const_bot [Bot β] : (↑(⊥ : β) : Germ l β) = ⊥ 
goal: ↑⊥ = ⊥

full_name: Filter.Germ.const_top
code: @[simp, norm_cast]
theorem const_top [Top β] : (↑(⊤ : β) : Germ l β) = ⊤ 
goal: ↑⊤ = ⊤

full_name: Filter.Germ.instOrderBot
code: instance instOrderBot [LE β] [OrderBot β] : OrderBot (Germ l β) 
goal: OrderBot (l.Germ β)

full_name: Filter.Germ.instOrderTop
code: instance instOrderTop [LE β] [OrderTop β] : OrderTop (Germ l β) 
goal: OrderTop (l.Germ β)

full_name: Filter.Germ.instBoundedOrder
code: instance instBoundedOrder [LE β] [BoundedOrder β] : BoundedOrder (Germ l β) 
goal: BoundedOrder (l.Germ β)

full_name: Filter.Germ.instSup
code: instance instSup [Sup β] : Sup (Germ l β) 
goal: Sup (l.Germ β)

full_name: Filter.Germ.instInf
code: instance instInf [Inf β] : Inf (Germ l β) 
goal: Inf (l.Germ β)

full_name: Filter.Germ.const_sup
code: @[simp, norm_cast]
theorem const_sup [Sup β] (a b : β) : ↑(a ⊔ b) = (↑a ⊔ ↑b : Germ l β) 
goal: ↑(a ⊔ b) = ↑a ⊔ ↑b

full_name: Filter.Germ.const_inf
code: @[simp, norm_cast]
theorem const_inf [Inf β] (a b : β) : ↑(a ⊓ b) = (↑a ⊓ ↑b : Germ l β) 
goal: ↑(a ⊓ b) = ↑a ⊓ ↑b

full_name: Filter.Germ.instSemilatticeSup
code: instance instSemilatticeSup [SemilatticeSup β] : SemilatticeSup (Germ l β) 
goal: SemilatticeSup (l.Germ β)

full_name: Filter.Germ.instSemilatticeInf
code: instance instSemilatticeInf [SemilatticeInf β] : SemilatticeInf (Germ l β) 
goal: SemilatticeInf (l.Germ β)

full_name: Filter.Germ.instLattice
code: instance instLattice [Lattice β] : Lattice (Germ l β) 
goal: Lattice (l.Germ β)

full_name: Filter.Germ.instDistribLattice
code: instance instDistribLattice [DistribLattice β] : DistribLattice (Germ l β) 
goal: DistribLattice (l.Germ β)

full_name: Filter.Germ.instExistsAddOfLE
code: @[to_additive]
instance instExistsMulOfLE [Mul β] [LE β] [ExistsMulOfLE β] : ExistsMulOfLE (Germ l β) 
goal: ExistsAddOfLE (l.Germ β)

full_name: Filter.Germ.instExistsMulOfLE
code: @[to_additive]
instance instExistsMulOfLE [Mul β] [LE β] [ExistsMulOfLE β] : ExistsMulOfLE (Germ l β) 
goal: ExistsMulOfLE (l.Germ β)