File: Mathlib/Order/Filter/EventuallyConst.lean

full_name: Filter.EventuallyConst
code: /-- The proposition that a function is eventually constant along a filter on the domain. -/
def EventuallyConst (f : α → β) (l : Filter α) : Prop 
goal: Prop

full_name: Filter.HasBasis.eventuallyConst_iff
code: 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 
goal: Filter.EventuallyConst f l ↔ ∃ i, p i ∧ ∀ x ∈ s i, ∀ y ∈ s i, f x = f y

full_name: Filter.HasBasis.eventuallyConst_iff'
code: 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) 
goal: Filter.EventuallyConst f l ↔ ∃ i, p i ∧ ∀ y ∈ s i, f y = f (x i)

full_name: Filter.eventuallyConst_iff_tendsto
code: lemma eventuallyConst_iff_tendsto [Nonempty β] :
    EventuallyConst f l ↔ ∃ x, Tendsto f l (pure x) 
goal: Filter.EventuallyConst f l ↔ ∃ x, Filter.Tendsto f l (pure x)

full_name: Filter.EventuallyConst.of_tendsto
code: theorem EventuallyConst.of_tendsto {x : β} (h : Tendsto f l (pure x)) : EventuallyConst f l 
goal: Filter.EventuallyConst f l

full_name: Filter.eventuallyConst_iff_exists_eventuallyEq
code: theorem eventuallyConst_iff_exists_eventuallyEq [Nonempty β] :
    EventuallyConst f l ↔ ∃ c, f =ᶠ[l] fun _ ↦ c 
goal: Filter.EventuallyConst f l ↔ ∃ c, f =ᶠ[l] fun x => c

full_name: Filter.eventuallyConst_pred'
code: theorem eventuallyConst_pred' {p : α → Prop} :
    EventuallyConst p l ↔ (p =ᶠ[l] fun _ ↦ False) ∨ (p =ᶠ[l] fun _ ↦ True) 
goal: Filter.EventuallyConst p l ↔ (p =ᶠ[l] fun x => False) ∨ p =ᶠ[l] fun x => True

full_name: Filter.eventuallyConst_pred
code: theorem eventuallyConst_pred {p : α → Prop} :
    EventuallyConst p l ↔ (∀ᶠ x in l, p x) ∨ (∀ᶠ x in l, ¬p x) 
goal: Filter.EventuallyConst p l ↔ (∀ᶠ (x : α) in l, p x) ∨ ∀ᶠ (x : α) in l, ¬p x

full_name: Filter.eventuallyConst_set'
code: theorem eventuallyConst_set' {s : Set α} :
    EventuallyConst s l ↔ (s =ᶠ[l] (∅ : Set α)) ∨ s =ᶠ[l] univ 
goal: Filter.EventuallyConst s l ↔ s =ᶠ[l] ∅ ∨ s =ᶠ[l] Set.univ

full_name: Filter.eventuallyConst_set
code: theorem eventuallyConst_set {s : Set α} :
    EventuallyConst s l ↔ (∀ᶠ x in l, x ∈ s) ∨ (∀ᶠ x in l, x ∉ s) 
goal: Filter.EventuallyConst s l ↔ (∀ᶠ (x : α) in l, x ∈ s) ∨ ∀ᶠ (x : α) in l, x ∉ s

