File: Mathlib/Order/Filter/Extr.lean

full_name: IsMinFilter
code: /-- `IsMinFilter f l a` means that `f a ≤ f x` for all `x` in some `l`-neighborhood of `a` -/
def IsMinFilter : Prop 
goal: Prop

full_name: IsMaxFilter
code: /-- `is_maxFilter f l a` means that `f x ≤ f a` for all `x` in some `l`-neighborhood of `a` -/
def IsMaxFilter : Prop 
goal: Prop

full_name: IsExtrFilter
code: /-- `IsExtrFilter f l a` means `IsMinFilter f l a` or `IsMaxFilter f l a` -/
def IsExtrFilter : Prop 
goal: Prop

full_name: IsMinOn
code: /-- `IsMinOn f s a` means that `f a ≤ f x` for all `x ∈ s`. Note that we do not assume `a ∈ s`. -/
def IsMinOn 
goal: Prop

full_name: IsMaxOn
code: /-- `IsMaxOn f s a` means that `f x ≤ f a` for all `x ∈ s`. Note that we do not assume `a ∈ s`. -/
def IsMaxOn 
goal: Prop

full_name: IsExtrOn
code: /-- `IsExtrOn f s a` means `IsMinOn f s a` or `IsMaxOn f s a` -/
def IsExtrOn : Prop 
goal: Prop

full_name: IsExtrOn.elim
code: theorem IsExtrOn.elim {p : Prop} : IsExtrOn f s a → (IsMinOn f s a → p) → (IsMaxOn f s a → p) → p 
goal: IsExtrOn f s a → (IsMinOn f s a → p) → (IsMaxOn f s a → p) → p

full_name: isMinOn_iff
code: theorem isMinOn_iff : IsMinOn f s a ↔ ∀ x ∈ s, f a ≤ f x 
goal: IsMinOn f s a ↔ ∀ x ∈ s, f a ≤ f x

full_name: isMaxOn_iff
code: theorem isMaxOn_iff : IsMaxOn f s a ↔ ∀ x ∈ s, f x ≤ f a 
goal: IsMaxOn f s a ↔ ∀ x ∈ s, f x ≤ f a

full_name: isMinOn_univ_iff
code: theorem isMinOn_univ_iff : IsMinOn f univ a ↔ ∀ x, f a ≤ f x 
goal: IsMinOn f Set.univ a ↔ ∀ (x : α), f a ≤ f x

full_name: isMaxOn_univ_iff
code: theorem isMaxOn_univ_iff : IsMaxOn f univ a ↔ ∀ x, f x ≤ f a 
goal: IsMaxOn f Set.univ a ↔ ∀ (x : α), f x ≤ f a

full_name: IsMinFilter.tendsto_principal_Ici
code: theorem IsMinFilter.tendsto_principal_Ici (h : IsMinFilter f l a) : Tendsto f l (𝓟 <| Ici (f a)) 
goal: Filter.Tendsto f l (𝓟 (Set.Ici (f a)))

full_name: IsMaxFilter.tendsto_principal_Iic
code: theorem IsMaxFilter.tendsto_principal_Iic (h : IsMaxFilter f l a) : Tendsto f l (𝓟 <| Iic (f a)) 
goal: Filter.Tendsto f l (𝓟 (Set.Iic (f a)))

full_name: IsMinFilter.isExtr
code: theorem IsMinFilter.isExtr : IsMinFilter f l a → IsExtrFilter f l a 
goal: IsMinFilter f l a → IsExtrFilter f l a

full_name: IsMaxFilter.isExtr
code: theorem IsMaxFilter.isExtr : IsMaxFilter f l a → IsExtrFilter f l a 
goal: IsMaxFilter f l a → IsExtrFilter f l a

full_name: IsMinOn.isExtr
code: theorem IsMinOn.isExtr (h : IsMinOn f s a) : IsExtrOn f s a 
goal: IsExtrOn f s a

full_name: IsMaxOn.isExtr
code: theorem IsMaxOn.isExtr (h : IsMaxOn f s a) : IsExtrOn f s a 
goal: IsExtrOn f s a

full_name: isMinFilter_const
code: theorem isMinFilter_const {b : β} : IsMinFilter (fun _ => b) l a 
goal: IsMinFilter (fun x => b) l a

