File: Mathlib/Topology/Order/LocalExtr.lean

full_name: IsLocalMinOn
code: /-- `IsLocalMinOn f s a` means that `f a ≤ f x` for all `x ∈ s` in some neighborhood of `a`. -/
def IsLocalMinOn 
goal: Prop

full_name: IsLocalMaxOn
code: /-- `IsLocalMaxOn f s a` means that `f x ≤ f a` for all `x ∈ s` in some neighborhood of `a`. -/
def IsLocalMaxOn 
goal: Prop

full_name: IsLocalExtrOn
code: /-- `IsLocalExtrOn f s a` means `IsLocalMinOn f s a ∨ IsLocalMaxOn f s a`. -/
def IsLocalExtrOn 
goal: Prop

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

full_name: IsLocalMax
code: /-- `IsLocalMax f a` means that `f x ≤ f a` for all `x ∈ s` in some neighborhood of `a`. -/
def IsLocalMax 
goal: Prop

full_name: IsLocalExtr
code: /-- `IsLocalExtrOn f s a` means `IsLocalMinOn f s a ∨ IsLocalMaxOn f s a`. -/
def IsLocalExtr 
goal: Prop

full_name: IsLocalExtrOn.elim
code: theorem IsLocalExtrOn.elim {p : Prop} :
    IsLocalExtrOn f s a → (IsLocalMinOn f s a → p) → (IsLocalMaxOn f s a → p) → p 
goal: IsLocalExtrOn f s a → (IsLocalMinOn f s a → p) → (IsLocalMaxOn f s a → p) → p

full_name: IsLocalExtr.elim
code: theorem IsLocalExtr.elim {p : Prop} :
    IsLocalExtr f a → (IsLocalMin f a → p) → (IsLocalMax f a → p) → p 
goal: IsLocalExtr f a → (IsLocalMin f a → p) → (IsLocalMax f a → p) → p

full_name: IsLocalMin.on
code: theorem IsLocalMin.on (h : IsLocalMin f a) (s) : IsLocalMinOn f s a 
goal: IsLocalMinOn f s a

full_name: IsLocalMax.on
code: theorem IsLocalMax.on (h : IsLocalMax f a) (s) : IsLocalMaxOn f s a 
goal: IsLocalMaxOn f s a

full_name: IsLocalExtr.on
code: theorem IsLocalExtr.on (h : IsLocalExtr f a) (s) : IsLocalExtrOn f s a 
goal: IsLocalExtrOn f s a

full_name: IsLocalMinOn.on_subset
code: theorem IsLocalMinOn.on_subset {t : Set α} (hf : IsLocalMinOn f t a) (h : s ⊆ t) :
    IsLocalMinOn f s a 
goal: IsLocalMinOn f s a

full_name: IsLocalMaxOn.on_subset
code: theorem IsLocalMaxOn.on_subset {t : Set α} (hf : IsLocalMaxOn f t a) (h : s ⊆ t) :
    IsLocalMaxOn f s a 
goal: IsLocalMaxOn f s a

full_name: IsLocalExtrOn.on_subset
code: theorem IsLocalExtrOn.on_subset {t : Set α} (hf : IsLocalExtrOn f t a) (h : s ⊆ t) :
    IsLocalExtrOn f s a 
goal: IsLocalExtrOn f s a

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

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

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

full_name: IsMinOn.localize
code: theorem IsMinOn.localize (hf : IsMinOn f s a) : IsLocalMinOn f s a 
goal: IsLocalMinOn f s a

full_name: IsMaxOn.localize
code: theorem IsMaxOn.localize (hf : IsMaxOn f s a) : IsLocalMaxOn f s a 
goal: IsLocalMaxOn f s a

full_name: IsExtrOn.localize
code: theorem IsExtrOn.localize (hf : IsExtrOn f s a) : IsLocalExtrOn f s a 
goal: IsLocalExtrOn f s a

full_name: IsLocalMinOn.isLocalMin
code: theorem IsLocalMinOn.isLocalMin (hf : IsLocalMinOn f s a) (hs : s ∈ 𝓝 a) : IsLocalMin f a 
goal: IsLocalMin f a

full_name: IsLocalMaxOn.isLocalMax
code: theorem IsLocalMaxOn.isLocalMax (hf : IsLocalMaxOn f s a) (hs : s ∈ 𝓝 a) : IsLocalMax f a 
goal: IsLocalMax f a

