ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
-- Filter.Germ.const_pow
@[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 
Arguments: {α : Type u_1} {l : Filter α} {M : Type u_5} {G : Type u_6} [Pow G M] (a : G) (n : M)
Goal: ↑(a ^ n) = ↑a ^ n
-- Filter.Germ.const_nsmul
@[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 
Arguments: {α : Type u_1} {l : Filter α} {M : Type u_5} {G : Type u_6} [SMul M G] (a : G) (n : M)
Goal: ↑(n • a) = n • ↑a
-- Filter.Germ.coe_coeMulHom
@[to_additive (attr := simp)]
theorem coe_coeMulHom [Monoid M] : (coeMulHom l : (α → M) → Germ l M) = ofFun 
Arguments: {α : Type u_1} {l : Filter α} {M : Type u_5} [Monoid M]
Goal: ⇑(Filter.Germ.coeMulHom l) = Filter.Germ.ofFun
-- Filter.Germ.coe_coeAddHom
@[to_additive (attr := simp)]
theorem coe_coeMulHom [Monoid M] : (coeMulHom l : (α → M) → Germ l M) = ofFun 
Arguments: {α : Type u_1} {l : Filter α} {M : Type u_5} [AddMonoid M]
Goal: ⇑(Filter.Germ.coeAddHom l) = Filter.Germ.ofFun
-- Filter.Germ.natCast_def
@[simp]
theorem natCast_def [NatCast M] (n : ℕ) : ((fun _ ↦ n : α → M) : Germ l M) = n 
Arguments: {α : Type u_1} {l : Filter α} {M : Type u_5} [NatCast M] (n : ℕ)
Goal: (↑fun x => ↑n) = ↑n
-- Filter.Germ.const_nat
@[simp, norm_cast]
theorem const_nat [NatCast M] (n : ℕ) : ((n : M) : Germ l M) = n 
Arguments: {α : Type u_1} {l : Filter α} {M : Type u_5} [NatCast M] (n : ℕ)
Goal: ↑↑n = ↑n
-- Filter.Germ.coe_ofNat
@[simp, norm_cast]
theorem coe_ofNat [NatCast M] (n : ℕ) [n.AtLeastTwo] :
    ((no_index (OfNat.ofNat n : α → M)) : Germ l M) = OfNat.ofNat n 
Arguments: {α : Type u_1} {l : Filter α} {M : Type u_5} [NatCast M] (n : ℕ) [n.AtLeastTwo]
Goal: ↑(OfNat.ofNat n) = OfNat.ofNat n
-- Filter.Germ.const_ofNat
@[simp, norm_cast]
theorem const_ofNat [NatCast M] (n : ℕ) [n.AtLeastTwo] :
    ((no_index (OfNat.ofNat n : M)) : Germ l M) = OfNat.ofNat n 
Arguments: {α : Type u_1} {l : Filter α} {M : Type u_5} [NatCast M] (n : ℕ) [n.AtLeastTwo]
Goal: ↑(OfNat.ofNat n) = OfNat.ofNat n
-- Filter.Germ.intCast_def
@[simp]
theorem intCast_def [IntCast M] (n : ℤ) : ((fun _ ↦ n : α → M) : Germ l M) = n 
Arguments: {α : Type u_1} {l : Filter α} {M : Type u_5} [IntCast M] (n : ℤ)
Goal: (↑fun x => ↑n) = ↑n
-- Filter.Germ.coe_neg
@[to_additive (attr := simp, norm_cast)]
theorem coe_inv [Inv G] (f : α → G) : ↑f⁻¹ = (f⁻¹ : Germ l G) 
Arguments: {α : Type u_1} {l : Filter α} {G : Type u_6} [Neg G] (f : α → G)
Goal: ↑(-f) = -↑f
-- Filter.Germ.coe_inv
@[to_additive (attr := simp, norm_cast)]
theorem coe_inv [Inv G] (f : α → G) : ↑f⁻¹ = (f⁻¹ : Germ l G) 
Arguments: {α : Type u_1} {l : Filter α} {G : Type u_6} [Inv G] (f : α → G)
Goal: ↑f⁻¹ = (↑f)⁻¹
-- Filter.Germ.const_neg
@[to_additive (attr := simp, norm_cast)]
theorem const_inv [Inv G] (a : G) : (↑(a⁻¹) : Germ l G) = (↑a)⁻¹ 
Arguments: {α : Type u_1} {l : Filter α} {G : Type u_6} [Neg G] (a : G)
Goal: ↑(-a) = -↑a
-- Filter.Germ.const_inv
@[to_additive (attr := simp, norm_cast)]
theorem const_inv [Inv G] (a : G) : (↑(a⁻¹) : Germ l G) = (↑a)⁻¹ 
Arguments: {α : Type u_1} {l : Filter α} {G : Type u_6} [Inv G] (a : G)
Goal: ↑a⁻¹ = (↑a)⁻¹
-- Filter.Germ.coe_div
@[to_additive (attr := simp, norm_cast)]
theorem coe_div [Div M] (f g : α → M) : ↑(f / g) = (f / g : Germ l M) 
Arguments: {α : Type u_1} {l : Filter α} {M : Type u_5} [Div M] (f g : α → M)
Goal: ↑(f / g) = ↑f / ↑g
-- Filter.Germ.coe_sub
@[to_additive (attr := simp, norm_cast)]
theorem coe_div [Div M] (f g : α → M) : ↑(f / g) = (f / g : Germ l M) 
Arguments: {α : Type u_1} {l : Filter α} {M : Type u_5} [Sub M] (f g : α → M)
Goal: ↑(f - g) = ↑f - ↑g
-- Filter.Germ.const_sub
@[to_additive (attr := simp, norm_cast)]
theorem const_div [Div M] (a b : M) : (↑(a / b) : Germ l M) = ↑a / ↑b 
Arguments: {α : Type u_1} {l : Filter α} {M : Type u_5} [Sub M] (a b : M)
Goal: ↑(a - b) = ↑a - ↑b
-- Filter.Germ.const_div
@[to_additive (attr := simp, norm_cast)]
theorem const_div [Div M] (a b : M) : (↑(a / b) : Germ l M) = ↑a / ↑b 
Arguments: {α : Type u_1} {l : Filter α} {M : Type u_5} [Div M] (a b : M)
Goal: ↑(a / b) = ↑a / ↑b
-- Filter.Germ.coe_coeRingHom
@[simp]
theorem coe_coeRingHom [Semiring R] : (coeRingHom l : (α → R) → Germ l R) = ofFun 
Arguments: {α : Type u_1} {l : Filter α} {R : Type u_5} [Semiring R]
Goal: ⇑(Filter.Germ.coeRingHom l) = Filter.Germ.ofFun
-- Filter.Germ.coe_vadd'
@[to_additive (attr := simp, norm_cast)]
theorem coe_smul' [SMul M β] (c : α → M) (f : α → β) : ↑(c • f) = (c : Germ l M) • (f : Germ l β) 
Arguments: {α : Type u_1} {β : Type u_2} {l : Filter α} {M : Type u_5} [VAdd M β] (c : α → M) (f : α → β)
Goal: ↑(c +ᵥ f) = ↑c +ᵥ ↑f
-- Filter.Germ.coe_smul'
@[to_additive (attr := simp, norm_cast)]
theorem coe_smul' [SMul M β] (c : α → M) (f : α → β) : ↑(c • f) = (c : Germ l M) • (f : Germ l β) 
Arguments: {α : Type u_1} {β : Type u_2} {l : Filter α} {M : Type u_5} [SMul M β] (c : α → M) (f : α → β)
Goal: ↑(c • f) = ↑c • ↑f
-- Filter.Germ.le_def
theorem le_def [LE β] : ((· ≤ ·) : Germ l β → Germ l β → Prop) = LiftRel (· ≤ ·) 
Arguments: {α : Type u_1} {β : Type u_2} {l : Filter α} [LE β]
Goal: (fun x x_1 => x ≤ x_1) = Filter.Germ.LiftRel fun x x_1 => x ≤ x_1
-- Filter.Germ.coe_le
@[simp]
theorem coe_le [LE β] : (f : Germ l β) ≤ g ↔ f ≤ᶠ[l] g 
Arguments: {α : Type u_1} {β : Type u_2} {l : Filter α} {f g : α → β} [LE β]
Goal: ↑f ≤ ↑g ↔ f ≤ᶠ[l] g
-- Filter.Germ.coe_nonneg
theorem coe_nonneg [LE β] [Zero β] {f : α → β} : 0 ≤ (f : Germ l β) ↔ ∀ᶠ x in l, 0 ≤ f x 
Arguments: {α : Type u_1} {β : Type u_2} {l : Filter α} [LE β] [Zero β] {f : α → β}
Goal: 0 ≤ ↑f ↔ ∀ᶠ (x : α) in l, 0 ≤ f x
-- Filter.Germ.const_le
theorem const_le [LE β] {x y : β} : x ≤ y → (↑x : Germ l β) ≤ ↑y 
Arguments: {α : Type u_1} {β : Type u_2} {l : Filter α} [LE β] {x y : β}
Goal: x ≤ y → ↑x ≤ ↑y
-- Filter.Germ.const_le_iff
@[simp, norm_cast]
theorem const_le_iff [LE β] [NeBot l] {x y : β} : (↑x : Germ l β) ≤ ↑y ↔ x ≤ y 
Arguments: {α : Type u_1} {β : Type u_2} {l : Filter α} [LE β] [l.NeBot] {x y : β}
Goal: ↑x ≤ ↑y ↔ x ≤ y
-- Filter.Germ.const_bot
@[simp, norm_cast]
theorem const_bot [Bot β] : (↑(⊥ : β) : Germ l β) = ⊥ 
Arguments: {α : Type u_1} {β : Type u_2} {l : Filter α} [Bot β]
Goal: ↑⊥ = ⊥
-- Filter.Germ.const_top
@[simp, norm_cast]
theorem const_top [Top β] : (↑(⊤ : β) : Germ l β) = ⊤ 
Arguments: {α : Type u_1} {β : Type u_2} {l : Filter α} [Top β]
Goal: ↑⊤ = ⊤
-- Filter.Germ.const_sup
@[simp, norm_cast]
theorem const_sup [Sup β] (a b : β) : ↑(a ⊔ b) = (↑a ⊔ ↑b : Germ l β) 
Arguments: {α : Type u_1} {β : Type u_2} {l : Filter α} [Sup β] (a b : β)
Goal: ↑(a ⊔ b) = ↑a ⊔ ↑b
-- Filter.Germ.const_inf
@[simp, norm_cast]
theorem const_inf [Inf β] (a b : β) : ↑(a ⊓ b) = (↑a ⊓ ↑b : Germ l β) 
Arguments: {α : Type u_1} {β : Type u_2} {l : Filter α} [Inf β] (a b : β)
Goal: ↑(a ⊓ b) = ↑a ⊓ ↑b
-- Filter.HasBasis.eventuallyConst_iff
theorem HasBasis.eventuallyConst_iff {ι : Sort*} {p : ι → Prop} {s : ι → Set α}
    (h : l.HasBasis p s) : EventuallyConst f l ↔ ∃ i, p i ∧ ∀ x ∈ s i, ∀ y ∈ s i, f x = f y 
Arguments: {α : Type u_1} {β : Type u_2} {l : Filter α} {f : α → β} {ι : Sort u_5} {p : ι → Prop} {s : ι → Set α} (h : l.HasBasis p s)
Goal: Filter.EventuallyConst f l ↔ ∃ i, p i ∧ ∀ x ∈ s i, ∀ y ∈ s i, f x = f y
-- Filter.HasBasis.eventuallyConst_iff'
theorem HasBasis.eventuallyConst_iff' {ι : Sort*} {p : ι → Prop} {s : ι → Set α}
    {x : ι → α} (h : l.HasBasis p s) (hx : ∀ i, p i → x i ∈ s i) :
    EventuallyConst f l ↔ ∃ i, p i ∧ ∀ y ∈ s i, f y = f (x i) 
Arguments: {α : Type u_1} {β : Type u_2} {l : Filter α} {f : α → β} {ι : Sort u_5} {p : ι → Prop} {s : ι → Set α} {x : ι → α} (h : l.HasBasis p s) (hx : ∀ (i : ι), p i → x i ∈ s i)
Goal: Filter.EventuallyConst f l ↔ ∃ i, p i ∧ ∀ y ∈ s i, f y = f (x i)
-- Filter.eventuallyConst_iff_tendsto
lemma eventuallyConst_iff_tendsto [Nonempty β] :
    EventuallyConst f l ↔ ∃ x, Tendsto f l (pure x) 
Arguments: {α : Type u_1} {β : Type u_2} {l : Filter α} {f : α → β} [Nonempty β]
Goal: Filter.EventuallyConst f l ↔ ∃ x, Filter.Tendsto f l (pure x)
-- Filter.EventuallyConst.of_tendsto
theorem EventuallyConst.of_tendsto {x : β} (h : Tendsto f l (pure x)) : EventuallyConst f l 
Arguments: {α : Type u_1} {β : Type u_2} {l : Filter α} {f : α → β} {x : β} (h : Filter.Tendsto f l (pure x))
Goal: Filter.EventuallyConst f l
-- Filter.eventuallyConst_iff_exists_eventuallyEq
theorem eventuallyConst_iff_exists_eventuallyEq [Nonempty β] :
    EventuallyConst f l ↔ ∃ c, f =ᶠ[l] fun _ ↦ c 
Arguments: {α : Type u_1} {β : Type u_2} {l : Filter α} {f : α → β} [Nonempty β]
Goal: Filter.EventuallyConst f l ↔ ∃ c, f =ᶠ[l] fun x => c
-- Filter.eventuallyConst_pred'
theorem eventuallyConst_pred' {p : α → Prop} :
    EventuallyConst p l ↔ (p =ᶠ[l] fun _ ↦ False) ∨ (p =ᶠ[l] fun _ ↦ True) 
Arguments: {α : Type u_1} {l : Filter α} {p : α → Prop}
Goal: Filter.EventuallyConst p l ↔ (p =ᶠ[l] fun x => False) ∨ p =ᶠ[l] fun x => True
-- Filter.eventuallyConst_pred
theorem eventuallyConst_pred {p : α → Prop} :
    EventuallyConst p l ↔ (∀ᶠ x in l, p x) ∨ (∀ᶠ x in l, ¬p x) 
Arguments: {α : Type u_1} {l : Filter α} {p : α → Prop}
Goal: Filter.EventuallyConst p l ↔ (∀ᶠ (x : α) in l, p x) ∨ ∀ᶠ (x : α) in l, ¬p x
-- Filter.eventuallyConst_set'
theorem eventuallyConst_set' {s : Set α} :
    EventuallyConst s l ↔ (s =ᶠ[l] (∅ : Set α)) ∨ s =ᶠ[l] univ 
Arguments: {α : Type u_1} {l : Filter α} {s : Set α}
Goal: Filter.EventuallyConst s l ↔ s =ᶠ[l] ∅ ∨ s =ᶠ[l] Set.univ
-- Filter.eventuallyConst_set
theorem eventuallyConst_set {s : Set α} :
    EventuallyConst s l ↔ (∀ᶠ x in l, x ∈ s) ∨ (∀ᶠ x in l, x ∉ s) 
Arguments: {α : Type u_1} {l : Filter α} {s : Set α}
Goal: Filter.EventuallyConst s l ↔ (∀ᶠ (x : α) in l, x ∈ s) ∨ ∀ᶠ (x : α) in l, x ∉ s
-- Filter.eventuallyConst_preimage
theorem eventuallyConst_preimage {s : Set β} {f : α → β} :
    EventuallyConst (f ⁻¹' s) l ↔ EventuallyConst s (map f l) 
Arguments: {α : Type u_1} {β : Type u_2} {l : Filter α} {s : Set β} {f : α → β}
Goal: Filter.EventuallyConst (f ⁻¹' s) l ↔ Filter.EventuallyConst s (Filter.map f l)
-- Filter.EventuallyEq.eventuallyConst_iff
theorem EventuallyEq.eventuallyConst_iff {g : α → β} (h : f =ᶠ[l] g) :
    EventuallyConst f l ↔ EventuallyConst g l 
Arguments: {α : Type u_1} {β : Type u_2} {l : Filter α} {f g : α → β} (h : f =ᶠ[l] g)
Goal: Filter.EventuallyConst f l ↔ Filter.EventuallyConst g l
-- Filter.eventuallyConst_id
@[simp] theorem eventuallyConst_id : EventuallyConst id l ↔ l.Subsingleton 
Arguments: {α : Type u_1} {l : Filter α}
Goal: Filter.EventuallyConst id l ↔ l.Subsingleton
-- Filter.EventuallyConst.bot
@[simp] protected lemma bot : EventuallyConst f ⊥ 
Arguments: {α : Type u_1} {β : Type u_2} {f : α → β}
Goal: Filter.EventuallyConst f ⊥
-- Filter.EventuallyConst.const
@[simp]
protected lemma const (c : β) : EventuallyConst (fun _ ↦ c) l 
Arguments: {α : Type u_1} {β : Type u_2} {l : Filter α} (c : β)
Goal: Filter.EventuallyConst (fun x => c) l
-- Filter.EventuallyConst.congr
protected lemma congr {g} (h : EventuallyConst f l) (hg : f =ᶠ[l] g) : EventuallyConst g l 
Arguments: {α : Type u_1} {β : Type u_2} {l : Filter α} {f g : α → β} (h : Filter.EventuallyConst f l) (hg : f =ᶠ[l] g)
Goal: Filter.EventuallyConst g l
-- Filter.EventuallyConst.of_subsingleton_right
@[nontriviality]
lemma of_subsingleton_right [Subsingleton β] : EventuallyConst f l 
Arguments: {α : Type u_1} {β : Type u_2} {l : Filter α} {f : α → β} [Subsingleton β]
Goal: Filter.EventuallyConst f l
-- Filter.EventuallyConst.anti
nonrec lemma anti {l'} (h : EventuallyConst f l) (hl' : l' ≤ l) : EventuallyConst f l' 
Arguments: {α : Type u_1} {β : Type u_2} {l : Filter α} {f : α → β} {l' : Filter α} (h : Filter.EventuallyConst f l) (hl' : l' ≤ l)
Goal: Filter.EventuallyConst f l'
-- Filter.EventuallyConst.of_subsingleton_left
@[nontriviality]
lemma of_subsingleton_left [Subsingleton α] : EventuallyConst f l 
Arguments: {α : Type u_1} {β : Type u_2} {l : Filter α} {f : α → β} [Subsingleton α]
Goal: Filter.EventuallyConst f l
-- Filter.EventuallyConst.comp
lemma comp (h : EventuallyConst f l) (g : β → γ) : EventuallyConst (g ∘ f) l 
Arguments: {α : Type u_1} {β : Type u_2} {γ : Type u_3} {l : Filter α} {f : α → β} (h : Filter.EventuallyConst f l) (g : β → γ)
Goal: Filter.EventuallyConst (g ∘ f) l
-- Filter.EventuallyConst.neg
@[to_additive]
protected lemma inv [Inv β] (h : EventuallyConst f l) : EventuallyConst (f⁻¹) l 
Arguments: {α : Type u_1} {β : Type u_2} {l : Filter α} {f : α → β} [Neg β] (h : Filter.EventuallyConst f l)
Goal: Filter.EventuallyConst (-f) l
-- Filter.EventuallyConst.inv
@[to_additive]
protected lemma inv [Inv β] (h : EventuallyConst f l) : EventuallyConst (f⁻¹) l 
Arguments: {α : Type u_1} {β : Type u_2} {l : Filter α} {f : α → β} [Inv β] (h : Filter.EventuallyConst f l)
Goal: Filter.EventuallyConst f⁻¹ l
-- Filter.EventuallyConst.comp_tendsto
lemma comp_tendsto {lb : Filter β} {g : β → γ} (hg : EventuallyConst g lb)
    (hf : Tendsto f l lb) : EventuallyConst (g ∘ f) l 
Arguments: {α : Type u_1} {β : Type u_2} {γ : Type u_3} {l : Filter α} {f : α → β} {lb : Filter β} {g : β → γ} (hg : Filter.EventuallyConst g lb) (hf : Filter.Tendsto f l lb)
Goal: Filter.EventuallyConst (g ∘ f) l
-- Filter.EventuallyConst.apply
lemma apply {ι : Type*} {p : ι → Type*} {g : α → ∀ x, p x}
    (h : EventuallyConst g l) (i : ι) : EventuallyConst (g · i) l 
Arguments: {α : Type u_1} {l : Filter α} {ι : Type u_5} {p : ι → Type u_6} {g : α → (x : ι) → p x} (h : Filter.EventuallyConst g l) (i : ι)
Goal: Filter.EventuallyConst (fun x => g x i) l
-- Filter.EventuallyConst.comp₂
lemma comp₂ {g : α → γ} (hf : EventuallyConst f l) (op : β → γ → δ) (hg : EventuallyConst g l) :
    EventuallyConst (fun x ↦ op (f x) (g x)) l 
Arguments: {α : Type u_1} {β : Type u_2} {γ : Type u_3} {δ : Type u_4} {l : Filter α} {f : α → β} {g : α → γ} (hf : Filter.EventuallyConst f l) (op : β → γ → δ) (hg : Filter.EventuallyConst g l)
Goal: Filter.EventuallyConst (fun x => op (f x) (g x)) l
-- Filter.EventuallyConst.prod_mk
lemma prod_mk {g : α → γ} (hf : EventuallyConst f l) (hg : EventuallyConst g l) :
    EventuallyConst (fun x ↦ (f x, g x)) l 
Arguments: {α : Type u_1} {β : Type u_2} {γ : Type u_3} {l : Filter α} {f : α → β} {g : α → γ} (hf : Filter.EventuallyConst f l) (hg : Filter.EventuallyConst g l)
Goal: Filter.EventuallyConst (fun x => (f x, g x)) l
-- Filter.EventuallyConst.mul
@[to_additive]
lemma mul [Mul β] {g : α → β} (hf : EventuallyConst f l) (hg : EventuallyConst g l) :
    EventuallyConst (f * g) l 
Arguments: {α : Type u_1} {β : Type u_2} {l : Filter α} {f : α → β} [Mul β] {g : α → β} (hf : Filter.EventuallyConst f l) (hg : Filter.EventuallyConst g l)
Goal: Filter.EventuallyConst (f * g) l
-- Filter.EventuallyConst.add
@[to_additive]
lemma mul [Mul β] {g : α → β} (hf : EventuallyConst f l) (hg : EventuallyConst g l) :
    EventuallyConst (f * g) l 
Arguments: {α : Type u_1} {β : Type u_2} {l : Filter α} {f : α → β} [Add β] {g : α → β} (hf : Filter.EventuallyConst f l) (hg : Filter.EventuallyConst g l)
Goal: Filter.EventuallyConst (f + g) l
-- Filter.EventuallyConst.of_indicator_const
@[to_additive]
lemma of_mulIndicator_const (h : EventuallyConst (s.mulIndicator fun _ ↦ c) l) (hc : c ≠ 1) :
    EventuallyConst s l 
Arguments: {α : Type u_1} {β : Type u_2} {l : Filter α} [Zero β] {s : Set α} {c : β} (h : Filter.EventuallyConst (s.indicator fun x => c) l) (hc : c ≠ 0)
Goal: Filter.EventuallyConst s l
-- Filter.EventuallyConst.of_mulIndicator_const
@[to_additive]
lemma of_mulIndicator_const (h : EventuallyConst (s.mulIndicator fun _ ↦ c) l) (hc : c ≠ 1) :
    EventuallyConst s l 
Arguments: {α : Type u_1} {β : Type u_2} {l : Filter α} [One β] {s : Set α} {c : β} (h : Filter.EventuallyConst (s.mulIndicator fun x => c) l) (hc : c ≠ 1)
Goal: Filter.EventuallyConst s l
-- Filter.EventuallyConst.indicator_const
@[to_additive]
theorem mulIndicator_const (h : EventuallyConst s l) (c : β) :
    EventuallyConst (s.mulIndicator fun _ ↦ c) l 
Arguments: {α : Type u_1} {β : Type u_2} {l : Filter α} [Zero β] {s : Set α} (h : Filter.EventuallyConst s l) (c : β)
Goal: Filter.EventuallyConst (s.indicator fun x => c) l
-- Filter.EventuallyConst.mulIndicator_const
@[to_additive]
theorem mulIndicator_const (h : EventuallyConst s l) (c : β) :
    EventuallyConst (s.mulIndicator fun _ ↦ c) l 
Arguments: {α : Type u_1} {β : Type u_2} {l : Filter α} [One β] {s : Set α} (h : Filter.EventuallyConst s l) (c : β)
Goal: Filter.EventuallyConst (s.mulIndicator fun x => c) l
-- Filter.EventuallyConst.indicator_const_iff_of_ne
@[to_additive]
theorem mulIndicator_const_iff_of_ne (hc : c ≠ 1) :
    EventuallyConst (s.mulIndicator fun _ ↦ c) l ↔ EventuallyConst s l 
Arguments: {α : Type u_1} {β : Type u_2} {l : Filter α} [Zero β] {s : Set α} {c : β} (hc : c ≠ 0)
Goal: Filter.EventuallyConst (s.indicator fun x => c) l ↔ Filter.EventuallyConst s l
-- Filter.EventuallyConst.mulIndicator_const_iff_of_ne
@[to_additive]
theorem mulIndicator_const_iff_of_ne (hc : c ≠ 1) :
    EventuallyConst (s.mulIndicator fun _ ↦ c) l ↔ EventuallyConst s l 
Arguments: {α : Type u_1} {β : Type u_2} {l : Filter α} [One β] {s : Set α} {c : β} (hc : c ≠ 1)
Goal: Filter.EventuallyConst (s.mulIndicator fun x => c) l ↔ Filter.EventuallyConst s l
-- Filter.EventuallyConst.mulIndicator_const_iff
@[to_additive (attr := simp)]
theorem mulIndicator_const_iff :
    EventuallyConst (s.mulIndicator fun _ ↦ c) l ↔ c = 1 ∨ EventuallyConst s l 
Arguments: {α : Type u_1} {β : Type u_2} {l : Filter α} [One β] {s : Set α} {c : β}
Goal: Filter.EventuallyConst (s.mulIndicator fun x => c) l ↔ c = 1 ∨ Filter.EventuallyConst s l
-- Filter.EventuallyConst.indicator_const_iff
@[to_additive (attr := simp)]
theorem mulIndicator_const_iff :
    EventuallyConst (s.mulIndicator fun _ ↦ c) l ↔ c = 1 ∨ EventuallyConst s l 
Arguments: {α : Type u_1} {β : Type u_2} {l : Filter α} [Zero β] {s : Set α} {c : β}
Goal: Filter.EventuallyConst (s.indicator fun x => c) l ↔ c = 0 ∨ Filter.EventuallyConst s l
-- Filter.eventuallyConst_atTop
lemma eventuallyConst_atTop [SemilatticeSup α] [Nonempty α] :
    EventuallyConst f atTop ↔ (∃ i, ∀ j, i ≤ j → f j = f i) 
Arguments: {α : Type u_1} {β : Type u_2} {f : α → β} [SemilatticeSup α] [Nonempty α]
Goal: Filter.EventuallyConst f Filter.atTop ↔ ∃ i, ∀ (j : α), i ≤ j → f j = f i
-- Filter.eventuallyConst_atTop_nat
lemma eventuallyConst_atTop_nat {f : ℕ → α} :
    EventuallyConst f atTop ↔ ∃ n, ∀ m, n ≤ m → f (m + 1) = f m 
Arguments: {α : Type u_1} {f : ℕ → α}
Goal: Filter.EventuallyConst f Filter.atTop ↔ ∃ n, ∀ (m : ℕ), n ≤ m → f (m + 1) = f m
-- SupHom.map_sup'
structure SupHom (α β : Type*) [Sup α] [Sup β] where
    toFun : α → β
    map_sup' (a b : α) : toFun (a ⊔ b) = toFun a ⊔ toFun b
Arguments: {α : Type u_7} {β : Type u_8} [Sup α] [Sup β] (self : SupHom α β) (a b : α)
Goal: self.toFun (a ⊔ b) = self.toFun a ⊔ self.toFun b
-- InfHom.map_inf'
structure InfHom (α β : Type*) [Inf α] [Inf β] where
    toFun : α → β
    map_inf' (a b : α) : toFun (a ⊓ b) = toFun a ⊓ toFun b
Arguments: {α : Type u_7} {β : Type u_8} [Inf α] [Inf β] (self : InfHom α β) (a b : α)
Goal: self.toFun (a ⊓ b) = self.toFun a ⊓ self.toFun b
-- SupBotHom.map_bot'
structure SupBotHom (α β : Type*) [Sup α] [Sup β] [Bot α] [Bot β] extends SupHom α β where
    map_bot' : toFun ⊥ = ⊥
Arguments: {α : Type u_7} {β : Type u_8} [Sup α] [Sup β] [Bot α] [Bot β] (self : SupBotHom α β)
Goal: self.toFun ⊥ = ⊥
-- InfTopHom.map_top'
structure InfTopHom (α β : Type*) [Inf α] [Inf β] [Top α] [Top β] extends InfHom α β where
    map_top' : toFun ⊤ = ⊤
Arguments: {α : Type u_7} {β : Type u_8} [Inf α] [Inf β] [Top α] [Top β] (self : InfTopHom α β)
Goal: self.toFun ⊤ = ⊤
-- LatticeHom.map_inf'
structure LatticeHom (α β : Type*) [Lattice α] [Lattice β] extends SupHom α β where
    map_inf' (a b : α) : toFun (a ⊓ b) = toFun a ⊓ toFun b
Arguments: {α : Type u_7} {β : Type u_8} [Lattice α] [Lattice β] (self : LatticeHom α β) (a b : α)
Goal: self.toFun (a ⊓ b) = self.toFun a ⊓ self.toFun b
-- BoundedLatticeHom.map_top'
structure BoundedLatticeHom (α β : Type*) [Lattice α] [Lattice β] [BoundedOrder α]
  [BoundedOrder β] extends LatticeHom α β where
    map_top' : toFun ⊤ = ⊤
    map_bot' : toFun ⊥ = ⊥
Arguments: {α : Type u_7} {β : Type u_8} [Lattice α] [Lattice β] [BoundedOrder α] [BoundedOrder β] (self : BoundedLatticeHom α β)
Goal: self.toFun ⊤ = ⊤
-- BoundedLatticeHom.map_bot'
structure BoundedLatticeHom (α β : Type*) [Lattice α] [Lattice β] [BoundedOrder α]
  [BoundedOrder β] extends LatticeHom α β where
    map_top' : toFun ⊤ = ⊤
    map_bot' : toFun ⊥ = ⊥
Arguments: {α : Type u_7} {β : Type u_8} [Lattice α] [Lattice β] [BoundedOrder α] [BoundedOrder β] (self : BoundedLatticeHom α β)
Goal: self.toFun ⊥ = ⊥
-- SupHomClass.map_sup
class SupHomClass (F α β : Type*) [Sup α] [Sup β] [FunLike F α β] : Prop where
    map_sup (f : F) (a b : α) : f (a ⊔ b) = f a ⊔ f b
Arguments: {F : Type u_7} {α : Type u_8} {β : Type u_9} [Sup α] [Sup β] [FunLike F α β] [self : SupHomClass F α β] (f : F) (a b : α)
Goal: f (a ⊔ b) = f a ⊔ f b
-- InfHomClass.map_inf
class InfHomClass (F α β : Type*) [Inf α] [Inf β] [FunLike F α β] : Prop where
    map_inf (f : F) (a b : α) : f (a ⊓ b) = f a ⊓ f b
Arguments: {F : Type u_7} {α : Type u_8} {β : Type u_9} [Inf α] [Inf β] [FunLike F α β] [self : InfHomClass F α β] (f : F) (a b : α)
Goal: f (a ⊓ b) = f a ⊓ f b
-- SupBotHomClass.map_bot
class SupBotHomClass (F α β : Type*) [Sup α] [Sup β] [Bot α] [Bot β] [FunLike F α β]
  extends SupHomClass F α β : Prop where
    map_bot (f : F) : f ⊥ = ⊥
Arguments: {F : Type u_7} {α : Type u_8} {β : Type u_9} [Sup α] [Sup β] [Bot α] [Bot β] [FunLike F α β] [self : SupBotHomClass F α β] (f : F)
Goal: f ⊥ = ⊥
-- InfTopHomClass.map_top
class InfTopHomClass (F α β : Type*) [Inf α] [Inf β] [Top α] [Top β] [FunLike F α β]
  extends InfHomClass F α β : Prop where
    map_top (f : F) : f ⊤ = ⊤
Arguments: {F : Type u_7} {α : Type u_8} {β : Type u_9} [Inf α] [Inf β] [Top α] [Top β] [FunLike F α β] [self : InfTopHomClass F α β] (f : F)
Goal: f ⊤ = ⊤
-- LatticeHomClass.map_inf
class LatticeHomClass (F α β : Type*) [Lattice α] [Lattice β] [FunLike F α β]
  extends SupHomClass F α β : Prop where
    map_inf (f : F) (a b : α) : f (a ⊓ b) = f a ⊓ f b
Arguments: {F : Type u_7} {α : Type u_8} {β : Type u_9} [Lattice α] [Lattice β] [FunLike F α β] [self : LatticeHomClass F α β] (f : F) (a b : α)
Goal: f (a ⊓ b) = f a ⊓ f b
-- BoundedLatticeHomClass.map_top
class BoundedLatticeHomClass (F α β : Type*) [Lattice α] [Lattice β] [BoundedOrder α]
  [BoundedOrder β] [FunLike F α β] extends LatticeHomClass F α β : Prop where
    map_top (f : F) : f ⊤ = ⊤
    map_bot (f : F) : f ⊥ = ⊥
Arguments: {F : Type u_7} {α : Type u_8} {β : Type u_9} [Lattice α] [Lattice β] [BoundedOrder α] [BoundedOrder β] [FunLike F α β] [self : BoundedLatticeHomClass F α β] (f : F)
Goal: f ⊤ = ⊤
-- BoundedLatticeHomClass.map_bot
class BoundedLatticeHomClass (F α β : Type*) [Lattice α] [Lattice β] [BoundedOrder α]
  [BoundedOrder β] [FunLike F α β] extends LatticeHomClass F α β : Prop where
    map_top (f : F) : f ⊤ = ⊤
    map_bot (f : F) : f ⊥ = ⊥
Arguments: {F : Type u_7} {α : Type u_8} {β : Type u_9} [Lattice α] [Lattice β] [BoundedOrder α] [BoundedOrder β] [FunLike F α β] [self : BoundedLatticeHomClass F α β] (f : F)
Goal: f ⊥ = ⊥
-- orderEmbeddingOfInjective_apply
@[simps! apply]
def orderEmbeddingOfInjective [SemilatticeInf α] [SemilatticeInf β] (f : F) [InfHomClass F α β]
    (hf : Injective f) : α ↪o β 
Arguments: {F : Type u_1} {α : Type u_3} {β : Type u_4} [FunLike F α β] [SemilatticeInf α] [SemilatticeInf β] (f : F) [InfHomClass F α β] (hf : Function.Injective ⇑f) (a : α)
Goal: (orderEmbeddingOfInjective f hf) a = f a
-- Disjoint.map
theorem Disjoint.map (h : Disjoint a b) : Disjoint (f a) (f b) 
Arguments: {F : Type u_1} {α : Type u_3} {β : Type u_4} [Lattice α] [BoundedOrder α] [Lattice β] [BoundedOrder β] [FunLike F α β] [BoundedLatticeHomClass F α β] (f : F) {a b : α} (h : Disjoint a b)
Goal: Disjoint (f a) (f b)
-- Codisjoint.map
theorem Codisjoint.map (h : Codisjoint a b) : Codisjoint (f a) (f b) 
Arguments: {F : Type u_1} {α : Type u_3} {β : Type u_4} [Lattice α] [BoundedOrder α] [Lattice β] [BoundedOrder β] [FunLike F α β] [BoundedLatticeHomClass F α β] (f : F) {a b : α} (h : Codisjoint a b)
Goal: Codisjoint (f a) (f b)