full_name: isMaxFilter_const
code: theorem isMaxFilter_const {b : β} : IsMaxFilter (fun _ => b) l a 
goal: IsMaxFilter (fun x => b) l a

full_name: isExtrFilter_const
code: theorem isExtrFilter_const {b : β} : IsExtrFilter (fun _ => b) l a 
goal: IsExtrFilter (fun x => b) l a

full_name: isMinOn_const
code: theorem isMinOn_const {b : β} : IsMinOn (fun _ => b) s a 
goal: IsMinOn (fun x => b) s a

full_name: isMaxOn_const
code: theorem isMaxOn_const {b : β} : IsMaxOn (fun _ => b) s a 
goal: IsMaxOn (fun x => b) s a

full_name: isExtrOn_const
code: theorem isExtrOn_const {b : β} : IsExtrOn (fun _ => b) s a 
goal: IsExtrOn (fun x => b) s a

full_name: isMinFilter_dual_iff
code: theorem isMinFilter_dual_iff : IsMinFilter (toDual ∘ f) l a ↔ IsMaxFilter f l a 
goal: IsMinFilter (⇑OrderDual.toDual ∘ f) l a ↔ IsMaxFilter f l a

full_name: isMaxFilter_dual_iff
code: theorem isMaxFilter_dual_iff : IsMaxFilter (toDual ∘ f) l a ↔ IsMinFilter f l a 
goal: IsMaxFilter (⇑OrderDual.toDual ∘ f) l a ↔ IsMinFilter f l a

full_name: isExtrFilter_dual_iff
code: theorem isExtrFilter_dual_iff : IsExtrFilter (toDual ∘ f) l a ↔ IsExtrFilter f l a 
goal: IsExtrFilter (⇑OrderDual.toDual ∘ f) l a ↔ IsExtrFilter f l a

full_name: isMinOn_dual_iff
code: theorem isMinOn_dual_iff : IsMinOn (toDual ∘ f) s a ↔ IsMaxOn f s a 
goal: IsMinOn (⇑OrderDual.toDual ∘ f) s a ↔ IsMaxOn f s a

full_name: isMaxOn_dual_iff
code: theorem isMaxOn_dual_iff : IsMaxOn (toDual ∘ f) s a ↔ IsMinOn f s a 
goal: IsMaxOn (⇑OrderDual.toDual ∘ f) s a ↔ IsMinOn f s a

full_name: isExtrOn_dual_iff
code: theorem isExtrOn_dual_iff : IsExtrOn (toDual ∘ f) s a ↔ IsExtrOn f s a 
goal: IsExtrOn (⇑OrderDual.toDual ∘ f) s a ↔ IsExtrOn f s a