full_name: IsLocalExtrOn.isLocalExtr
code: theorem IsLocalExtrOn.isLocalExtr (hf : IsLocalExtrOn f s a) (hs : s ∈ 𝓝 a) : IsLocalExtr f a 
goal: IsLocalExtr f a

full_name: IsMinOn.isLocalMin
code: theorem IsMinOn.isLocalMin (hf : IsMinOn f s a) (hs : s ∈ 𝓝 a) : IsLocalMin f a 
goal: IsLocalMin f a

full_name: IsMaxOn.isLocalMax
code: theorem IsMaxOn.isLocalMax (hf : IsMaxOn f s a) (hs : s ∈ 𝓝 a) : IsLocalMax f a 
goal: IsLocalMax f a

full_name: IsExtrOn.isLocalExtr
code: theorem IsExtrOn.isLocalExtr (hf : IsExtrOn f s a) (hs : s ∈ 𝓝 a) : IsLocalExtr f a 
goal: IsLocalExtr f a

full_name: IsLocalMinOn.not_nhds_le_map
code: theorem IsLocalMinOn.not_nhds_le_map [TopologicalSpace β] (hf : IsLocalMinOn f s a)
    [NeBot (𝓝[<] f a)] : ¬𝓝 (f a) ≤ map f (𝓝[s] a) 
goal: ¬𝓝 (f a) ≤ Filter.map f (𝓝[s] a)

full_name: IsLocalMaxOn.not_nhds_le_map
code: theorem IsLocalMaxOn.not_nhds_le_map [TopologicalSpace β] (hf : IsLocalMaxOn f s a)
    [NeBot (𝓝[>] f a)] : ¬𝓝 (f a) ≤ map f (𝓝[s] a) 
goal: ¬𝓝 (f a) ≤ Filter.map f (𝓝[s] a)

full_name: IsLocalExtrOn.not_nhds_le_map
code: theorem IsLocalExtrOn.not_nhds_le_map [TopologicalSpace β] (hf : IsLocalExtrOn f s a)
    [NeBot (𝓝[<] f a)] [NeBot (𝓝[>] f a)] : ¬𝓝 (f a) ≤ map f (𝓝[s] a) 
goal: ¬𝓝 (f a) ≤ Filter.map f (𝓝[s] a)

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

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

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

full_name: isLocalMin_const
code: theorem isLocalMin_const {b : β} : IsLocalMin (fun _ => b) a 
goal: IsLocalMin (fun x => b) a

full_name: isLocalMax_const
code: theorem isLocalMax_const {b : β} : IsLocalMax (fun _ => b) a 
goal: IsLocalMax (fun x => b) a

full_name: isLocalExtr_const
code: theorem isLocalExtr_const {b : β} : IsLocalExtr (fun _ => b) a 
goal: IsLocalExtr (fun x => b) a

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

full_name: IsLocalMin.comp_continuous
code: theorem IsLocalMin.comp_continuous [TopologicalSpace δ] {g : δ → α} {b : δ}
    (hf : IsLocalMin f (g b)) (hg : ContinuousAt g b) : IsLocalMin (f ∘ g) b 
goal: IsLocalMin (f ∘ g) b

full_name: IsLocalMax.comp_continuous
code: theorem IsLocalMax.comp_continuous [TopologicalSpace δ] {g : δ → α} {b : δ}
    (hf : IsLocalMax f (g b)) (hg : ContinuousAt g b) : IsLocalMax (f ∘ g) b 
goal: IsLocalMax (f ∘ g) b

full_name: IsLocalExtr.comp_continuous
code: theorem IsLocalExtr.comp_continuous [TopologicalSpace δ] {g : δ → α} {b : δ}
    (hf : IsLocalExtr f (g b)) (hg : ContinuousAt g b) : IsLocalExtr (f ∘ g) b 
goal: IsLocalExtr (f ∘ g) b

full_name: IsLocalMin.comp_continuousOn
code: theorem IsLocalMin.comp_continuousOn [TopologicalSpace δ] {s : Set δ} {g : δ → α} {b : δ}
    (hf : IsLocalMin f (g b)) (hg : ContinuousOn g s) (hb : b ∈ s) : IsLocalMinOn (f ∘ g) s b 
goal: IsLocalMinOn (f ∘ g) s b

full_name: IsLocalMax.comp_continuousOn
code: theorem IsLocalMax.comp_continuousOn [TopologicalSpace δ] {s : Set δ} {g : δ → α} {b : δ}
    (hf : IsLocalMax f (g b)) (hg : ContinuousOn g s) (hb : b ∈ s) : IsLocalMaxOn (f ∘ g) s b 