full_name: Filter.eventuallyConst_preimage
code: theorem eventuallyConst_preimage {s : Set β} {f : α → β} :
    EventuallyConst (f ⁻¹' s) l ↔ EventuallyConst s (map f l) 
goal: Filter.EventuallyConst (f ⁻¹' s) l ↔ Filter.EventuallyConst s (Filter.map f l)

full_name: Filter.EventuallyEq.eventuallyConst_iff
code: theorem EventuallyEq.eventuallyConst_iff {g : α → β} (h : f =ᶠ[l] g) :
    EventuallyConst f l ↔ EventuallyConst g l 
goal: Filter.EventuallyConst f l ↔ Filter.EventuallyConst g l

full_name: Filter.eventuallyConst_id
code: @[simp] theorem eventuallyConst_id : EventuallyConst id l ↔ l.Subsingleton 
goal: Filter.EventuallyConst id l ↔ l.Subsingleton

full_name: Filter.EventuallyConst.bot
code: @[simp] protected lemma bot : EventuallyConst f ⊥ 
goal: Filter.EventuallyConst f ⊥

full_name: Filter.EventuallyConst.const
code: @[simp]
protected lemma const (c : β) : EventuallyConst (fun _ ↦ c) l 
goal: Filter.EventuallyConst (fun x => c) l

full_name: Filter.EventuallyConst.congr
code: protected lemma congr {g} (h : EventuallyConst f l) (hg : f =ᶠ[l] g) : EventuallyConst g l 
goal: Filter.EventuallyConst g l

full_name: Filter.EventuallyConst.of_subsingleton_right
code: @[nontriviality]
lemma of_subsingleton_right [Subsingleton β] : EventuallyConst f l 
goal: Filter.EventuallyConst f l

full_name: Filter.EventuallyConst.anti
code: nonrec lemma anti {l'} (h : EventuallyConst f l) (hl' : l' ≤ l) : EventuallyConst f l' 
goal: Filter.EventuallyConst f l'

full_name: Filter.EventuallyConst.of_subsingleton_left
code: @[nontriviality]
lemma of_subsingleton_left [Subsingleton α] : EventuallyConst f l 
goal: Filter.EventuallyConst f l

full_name: Filter.EventuallyConst.comp
code: lemma comp (h : EventuallyConst f l) (g : β → γ) : EventuallyConst (g ∘ f) l 
goal: Filter.EventuallyConst (g ∘ f) l

full_name: Filter.EventuallyConst.neg
code: @[to_additive]
protected lemma inv [Inv β] (h : EventuallyConst f l) : EventuallyConst (f⁻¹) l 
goal: Filter.EventuallyConst (-f) l

full_name: Filter.EventuallyConst.inv
code: @[to_additive]
protected lemma inv [Inv β] (h : EventuallyConst f l) : EventuallyConst (f⁻¹) l 
goal: Filter.EventuallyConst f⁻¹ l

full_name: Filter.EventuallyConst.comp_tendsto
code: lemma comp_tendsto {lb : Filter β} {g : β → γ} (hg : EventuallyConst g lb)
    (hf : Tendsto f l lb) : EventuallyConst (g ∘ f) l 
goal: Filter.EventuallyConst (g ∘ f) l

full_name: Filter.EventuallyConst.apply
code: lemma apply {ι : Type*} {p : ι → Type*} {g : α → ∀ x, p x}
    (h : EventuallyConst g l) (i : ι) : EventuallyConst (g · i) l 
goal: Filter.EventuallyConst (fun x => g x i) l

full_name: Filter.EventuallyConst.comp₂
code: lemma comp₂ {g : α → γ} (hf : EventuallyConst f l) (op : β → γ → δ) (hg : EventuallyConst g l) :
    EventuallyConst (fun x ↦ op (f x) (g x)) l 
goal: Filter.EventuallyConst (fun x => op (f x) (g x)) l

full_name: Filter.EventuallyConst.prod_mk
code: lemma prod_mk {g : α → γ} (hf : EventuallyConst f l) (hg : EventuallyConst g l) :
    EventuallyConst (fun x ↦ (f x, g x)) l 
goal: Filter.EventuallyConst (fun x => (f x, g x)) l

full_name: Filter.EventuallyConst.mul
code: @[to_additive]
lemma mul [Mul β] {g : α → β} (hf : EventuallyConst f l) (hg : EventuallyConst g l) :
    EventuallyConst (f * g) l 
goal: Filter.EventuallyConst (f * g) l

full_name: Filter.EventuallyConst.add
code: @[to_additive]
lemma mul [Mul β] {g : α → β} (hf : EventuallyConst f l) (hg : EventuallyConst g l) :
    EventuallyConst (f * g) l 
goal: Filter.EventuallyConst (f + g) l

full_name: Filter.EventuallyConst.of_indicator_const
code: @[to_additive]
lemma of_mulIndicator_const (h : EventuallyConst (s.mulIndicator fun _ ↦ c) l) (hc : c ≠ 1) :
    EventuallyConst s l 
goal: Filter.EventuallyConst s l

full_name: Filter.EventuallyConst.of_mulIndicator_const
code: @[to_additive]
lemma of_mulIndicator_const (h : EventuallyConst (s.mulIndicator fun _ ↦ c) l) (hc : c ≠ 1) :
    EventuallyConst s l 
goal: Filter.EventuallyConst s l

full_name: Filter.EventuallyConst.indicator_const
code: @[to_additive]
theorem mulIndicator_const (h : EventuallyConst s l) (c : β) :
    EventuallyConst (s.mulIndicator fun _ ↦ c) l 
goal: Filter.EventuallyConst (s.indicator fun x => c) l

full_name: Filter.EventuallyConst.mulIndicator_const
code: @[to_additive]
theorem mulIndicator_const (h : EventuallyConst s l) (c : β) :
    EventuallyConst (s.mulIndicator fun _ ↦ c) l 
goal: Filter.EventuallyConst (s.mulIndicator fun x => c) l

full_name: Filter.EventuallyConst.indicator_const_iff_of_ne
code: @[to_additive]
theorem mulIndicator_const_iff_of_ne (hc : c ≠ 1) :
    EventuallyConst (s.mulIndicator fun _ ↦ c) l ↔ EventuallyConst s l 
goal: Filter.EventuallyConst (s.indicator fun x => c) l ↔ Filter.EventuallyConst s l

full_name: Filter.EventuallyConst.mulIndicator_const_iff_of_ne
code: @[to_additive]
theorem mulIndicator_const_iff_of_ne (hc : c ≠ 1) :
    EventuallyConst (s.mulIndicator fun _ ↦ c) l ↔ EventuallyConst s l 
goal: Filter.EventuallyConst (s.mulIndicator fun x => c) l ↔ Filter.EventuallyConst s l

full_name: Filter.EventuallyConst.mulIndicator_const_iff
code: @[to_additive (attr := simp)]
theorem mulIndicator_const_iff :
    EventuallyConst (s.mulIndicator fun _ ↦ c) l ↔ c = 1 ∨ EventuallyConst s l 
goal: Filter.EventuallyConst (s.mulIndicator fun x => c) l ↔ c = 1 ∨ Filter.EventuallyConst s l

full_name: Filter.EventuallyConst.indicator_const_iff
code: @[to_additive (attr := simp)]
theorem mulIndicator_const_iff :
    EventuallyConst (s.mulIndicator fun _ ↦ c) l ↔ c = 1 ∨ EventuallyConst s l 
goal: Filter.EventuallyConst (s.indicator fun x => c) l ↔ c = 0 ∨ Filter.EventuallyConst s l

full_name: Filter.eventuallyConst_atTop
code: lemma eventuallyConst_atTop [SemilatticeSup α] [Nonempty α] :
    EventuallyConst f atTop ↔ (∃ i, ∀ j, i ≤ j → f j = f i) 
goal: Filter.EventuallyConst f Filter.atTop ↔ ∃ i, ∀ (j : α), i ≤ j → f j = f i

full_name: Filter.eventuallyConst_atTop_nat
code: lemma eventuallyConst_atTop_nat {f : ℕ → α} :
    EventuallyConst f atTop ↔ ∃ n, ∀ m, n ≤ m → f (m + 1) = f m 
goal: Filter.EventuallyConst f Filter.atTop ↔ ∃ n, ∀ (m : ℕ), n ≤ m → f (m + 1) = f m