full_name: IsMinFilter.filter_mono
code: theorem IsMinFilter.filter_mono (h : IsMinFilter f l a) (hl : l' ≤ l) : IsMinFilter f l' a 
goal: IsMinFilter f l' a

full_name: IsMaxFilter.filter_mono
code: theorem IsMaxFilter.filter_mono (h : IsMaxFilter f l a) (hl : l' ≤ l) : IsMaxFilter f l' a 
goal: IsMaxFilter f l' a

full_name: IsExtrFilter.filter_mono
code: theorem IsExtrFilter.filter_mono (h : IsExtrFilter f l a) (hl : l' ≤ l) : IsExtrFilter f l' a 
goal: IsExtrFilter f l' a

full_name: IsMinFilter.filter_inf
code: theorem IsMinFilter.filter_inf (h : IsMinFilter f l a) (l') : IsMinFilter f (l ⊓ l') a 
goal: IsMinFilter f (l ⊓ l') a

full_name: IsMaxFilter.filter_inf
code: theorem IsMaxFilter.filter_inf (h : IsMaxFilter f l a) (l') : IsMaxFilter f (l ⊓ l') a 
goal: IsMaxFilter f (l ⊓ l') a

full_name: IsExtrFilter.filter_inf
code: theorem IsExtrFilter.filter_inf (h : IsExtrFilter f l a) (l') : IsExtrFilter f (l ⊓ l') a 
goal: IsExtrFilter f (l ⊓ l') a

full_name: IsMinOn.on_subset
code: theorem IsMinOn.on_subset (hf : IsMinOn f t a) (h : s ⊆ t) : IsMinOn f s a 
goal: IsMinOn f s a

full_name: IsMaxOn.on_subset
code: theorem IsMaxOn.on_subset (hf : IsMaxOn f t a) (h : s ⊆ t) : IsMaxOn f s a 
goal: IsMaxOn f s a

full_name: IsExtrOn.on_subset
code: theorem IsExtrOn.on_subset (hf : IsExtrOn f t a) (h : s ⊆ t) : IsExtrOn f s a 
goal: IsExtrOn f s a

full_name: IsMinOn.inter
code: theorem IsMinOn.inter (hf : IsMinOn f s a) (t) : IsMinOn f (s ∩ t) a 
goal: IsMinOn f (s ∩ t) a

full_name: IsMaxOn.inter
code: theorem IsMaxOn.inter (hf : IsMaxOn f s a) (t) : IsMaxOn f (s ∩ t) a 
goal: IsMaxOn f (s ∩ t) a

full_name: IsExtrOn.inter
code: theorem IsExtrOn.inter (hf : IsExtrOn f s a) (t) : IsExtrOn f (s ∩ t) a 
goal: IsExtrOn f (s ∩ t) a

full_name: IsMinFilter.comp_mono
code: theorem IsMinFilter.comp_mono (hf : IsMinFilter f l a) {g : β → γ} (hg : Monotone g) :
    IsMinFilter (g ∘ f) l a 
goal: IsMinFilter (g ∘ f) l a

full_name: IsMaxFilter.comp_mono
code: theorem IsMaxFilter.comp_mono (hf : IsMaxFilter f l a) {g : β → γ} (hg : Monotone g) :
    IsMaxFilter (g ∘ f) l a 
goal: IsMaxFilter (g ∘ f) l a

full_name: IsExtrFilter.comp_mono
code: theorem IsExtrFilter.comp_mono (hf : IsExtrFilter f l a) {g : β → γ} (hg : Monotone g) :
    IsExtrFilter (g ∘ f) l a 
goal: IsExtrFilter (g ∘ f) l a

full_name: IsMinFilter.comp_antitone
code: theorem IsMinFilter.comp_antitone (hf : IsMinFilter f l a) {g : β → γ} (hg : Antitone g) :
    IsMaxFilter (g ∘ f) l a 
goal: IsMaxFilter (g ∘ f) l a

full_name: IsMaxFilter.comp_antitone
code: theorem IsMaxFilter.comp_antitone (hf : IsMaxFilter f l a) {g : β → γ} (hg : Antitone g) :
    IsMinFilter (g ∘ f) l a 
goal: IsMinFilter (g ∘ f) l a

full_name: IsExtrFilter.comp_antitone
code: theorem IsExtrFilter.comp_antitone (hf : IsExtrFilter f l a) {g : β → γ} (hg : Antitone g) :
    IsExtrFilter (g ∘ f) l a 
goal: IsExtrFilter (g ∘ f) l a

full_name: IsMinOn.comp_mono
code: theorem IsMinOn.comp_mono (hf : IsMinOn f s a) {g : β → γ} (hg : Monotone g) :
    IsMinOn (g ∘ f) s a 
goal: IsMinOn (g ∘ f) s a

full_name: IsMaxOn.comp_mono
code: theorem IsMaxOn.comp_mono (hf : IsMaxOn f s a) {g : β → γ} (hg : Monotone g) :
    IsMaxOn (g ∘ f) s a 
goal: IsMaxOn (g ∘ f) s a

full_name: IsExtrOn.comp_mono
code: theorem IsExtrOn.comp_mono (hf : IsExtrOn f s a) {g : β → γ} (hg : Monotone g) :
    IsExtrOn (g ∘ f) s a 
goal: IsExtrOn (g ∘ f) s a

full_name: IsMinOn.comp_antitone
code: theorem IsMinOn.comp_antitone (hf : IsMinOn f s a) {g : β → γ} (hg : Antitone g) :
    IsMaxOn (g ∘ f) s a 
goal: IsMaxOn (g ∘ f) s a

full_name: IsMaxOn.comp_antitone
code: theorem IsMaxOn.comp_antitone (hf : IsMaxOn f s a) {g : β → γ} (hg : Antitone g) :
    IsMinOn (g ∘ f) s a 
goal: IsMinOn (g ∘ f) s a

full_name: IsExtrOn.comp_antitone
code: theorem IsExtrOn.comp_antitone (hf : IsExtrOn f s a) {g : β → γ} (hg : Antitone g) :
    IsExtrOn (g ∘ f) s a 
goal: IsExtrOn (g ∘ f) s a

full_name: IsMinFilter.bicomp_mono
code: theorem IsMinFilter.bicomp_mono [Preorder δ] {op : β → γ → δ}
    (hop : ((· ≤ ·) ⇒ (· ≤ ·) ⇒ (· ≤ ·)) op op) (hf : IsMinFilter f l a) {g : α → γ}
    (hg : IsMinFilter g l a) : IsMinFilter (fun x => op (f x) (g x)) l a 
goal: IsMinFilter (fun x => op (f x) (g x)) l a

full_name: IsMaxFilter.bicomp_mono
code: theorem IsMaxFilter.bicomp_mono [Preorder δ] {op : β → γ → δ}
    (hop : ((· ≤ ·) ⇒ (· ≤ ·) ⇒ (· ≤ ·)) op op) (hf : IsMaxFilter f l a) {g : α → γ}
    (hg : IsMaxFilter g l a) : IsMaxFilter (fun x => op (f x) (g x)) l a 
goal: IsMaxFilter (fun x => op (f x) (g x)) l a

full_name: IsMinOn.bicomp_mono
code: theorem IsMinOn.bicomp_mono [Preorder δ] {op : β → γ → δ}
    (hop : ((· ≤ ·) ⇒ (· ≤ ·) ⇒ (· ≤ ·)) op op) (hf : IsMinOn f s a) {g : α → γ}
    (hg : IsMinOn g s a) : IsMinOn (fun x => op (f x) (g x)) s a 
goal: IsMinOn (fun x => op (f x) (g x)) s a

full_name: IsMaxOn.bicomp_mono
code: theorem IsMaxOn.bicomp_mono [Preorder δ] {op : β → γ → δ}
    (hop : ((· ≤ ·) ⇒ (· ≤ ·) ⇒ (· ≤ ·)) op op) (hf : IsMaxOn f s a) {g : α → γ}
    (hg : IsMaxOn g s a) : IsMaxOn (fun x => op (f x) (g x)) s a 
goal: IsMaxOn (fun x => op (f x) (g x)) s a

full_name: IsMinFilter.comp_tendsto
code: theorem IsMinFilter.comp_tendsto {g : δ → α} {l' : Filter δ} {b : δ} (hf : IsMinFilter f l (g b))
    (hg : Tendsto g l' l) : IsMinFilter (f ∘ g) l' b 
goal: IsMinFilter (f ∘ g) l' b

full_name: IsMaxFilter.comp_tendsto
code: theorem IsMaxFilter.comp_tendsto {g : δ → α} {l' : Filter δ} {b : δ} (hf : IsMaxFilter f l (g b))
    (hg : Tendsto g l' l) : IsMaxFilter (f ∘ g) l' b 
goal: IsMaxFilter (f ∘ g) l' b

full_name: IsExtrFilter.comp_tendsto
code: theorem IsExtrFilter.comp_tendsto {g : δ → α} {l' : Filter δ} {b : δ} (hf : IsExtrFilter f l (g b))
    (hg : Tendsto g l' l) : IsExtrFilter (f ∘ g) l' b 
goal: IsExtrFilter (f ∘ g) l' b

full_name: IsMinOn.on_preimage
code: theorem IsMinOn.on_preimage (g : δ → α) {b : δ} (hf : IsMinOn f s (g b)) :
    IsMinOn (f ∘ g) (g ⁻¹' s) b 
goal: IsMinOn (f ∘ g) (g ⁻¹' s) b

full_name: IsMaxOn.on_preimage
code: theorem IsMaxOn.on_preimage (g : δ → α) {b : δ} (hf : IsMaxOn f s (g b)) :
    IsMaxOn (f ∘ g) (g ⁻¹' s) b 
goal: IsMaxOn (f ∘ g) (g ⁻¹' s) b

full_name: IsExtrOn.on_preimage
code: theorem IsExtrOn.on_preimage (g : δ → α) {b : δ} (hf : IsExtrOn f s (g b)) :
    IsExtrOn (f ∘ g) (g ⁻¹' s) b 
goal: IsExtrOn (f ∘ g) (g ⁻¹' s) b

full_name: IsMinOn.comp_mapsTo
code: theorem IsMinOn.comp_mapsTo {t : Set δ} {g : δ → α} {b : δ} (hf : IsMinOn f s a) (hg : MapsTo g t s)
    (ha : g b = a) : IsMinOn (f ∘ g) t b 
goal: IsMinOn (f ∘ g) t b

full_name: IsMaxOn.comp_mapsTo
code: theorem IsMaxOn.comp_mapsTo {t : Set δ} {g : δ → α} {b : δ} (hf : IsMaxOn f s a) (hg : MapsTo g t s)
    (ha : g b = a) : IsMaxOn (f ∘ g) t b 
goal: IsMaxOn (f ∘ g) t b

full_name: IsExtrOn.comp_mapsTo
code: theorem IsExtrOn.comp_mapsTo {t : Set δ} {g : δ → α} {b : δ} (hf : IsExtrOn f s a)
    (hg : MapsTo g t s) (ha : g b = a) : IsExtrOn (f ∘ g) t b 
goal: IsExtrOn (f ∘ g) t b

full_name: IsMinFilter.add
code: theorem IsMinFilter.add (hf : IsMinFilter f l a) (hg : IsMinFilter g l a) :
    IsMinFilter (fun x => f x + g x) l a 
goal: IsMinFilter (fun x => f x + g x) l a

full_name: IsMaxFilter.add
code: theorem IsMaxFilter.add (hf : IsMaxFilter f l a) (hg : IsMaxFilter g l a) :
    IsMaxFilter (fun x => f x + g x) l a 
goal: IsMaxFilter (fun x => f x + g x) l a

full_name: IsMinOn.add
code: theorem IsMinOn.add (hf : IsMinOn f s a) (hg : IsMinOn g s a) : IsMinOn (fun x => f x + g x) s a 
goal: IsMinOn (fun x => f x + g x) s a

full_name: IsMaxOn.add
code: theorem IsMaxOn.add (hf : IsMaxOn f s a) (hg : IsMaxOn g s a) : IsMaxOn (fun x => f x + g x) s a 
goal: IsMaxOn (fun x => f x + g x) s a

full_name: IsMinFilter.neg
code: theorem IsMinFilter.neg (hf : IsMinFilter f l a) : IsMaxFilter (fun x => -f x) l a 
goal: IsMaxFilter (fun x => -f x) l a

full_name: IsMaxFilter.neg
code: theorem IsMaxFilter.neg (hf : IsMaxFilter f l a) : IsMinFilter (fun x => -f x) l a 
goal: IsMinFilter (fun x => -f x) l a

full_name: IsExtrFilter.neg
code: theorem IsExtrFilter.neg (hf : IsExtrFilter f l a) : IsExtrFilter (fun x => -f x) l a 
goal: IsExtrFilter (fun x => -f x) l a

full_name: IsMinOn.neg
code: theorem IsMinOn.neg (hf : IsMinOn f s a) : IsMaxOn (fun x => -f x) s a 
goal: IsMaxOn (fun x => -f x) s a

full_name: IsMaxOn.neg
code: theorem IsMaxOn.neg (hf : IsMaxOn f s a) : IsMinOn (fun x => -f x) s a 
goal: IsMinOn (fun x => -f x) s a

full_name: IsExtrOn.neg
code: theorem IsExtrOn.neg (hf : IsExtrOn f s a) : IsExtrOn (fun x => -f x) s a 
goal: IsExtrOn (fun x => -f x) s a

full_name: IsMinFilter.sub
code: theorem IsMinFilter.sub (hf : IsMinFilter f l a) (hg : IsMaxFilter g l a) :
    IsMinFilter (fun x => f x - g x) l a 
goal: IsMinFilter (fun x => f x - g x) l a

full_name: IsMaxFilter.sub
code: theorem IsMaxFilter.sub (hf : IsMaxFilter f l a) (hg : IsMinFilter g l a) :
    IsMaxFilter (fun x => f x - g x) l a 
goal: IsMaxFilter (fun x => f x - g x) l a

full_name: IsMinOn.sub
code: theorem IsMinOn.sub (hf : IsMinOn f s a) (hg : IsMaxOn g s a) :
    IsMinOn (fun x => f x - g x) s a 
goal: IsMinOn (fun x => f x - g x) s a

full_name: IsMaxOn.sub
code: theorem IsMaxOn.sub (hf : IsMaxOn f s a) (hg : IsMinOn g s a) :
    IsMaxOn (fun x => f x - g x) s a 
goal: IsMaxOn (fun x => f x - g x) s a

full_name: IsMinFilter.sup
code: theorem IsMinFilter.sup (hf : IsMinFilter f l a) (hg : IsMinFilter g l a) :
    IsMinFilter (fun x => f x ⊔ g x) l a 
goal: IsMinFilter (fun x => f x ⊔ g x) l a

full_name: IsMaxFilter.sup
code: theorem IsMaxFilter.sup (hf : IsMaxFilter f l a) (hg : IsMaxFilter g l a) :
    IsMaxFilter (fun x => f x ⊔ g x) l a 
goal: IsMaxFilter (fun x => f x ⊔ g x) l a

full_name: IsMinOn.sup
code: theorem IsMinOn.sup (hf : IsMinOn f s a) (hg : IsMinOn g s a) : IsMinOn (fun x => f x ⊔ g x) s a 
goal: IsMinOn (fun x => f x ⊔ g x) s a

full_name: IsMaxOn.sup
code: theorem IsMaxOn.sup (hf : IsMaxOn f s a) (hg : IsMaxOn g s a) : IsMaxOn (fun x => f x ⊔ g x) s a 
goal: IsMaxOn (fun x => f x ⊔ g x) s a

full_name: IsMinFilter.inf
code: theorem IsMinFilter.inf (hf : IsMinFilter f l a) (hg : IsMinFilter g l a) :
    IsMinFilter (fun x => f x ⊓ g x) l a 
goal: IsMinFilter (fun x => f x ⊓ g x) l a

full_name: IsMaxFilter.inf
code: theorem IsMaxFilter.inf (hf : IsMaxFilter f l a) (hg : IsMaxFilter g l a) :
    IsMaxFilter (fun x => f x ⊓ g x) l a 
goal: IsMaxFilter (fun x => f x ⊓ g x) l a

full_name: IsMinOn.inf
code: theorem IsMinOn.inf (hf : IsMinOn f s a) (hg : IsMinOn g s a) : IsMinOn (fun x => f x ⊓ g x) s a 
goal: IsMinOn (fun x => f x ⊓ g x) s a

full_name: IsMaxOn.inf
code: theorem IsMaxOn.inf (hf : IsMaxOn f s a) (hg : IsMaxOn g s a) : IsMaxOn (fun x => f x ⊓ g x) s a 
goal: IsMaxOn (fun x => f x ⊓ g x) s a

full_name: IsMinFilter.min
code: theorem IsMinFilter.min (hf : IsMinFilter f l a) (hg : IsMinFilter g l a) :
    IsMinFilter (fun x => min (f x) (g x)) l a 
goal: IsMinFilter (fun x => min (f x) (g x)) l a

full_name: IsMaxFilter.min
code: theorem IsMaxFilter.min (hf : IsMaxFilter f l a) (hg : IsMaxFilter g l a) :
    IsMaxFilter (fun x => min (f x) (g x)) l a 
goal: IsMaxFilter (fun x => min (f x) (g x)) l a

full_name: IsMinOn.min
code: theorem IsMinOn.min (hf : IsMinOn f s a) (hg : IsMinOn g s a) :
    IsMinOn (fun x => min (f x) (g x)) s a 
goal: IsMinOn (fun x => min (f x) (g x)) s a

full_name: IsMaxOn.min
code: theorem IsMaxOn.min (hf : IsMaxOn f s a) (hg : IsMaxOn g s a) :
    IsMaxOn (fun x => min (f x) (g x)) s a 
goal: IsMaxOn (fun x => min (f x) (g x)) s a

full_name: IsMinFilter.max
code: theorem IsMinFilter.max (hf : IsMinFilter f l a) (hg : IsMinFilter g l a) :
    IsMinFilter (fun x => max (f x) (g x)) l a 
goal: IsMinFilter (fun x => max (f x) (g x)) l a

full_name: IsMaxFilter.max
code: theorem IsMaxFilter.max (hf : IsMaxFilter f l a) (hg : IsMaxFilter g l a) :
    IsMaxFilter (fun x => max (f x) (g x)) l a 
goal: IsMaxFilter (fun x => max (f x) (g x)) l a

full_name: IsMinOn.max
code: theorem IsMinOn.max (hf : IsMinOn f s a) (hg : IsMinOn g s a) :
    IsMinOn (fun x => max (f x) (g x)) s a 
goal: IsMinOn (fun x => max (f x) (g x)) s a

full_name: IsMaxOn.max
code: theorem IsMaxOn.max (hf : IsMaxOn f s a) (hg : IsMaxOn g s a) :
    IsMaxOn (fun x => max (f x) (g x)) s a 
goal: IsMaxOn (fun x => max (f x) (g x)) s a

full_name: Filter.EventuallyLE.isMaxFilter
code: theorem Filter.EventuallyLE.isMaxFilter {α β : Type*} [Preorder β] {f g : α → β} {a : α}
    {l : Filter α} (hle : g ≤ᶠ[l] f) (hfga : f a = g a) (h : IsMaxFilter f l a) :
    IsMaxFilter g l a 
goal: IsMaxFilter g l a

full_name: IsMaxFilter.congr
code: theorem IsMaxFilter.congr {α β : Type*} [Preorder β] {f g : α → β} {a : α} {l : Filter α}
    (h : IsMaxFilter f l a) (heq : f =ᶠ[l] g) (hfga : f a = g a) : IsMaxFilter g l a 
goal: IsMaxFilter g l a

full_name: Filter.EventuallyEq.isMaxFilter_iff
code: theorem Filter.EventuallyEq.isMaxFilter_iff {α β : Type*} [Preorder β] {f g : α → β} {a : α}
    {l : Filter α} (heq : f =ᶠ[l] g) (hfga : f a = g a) : IsMaxFilter f l a ↔ IsMaxFilter g l a 
goal: IsMaxFilter f l a ↔ IsMaxFilter g l a

full_name: Filter.EventuallyLE.isMinFilter
code: theorem Filter.EventuallyLE.isMinFilter {α β : Type*} [Preorder β] {f g : α → β} {a : α}
    {l : Filter α} (hle : f ≤ᶠ[l] g) (hfga : f a = g a) (h : IsMinFilter f l a) :
    IsMinFilter g l a 
goal: IsMinFilter g l a

full_name: IsMinFilter.congr
code: theorem IsMinFilter.congr {α β : Type*} [Preorder β] {f g : α → β} {a : α} {l : Filter α}
    (h : IsMinFilter f l a) (heq : f =ᶠ[l] g) (hfga : f a = g a) : IsMinFilter g l a 
goal: IsMinFilter g l a

full_name: Filter.EventuallyEq.isMinFilter_iff
code: theorem Filter.EventuallyEq.isMinFilter_iff {α β : Type*} [Preorder β] {f g : α → β} {a : α}
    {l : Filter α} (heq : f =ᶠ[l] g) (hfga : f a = g a) : IsMinFilter f l a ↔ IsMinFilter g l a 
goal: IsMinFilter f l a ↔ IsMinFilter g l a

full_name: IsExtrFilter.congr
code: theorem IsExtrFilter.congr {α β : Type*} [Preorder β] {f g : α → β} {a : α} {l : Filter α}
    (h : IsExtrFilter f l a) (heq : f =ᶠ[l] g) (hfga : f a = g a) : IsExtrFilter g l a 
goal: IsExtrFilter g l a

full_name: Filter.EventuallyEq.isExtrFilter_iff
code: theorem Filter.EventuallyEq.isExtrFilter_iff {α β : Type*} [Preorder β] {f g : α → β} {a : α}
    {l : Filter α} (heq : f =ᶠ[l] g) (hfga : f a = g a) : IsExtrFilter f l a ↔ IsExtrFilter g l a 
goal: IsExtrFilter f l a ↔ IsExtrFilter g l a

full_name: IsMaxOn.iSup_eq
code: theorem IsMaxOn.iSup_eq (hx₀ : x₀ ∈ s) (h : IsMaxOn f s x₀) : ⨆ x : s, f x = f x₀ 
goal: ⨆ x, f ↑x = f x₀

full_name: IsMinOn.iInf_eq
code: theorem IsMinOn.iInf_eq (hx₀ : x₀ ∈ s) (h : IsMinOn f s x₀) : ⨅ x : s, f x = f x₀ 
goal: ⨅ x, f ↑x = f x₀