goal: IsLocalMaxOn (f ∘ g) s b

full_name: IsLocalExtr.comp_continuousOn
code: theorem IsLocalExtr.comp_continuousOn [TopologicalSpace δ] {s : Set δ} (g : δ → α) {b : δ}
    (hf : IsLocalExtr f (g b)) (hg : ContinuousOn g s) (hb : b ∈ s) : IsLocalExtrOn (f ∘ g) s b 
goal: IsLocalExtrOn (f ∘ g) s b

full_name: IsLocalMinOn.comp_continuousOn
code: theorem IsLocalMinOn.comp_continuousOn [TopologicalSpace δ] {t : Set α} {s : Set δ} {g : δ → α}
    {b : δ} (hf : IsLocalMinOn f t (g b)) (hst : s ⊆ g ⁻¹' t) (hg : ContinuousOn g s) (hb : b ∈ s) :
    IsLocalMinOn (f ∘ g) s b 
goal: IsLocalMinOn (f ∘ g) s b

full_name: IsLocalMaxOn.comp_continuousOn
code: theorem IsLocalMaxOn.comp_continuousOn [TopologicalSpace δ] {t : Set α} {s : Set δ} {g : δ → α}
    {b : δ} (hf : IsLocalMaxOn f t (g b)) (hst : s ⊆ g ⁻¹' t) (hg : ContinuousOn g s) (hb : b ∈ s) :
    IsLocalMaxOn (f ∘ g) s b 
goal: IsLocalMaxOn (f ∘ g) s b

full_name: IsLocalExtrOn.comp_continuousOn
code: theorem IsLocalExtrOn.comp_continuousOn [TopologicalSpace δ] {t : Set α} {s : Set δ} (g : δ → α)
    {b : δ} (hf : IsLocalExtrOn f t (g b)) (hst : s ⊆ g ⁻¹' t) (hg : ContinuousOn g s)
    (hb : b ∈ s) : IsLocalExtrOn (f ∘ g) s b 
goal: IsLocalExtrOn (f ∘ g) s b

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

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

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

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

full_name: IsLocalMin.neg
code: nonrec theorem IsLocalMin.neg (hf : IsLocalMin f a) : IsLocalMax (fun x => -f x) a 
goal: IsLocalMax (fun x => -f x) a

full_name: IsLocalMax.neg
code: nonrec theorem IsLocalMax.neg (hf : IsLocalMax f a) : IsLocalMin (fun x => -f x) a 
goal: IsLocalMin (fun x => -f x) a

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

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

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

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

full_name: IsLocalMin.sub
code: nonrec theorem IsLocalMin.sub (hf : IsLocalMin f a) (hg : IsLocalMax g a) :
    IsLocalMin (fun x => f x - g x) a 
goal: IsLocalMin (fun x => f x - g x) a

full_name: IsLocalMax.sub
code: nonrec theorem IsLocalMax.sub (hf : IsLocalMax f a) (hg : IsLocalMin g a) :
    IsLocalMax (fun x => f x - g x) a 
goal: IsLocalMax (fun x => f x - g x) a

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

full_name: Filter.EventuallyLE.isLocalMaxOn
code: theorem Filter.EventuallyLE.isLocalMaxOn {f g : α → β} {a : α} (hle : g ≤ᶠ[𝓝[s] a] f)
    (hfga : f a = g a) (h : IsLocalMaxOn f s a) : IsLocalMaxOn g s a 
goal: IsLocalMaxOn g s a

full_name: IsLocalMaxOn.congr
code: nonrec theorem IsLocalMaxOn.congr {f g : α → β} {a : α} (h : IsLocalMaxOn f s a)
    (heq : f =ᶠ[𝓝[s] a] g) (hmem : a ∈ s) : IsLocalMaxOn g s a 
goal: IsLocalMaxOn g s a

full_name: Filter.EventuallyEq.isLocalMaxOn_iff
code: theorem Filter.EventuallyEq.isLocalMaxOn_iff {f g : α → β} {a : α} (heq : f =ᶠ[𝓝[s] a] g)
    (hmem : a ∈ s) : IsLocalMaxOn f s a ↔ IsLocalMaxOn g s a 
goal: IsLocalMaxOn f s a ↔ IsLocalMaxOn g s a

full_name: Filter.EventuallyLE.isLocalMinOn
code: theorem Filter.EventuallyLE.isLocalMinOn {f g : α → β} {a : α} (hle : f ≤ᶠ[𝓝[s] a] g)
    (hfga : f a = g a) (h : IsLocalMinOn f s a) : IsLocalMinOn g s a 
goal: IsLocalMinOn g s a

full_name: IsLocalMinOn.congr
code: nonrec theorem IsLocalMinOn.congr {f g : α → β} {a : α} (h : IsLocalMinOn f s a)
    (heq : f =ᶠ[𝓝[s] a] g) (hmem : a ∈ s) : IsLocalMinOn g s a 
goal: IsLocalMinOn g s a

full_name: Filter.EventuallyEq.isLocalMinOn_iff
code: nonrec theorem Filter.EventuallyEq.isLocalMinOn_iff {f g : α → β} {a : α} (heq : f =ᶠ[𝓝[s] a] g)
    (hmem : a ∈ s) : IsLocalMinOn f s a ↔ IsLocalMinOn g s a 
goal: IsLocalMinOn f s a ↔ IsLocalMinOn g s a

full_name: IsLocalExtrOn.congr
code: nonrec theorem IsLocalExtrOn.congr {f g : α → β} {a : α} (h : IsLocalExtrOn f s a)
    (heq : f =ᶠ[𝓝[s] a] g) (hmem : a ∈ s) : IsLocalExtrOn g s a 
goal: IsLocalExtrOn g s a

full_name: Filter.EventuallyEq.isLocalExtrOn_iff
code: theorem Filter.EventuallyEq.isLocalExtrOn_iff {f g : α → β} {a : α} (heq : f =ᶠ[𝓝[s] a] g)
    (hmem : a ∈ s) : IsLocalExtrOn f s a ↔ IsLocalExtrOn g s a 
goal: IsLocalExtrOn f s a ↔ IsLocalExtrOn g s a

full_name: Filter.EventuallyLE.isLocalMax
code: theorem Filter.EventuallyLE.isLocalMax {f g : α → β} {a : α} (hle : g ≤ᶠ[𝓝 a] f) (hfga : f a = g a)
    (h : IsLocalMax f a) : IsLocalMax g a 
goal: IsLocalMax g a

full_name: IsLocalMax.congr
code: nonrec theorem IsLocalMax.congr {f g : α → β} {a : α} (h : IsLocalMax f a) (heq : f =ᶠ[𝓝 a] g) :
    IsLocalMax g a 
goal: IsLocalMax g a

full_name: Filter.EventuallyEq.isLocalMax_iff
code: theorem Filter.EventuallyEq.isLocalMax_iff {f g : α → β} {a : α} (heq : f =ᶠ[𝓝 a] g) :
    IsLocalMax f a ↔ IsLocalMax g a 
goal: IsLocalMax f a ↔ IsLocalMax g a

full_name: Filter.EventuallyLE.isLocalMin
code: theorem Filter.EventuallyLE.isLocalMin {f g : α → β} {a : α} (hle : f ≤ᶠ[𝓝 a] g) (hfga : f a = g a)
    (h : IsLocalMin f a) : IsLocalMin g a 
goal: IsLocalMin g a

full_name: IsLocalMin.congr
code: nonrec theorem IsLocalMin.congr {f g : α → β} {a : α} (h : IsLocalMin f a) (heq : f =ᶠ[𝓝 a] g) :
    IsLocalMin g a 
goal: IsLocalMin g a

full_name: Filter.EventuallyEq.isLocalMin_iff
code: theorem Filter.EventuallyEq.isLocalMin_iff {f g : α → β} {a : α} (heq : f =ᶠ[𝓝 a] g) :
    IsLocalMin f a ↔ IsLocalMin g a 
goal: IsLocalMin f a ↔ IsLocalMin g a

full_name: IsLocalExtr.congr
code: nonrec theorem IsLocalExtr.congr {f g : α → β} {a : α} (h : IsLocalExtr f a) (heq : f =ᶠ[𝓝 a] g) :
    IsLocalExtr g a 
goal: IsLocalExtr g a

full_name: Filter.EventuallyEq.isLocalExtr_iff
code: theorem Filter.EventuallyEq.isLocalExtr_iff {f g : α → β} {a : α} (heq : f =ᶠ[𝓝 a] g) :
    IsLocalExtr f a ↔ IsLocalExtr g a 
goal: IsLocalExtr f a ↔ IsLocalExtr g a