ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
-- Filter.tendsto_eval_pi
theorem tendsto_eval_pi (f : ∀ i, Filter (α i)) (i : ι) : Tendsto (eval i) (pi f) (f i) 
Arguments: {ι : Type u_1} {α : ι → Type u_2} (f : (i : ι) → Filter (α i)) (i : ι)
Goal: Filter.Tendsto (Function.eval i) (Filter.pi f) (f i)
-- Filter.tendsto_pi
theorem tendsto_pi {β : Type*} {m : β → ∀ i, α i} {l : Filter β} :
    Tendsto m l (pi f) ↔ ∀ i, Tendsto (fun x => m x i) l (f i) 
Arguments: {ι : Type u_1} {α : ι → Type u_2} {f : (i : ι) → Filter (α i)} {β : Type u_3} {m : β → (i : ι) → α i} {l : Filter β}
Goal: Filter.Tendsto m l (Filter.pi f) ↔ ∀ (i : ι), Filter.Tendsto (fun x => m x i) l (f i)
-- Filter.le_pi
theorem le_pi {g : Filter (∀ i, α i)} : g ≤ pi f ↔ ∀ i, Tendsto (eval i) g (f i) 
Arguments: {ι : Type u_1} {α : ι → Type u_2} {f : (i : ι) → Filter (α i)} {g : Filter ((i : ι) → α i)}
Goal: g ≤ Filter.pi f ↔ ∀ (i : ι), Filter.Tendsto (Function.eval i) g (f i)
-- Filter.pi_mono
@[mono]
theorem pi_mono (h : ∀ i, f₁ i ≤ f₂ i) : pi f₁ ≤ pi f₂ 
Arguments: {ι : Type u_1} {α : ι → Type u_2} {f₁ f₂ : (i : ι) → Filter (α i)} (h : ∀ (i : ι), f₁ i ≤ f₂ i)
Goal: Filter.pi f₁ ≤ Filter.pi f₂
-- Filter.mem_pi_of_mem
theorem mem_pi_of_mem (i : ι) {s : Set (α i)} (hs : s ∈ f i) : eval i ⁻¹' s ∈ pi f 
Arguments: {ι : Type u_1} {α : ι → Type u_2} {f : (i : ι) → Filter (α i)} (i : ι) {s : Set (α i)} (hs : s ∈ f i)
Goal: Function.eval i ⁻¹' s ∈ Filter.pi f
-- Filter.pi_mem_pi
theorem pi_mem_pi {I : Set ι} (hI : I.Finite) (h : ∀ i ∈ I, s i ∈ f i) : I.pi s ∈ pi f 
Arguments: {ι : Type u_1} {α : ι → Type u_2} {f : (i : ι) → Filter (α i)} {s : (i : ι) → Set (α i)} {I : Set ι} (hI : I.Finite) (h : ∀ i ∈ I, s i ∈ f i)
Goal: I.pi s ∈ Filter.pi f
-- Filter.mem_pi
theorem mem_pi {s : Set (∀ i, α i)} :
    s ∈ pi f ↔ ∃ I : Set ι, I.Finite ∧ ∃ t : ∀ i, Set (α i), (∀ i, t i ∈ f i) ∧ I.pi t ⊆ s 
Arguments: {ι : Type u_1} {α : ι → Type u_2} {f : (i : ι) → Filter (α i)} {s : Set ((i : ι) → α i)}
Goal: s ∈ Filter.pi f ↔ ∃ I, I.Finite ∧ ∃ t, (∀ (i : ι), t i ∈ f i) ∧ I.pi t ⊆ s
-- Filter.mem_pi'
theorem mem_pi' {s : Set (∀ i, α i)} :
    s ∈ pi f ↔ ∃ I : Finset ι, ∃ t : ∀ i, Set (α i), (∀ i, t i ∈ f i) ∧ Set.pi (↑I) t ⊆ s 
Arguments: {ι : Type u_1} {α : ι → Type u_2} {f : (i : ι) → Filter (α i)} {s : Set ((i : ι) → α i)}
Goal: s ∈ Filter.pi f ↔ ∃ I t, (∀ (i : ι), t i ∈ f i) ∧ (↑I).pi t ⊆ s
-- Filter.mem_of_pi_mem_pi
theorem mem_of_pi_mem_pi [∀ i, NeBot (f i)] {I : Set ι} (h : I.pi s ∈ pi f) {i : ι} (hi : i ∈ I) :
    s i ∈ f i 
Arguments: {ι : Type u_1} {α : ι → Type u_2} {f : (i : ι) → Filter (α i)} {s : (i : ι) → Set (α i)} [∀ (i : ι), (f i).NeBot] {I : Set ι} (h : I.pi s ∈ Filter.pi f) {i : ι} (hi : i ∈ I)
Goal: s i ∈ f i
-- Filter.pi_mem_pi_iff
@[simp]
theorem pi_mem_pi_iff [∀ i, NeBot (f i)] {I : Set ι} (hI : I.Finite) :
    I.pi s ∈ pi f ↔ ∀ i ∈ I, s i ∈ f i 
Arguments: {ι : Type u_1} {α : ι → Type u_2} {f : (i : ι) → Filter (α i)} {s : (i : ι) → Set (α i)} [∀ (i : ι), (f i).NeBot] {I : Set ι} (hI : I.Finite)
Goal: I.pi s ∈ Filter.pi f ↔ ∀ i ∈ I, s i ∈ f i
-- Filter.Eventually.eval_pi
theorem Eventually.eval_pi {i : ι} (hf : ∀ᶠ x : α i in f i, p i x) :
    ∀ᶠ x : ∀ i : ι, α i in pi f, p i (x i) 
Arguments: {ι : Type u_1} {α : ι → Type u_2} {f : (i : ι) → Filter (α i)} {p : (i : ι) → α i → Prop} {i : ι} (hf : ∀ᶠ (x : α i) in f i, p i x)
Goal: ∀ᶠ (x : (i : ι) → α i) in Filter.pi f, p i (x i)
-- Filter.eventually_pi
theorem eventually_pi [Finite ι] (hf : ∀ i, ∀ᶠ x in f i, p i x) :
    ∀ᶠ x : ∀ i, α i in pi f, ∀ i, p i (x i) 
Arguments: {ι : Type u_1} {α : ι → Type u_2} {f : (i : ι) → Filter (α i)} {p : (i : ι) → α i → Prop} [Finite ι] (hf : ∀ (i : ι), ∀ᶠ (x : α i) in f i, p i x)
Goal: ∀ᶠ (x : (i : ι) → α i) in Filter.pi f, ∀ (i : ι), p i (x i)
-- Filter.hasBasis_pi
theorem hasBasis_pi {ι' : ι → Type} {s : ∀ i, ι' i → Set (α i)} {p : ∀ i, ι' i → Prop}
    (h : ∀ i, (f i).HasBasis (p i) (s i)) :
    (pi f).HasBasis (fun If : Set ι × ∀ i, ι' i => If.1.Finite ∧ ∀ i ∈ If.1, p i (If.2 i))
      fun If : Set ι × ∀ i, ι' i => If.1.pi fun i => s i <| If.2 i 
Arguments: {ι : Type u_1} {α : ι → Type u_2} {f : (i : ι) → Filter (α i)} {ι' : ι → Type} {s : (i : ι) → ι' i → Set (α i)} {p : (i : ι) → ι' i → Prop} (h : ∀ (i : ι), (f i).HasBasis (p i) (s i))
Goal: (Filter.pi f).HasBasis (fun If => If.1.Finite ∧ ∀ i ∈ If.1, p i (If.2 i)) fun If => If.1.pi fun i => s i (If.2 i)
-- Filter.le_pi_principal
theorem le_pi_principal (s : (i : ι) → Set (α i)) :
    𝓟 (univ.pi s) ≤ pi fun i ↦ 𝓟 (s i) 
Arguments: {ι : Type u_1} {α : ι → Type u_2} (s : (i : ι) → Set (α i))
Goal: 𝓟 (Set.univ.pi s) ≤ Filter.pi fun i => 𝓟 (s i)
-- Filter.pi_principal
@[simp]
theorem pi_principal [Finite ι] (s : (i : ι) → Set (α i)) :
    pi (fun i ↦ 𝓟 (s i)) = 𝓟 (univ.pi s) 
Arguments: {ι : Type u_1} {α : ι → Type u_2} [Finite ι] (s : (i : ι) → Set (α i))
Goal: (Filter.pi fun i => 𝓟 (s i)) = 𝓟 (Set.univ.pi s)
-- Filter.pi_pure
@[simp]
theorem pi_pure [Finite ι] (f : (i : ι) → α i) : pi (pure <| f ·) = pure f 
Arguments: {ι : Type u_1} {α : ι → Type u_2} [Finite ι] (f : (i : ι) → α i)
Goal: (Filter.pi fun x => pure (f x)) = pure f
-- Filter.pi_inf_principal_univ_pi_eq_bot
@[simp]
theorem pi_inf_principal_univ_pi_eq_bot :
    pi f ⊓ 𝓟 (Set.pi univ s) = ⊥ ↔ ∃ i, f i ⊓ 𝓟 (s i) = ⊥ 
Arguments: {ι : Type u_1} {α : ι → Type u_2} {f : (i : ι) → Filter (α i)} {s : (i : ι) → Set (α i)}
Goal: Filter.pi f ⊓ 𝓟 (Set.univ.pi s) = ⊥ ↔ ∃ i, f i ⊓ 𝓟 (s i) = ⊥
-- Filter.pi_inf_principal_pi_eq_bot
@[simp]
theorem pi_inf_principal_pi_eq_bot [∀ i, NeBot (f i)] {I : Set ι} :
    pi f ⊓ 𝓟 (Set.pi I s) = ⊥ ↔ ∃ i ∈ I, f i ⊓ 𝓟 (s i) = ⊥ 
Arguments: {ι : Type u_1} {α : ι → Type u_2} {f : (i : ι) → Filter (α i)} {s : (i : ι) → Set (α i)} [∀ (i : ι), (f i).NeBot] {I : Set ι}
Goal: Filter.pi f ⊓ 𝓟 (I.pi s) = ⊥ ↔ ∃ i ∈ I, f i ⊓ 𝓟 (s i) = ⊥
-- Filter.pi_inf_principal_univ_pi_neBot
@[simp]
theorem pi_inf_principal_univ_pi_neBot :
    NeBot (pi f ⊓ 𝓟 (Set.pi univ s)) ↔ ∀ i, NeBot (f i ⊓ 𝓟 (s i)) 
Arguments: {ι : Type u_1} {α : ι → Type u_2} {f : (i : ι) → Filter (α i)} {s : (i : ι) → Set (α i)}
Goal: (Filter.pi f ⊓ 𝓟 (Set.univ.pi s)).NeBot ↔ ∀ (i : ι), (f i ⊓ 𝓟 (s i)).NeBot
-- Filter.pi_inf_principal_pi_neBot
@[simp]
theorem pi_inf_principal_pi_neBot [∀ i, NeBot (f i)] {I : Set ι} :
    NeBot (pi f ⊓ 𝓟 (I.pi s)) ↔ ∀ i ∈ I, NeBot (f i ⊓ 𝓟 (s i)) 
Arguments: {ι : Type u_1} {α : ι → Type u_2} {f : (i : ι) → Filter (α i)} {s : (i : ι) → Set (α i)} [∀ (i : ι), (f i).NeBot] {I : Set ι}
Goal: (Filter.pi f ⊓ 𝓟 (I.pi s)).NeBot ↔ ∀ i ∈ I, (f i ⊓ 𝓟 (s i)).NeBot
-- Filter.pi_eq_bot
@[simp]
theorem pi_eq_bot : pi f = ⊥ ↔ ∃ i, f i = ⊥ 
Arguments: {ι : Type u_1} {α : ι → Type u_2} {f : (i : ι) → Filter (α i)}
Goal: Filter.pi f = ⊥ ↔ ∃ i, f i = ⊥
-- Filter.pi_neBot
@[simp]
theorem pi_neBot : NeBot (pi f) ↔ ∀ i, NeBot (f i) 
Arguments: {ι : Type u_1} {α : ι → Type u_2} {f : (i : ι) → Filter (α i)}
Goal: (Filter.pi f).NeBot ↔ ∀ (i : ι), (f i).NeBot
-- Filter.map_eval_pi
@[simp]
theorem map_eval_pi (f : ∀ i, Filter (α i)) [∀ i, NeBot (f i)] (i : ι) :
    map (eval i) (pi f) = f i 
Arguments: {ι : Type u_1} {α : ι → Type u_2} (f : (i : ι) → Filter (α i)) [∀ (i : ι), (f i).NeBot] (i : ι)
Goal: Filter.map (Function.eval i) (Filter.pi f) = f i
-- Filter.pi_le_pi
@[simp]
theorem pi_le_pi [∀ i, NeBot (f₁ i)] : pi f₁ ≤ pi f₂ ↔ ∀ i, f₁ i ≤ f₂ i 
Arguments: {ι : Type u_1} {α : ι → Type u_2} {f₁ f₂ : (i : ι) → Filter (α i)} [∀ (i : ι), (f₁ i).NeBot]
Goal: Filter.pi f₁ ≤ Filter.pi f₂ ↔ ∀ (i : ι), f₁ i ≤ f₂ i
-- Filter.pi_inj
@[simp]
theorem pi_inj [∀ i, NeBot (f₁ i)] : pi f₁ = pi f₂ ↔ f₁ = f₂ 
Arguments: {ι : Type u_1} {α : ι → Type u_2} {f₁ f₂ : (i : ι) → Filter (α i)} [∀ (i : ι), (f₁ i).NeBot]
Goal: Filter.pi f₁ = Filter.pi f₂ ↔ f₁ = f₂
-- Filter.mem_coprodᵢ_iff
theorem mem_coprodᵢ_iff {s : Set (∀ i, α i)} :
    s ∈ Filter.coprodᵢ f ↔ ∀ i : ι, ∃ t₁ ∈ f i, eval i ⁻¹' t₁ ⊆ s 
Arguments: {ι : Type u_1} {α : ι → Type u_2} {f : (i : ι) → Filter (α i)} {s : Set ((i : ι) → α i)}
Goal: s ∈ Filter.coprodᵢ f ↔ ∀ (i : ι), ∃ t₁ ∈ f i, Function.eval i ⁻¹' t₁ ⊆ s
-- Filter.compl_mem_coprodᵢ
theorem compl_mem_coprodᵢ {s : Set (∀ i, α i)} :
    sᶜ ∈ Filter.coprodᵢ f ↔ ∀ i, (eval i '' s)ᶜ ∈ f i 
Arguments: {ι : Type u_1} {α : ι → Type u_2} {f : (i : ι) → Filter (α i)} {s : Set ((i : ι) → α i)}
Goal: sᶜ ∈ Filter.coprodᵢ f ↔ ∀ (i : ι), (Function.eval i '' s)ᶜ ∈ f i
-- Filter.coprodᵢ_neBot_iff'
theorem coprodᵢ_neBot_iff' :
    NeBot (Filter.coprodᵢ f) ↔ (∀ i, Nonempty (α i)) ∧ ∃ d, NeBot (f d) 
Arguments: {ι : Type u_1} {α : ι → Type u_2} {f : (i : ι) → Filter (α i)}
Goal: (Filter.coprodᵢ f).NeBot ↔ (∀ (i : ι), Nonempty (α i)) ∧ ∃ d, (f d).NeBot
-- Filter.coprodᵢ_neBot_iff
@[simp]
theorem coprodᵢ_neBot_iff [∀ i, Nonempty (α i)] : NeBot (Filter.coprodᵢ f) ↔ ∃ d, NeBot (f d) 
Arguments: {ι : Type u_1} {α : ι → Type u_2} {f : (i : ι) → Filter (α i)} [∀ (i : ι), Nonempty (α i)]
Goal: (Filter.coprodᵢ f).NeBot ↔ ∃ d, (f d).NeBot
-- Filter.coprodᵢ_eq_bot_iff'
theorem coprodᵢ_eq_bot_iff' : Filter.coprodᵢ f = ⊥ ↔ (∃ i, IsEmpty (α i)) ∨ f = ⊥ 
Arguments: {ι : Type u_1} {α : ι → Type u_2} {f : (i : ι) → Filter (α i)}
Goal: Filter.coprodᵢ f = ⊥ ↔ (∃ i, IsEmpty (α i)) ∨ f = ⊥
-- Filter.coprodᵢ_eq_bot_iff
@[simp]
theorem coprodᵢ_eq_bot_iff [∀ i, Nonempty (α i)] : Filter.coprodᵢ f = ⊥ ↔ f = ⊥ 
Arguments: {ι : Type u_1} {α : ι → Type u_2} {f : (i : ι) → Filter (α i)} [∀ (i : ι), Nonempty (α i)]
Goal: Filter.coprodᵢ f = ⊥ ↔ f = ⊥
-- Filter.coprodᵢ_bot'
@[simp] theorem coprodᵢ_bot' : Filter.coprodᵢ (⊥ : ∀ i, Filter (α i)) = ⊥ 
Arguments: {ι : Type u_1} {α : ι → Type u_2}
Goal: Filter.coprodᵢ ⊥ = ⊥
-- Filter.coprodᵢ_bot
@[simp]
theorem coprodᵢ_bot : Filter.coprodᵢ (fun _ => ⊥ : ∀ i, Filter (α i)) = ⊥ 
Arguments: {ι : Type u_1} {α : ι → Type u_2}
Goal: (Filter.coprodᵢ fun x => ⊥) = ⊥
-- Filter.NeBot.coprodᵢ
theorem NeBot.coprodᵢ [∀ i, Nonempty (α i)] {i : ι} (h : NeBot (f i)) : NeBot (Filter.coprodᵢ f) 
Arguments: {ι : Type u_1} {α : ι → Type u_2} {f : (i : ι) → Filter (α i)} [∀ (i : ι), Nonempty (α i)] {i : ι} (h : (f i).NeBot)
Goal: (Filter.coprodᵢ f).NeBot
-- Filter.coprodᵢ_neBot
@[instance]
theorem coprodᵢ_neBot [∀ i, Nonempty (α i)] [Nonempty ι] (f : ∀ i, Filter (α i))
    [H : ∀ i, NeBot (f i)] : NeBot (Filter.coprodᵢ f) 
Arguments: {ι : Type u_1} {α : ι → Type u_2} [∀ (i : ι), Nonempty (α i)] [Nonempty ι] (f : (i : ι) → Filter (α i)) [H : ∀ (i : ι), (f i).NeBot]
Goal: (Filter.coprodᵢ f).NeBot
-- Filter.coprodᵢ_mono
@[mono]
theorem coprodᵢ_mono (hf : ∀ i, f₁ i ≤ f₂ i) : Filter.coprodᵢ f₁ ≤ Filter.coprodᵢ f₂ 
Arguments: {ι : Type u_1} {α : ι → Type u_2} {f₁ f₂ : (i : ι) → Filter (α i)} (hf : ∀ (i : ι), f₁ i ≤ f₂ i)
Goal: Filter.coprodᵢ f₁ ≤ Filter.coprodᵢ f₂
-- Filter.map_pi_map_coprodᵢ_le
theorem map_pi_map_coprodᵢ_le :
    map (fun k : ∀ i, α i => fun i => m i (k i)) (Filter.coprodᵢ f) ≤
      Filter.coprodᵢ fun i => map (m i) (f i) 
Arguments: {ι : Type u_1} {α : ι → Type u_2} {f : (i : ι) → Filter (α i)} {β : ι → Type u_3} {m : (i : ι) → α i → β i}
Goal: Filter.map (fun k i => m i (k i)) (Filter.coprodᵢ f) ≤ Filter.coprodᵢ fun i => Filter.map (m i) (f i)
-- Filter.Tendsto.pi_map_coprodᵢ
theorem Tendsto.pi_map_coprodᵢ {g : ∀ i, Filter (β i)} (h : ∀ i, Tendsto (m i) (f i) (g i)) :
    Tendsto (fun k : ∀ i, α i => fun i => m i (k i)) (Filter.coprodᵢ f) (Filter.coprodᵢ g) 
Arguments: {ι : Type u_1} {α : ι → Type u_2} {f : (i : ι) → Filter (α i)} {β : ι → Type u_3} {m : (i : ι) → α i → β i} {g : (i : ι) → Filter (β i)} (h : ∀ (i : ι), Filter.Tendsto (m i) (f i) (g i))
Goal: Filter.Tendsto (fun k i => m i (k i)) (Filter.coprodᵢ f) (Filter.coprodᵢ g)
-- Filter.const_eventuallyEq'
theorem const_eventuallyEq' [NeBot l] {a b : β} : (∀ᶠ _ in l, a = b) ↔ a = b 
Arguments: {α : Type u_1} {β : Type u_2} {l : Filter α} [l.NeBot] {a b : β}
Goal: (∀ᶠ (x : α) in l, a = b) ↔ a = b
-- Filter.const_eventuallyEq
theorem const_eventuallyEq [NeBot l] {a b : β} : ((fun _ => a) =ᶠ[l] fun _ => b) ↔ a = b 
Arguments: {α : Type u_1} {β : Type u_2} {l : Filter α} [l.NeBot] {a b : β}
Goal: ((fun x => a) =ᶠ[l] fun x => b) ↔ a = b
-- Filter.Germ.isConstant_coe
theorem isConstant_coe {l : Filter α} {b} (h : ∀ x', f x' = b) : (↑f : Germ l β).IsConstant 
Arguments: {α : Type u_1} {β : Type u_2} {f : α → β} {l : Filter α} {b : β} (h : ∀ (x' : α), f x' = b)
Goal: (↑f).IsConstant
-- Filter.Germ.isConstant_coe_const
@[simp]
theorem isConstant_coe_const {l : Filter α} {b : β} : (fun _ : α ↦ b : Germ l β).IsConstant 
Arguments: {α : Type u_1} {β : Type u_2} {l : Filter α} {b : β}
Goal: (↑fun x => b).IsConstant
-- Filter.Germ.isConstant_comp
lemma isConstant_comp {l : Filter α} {f : α → β} {g : β → γ}
    (h : (f : Germ l β).IsConstant) : ((g ∘ f) : Germ l γ).IsConstant 
Arguments: {α : Type u_1} {β : Type u_2} {γ : Type u_3} {l : Filter α} {f : α → β} {g : β → γ} (h : (↑f).IsConstant)
Goal: (↑(g ∘ f)).IsConstant
-- Filter.Germ.quot_mk_eq_coe
@[simp]
theorem quot_mk_eq_coe (l : Filter α) (f : α → β) : Quot.mk _ f = (f : Germ l β) 
Arguments: {α : Type u_1} {β : Type u_2} (l : Filter α) (f : α → β)
Goal: Quot.mk Setoid.r f = ↑f
-- Filter.Germ.mk'_eq_coe
@[simp]
theorem mk'_eq_coe (l : Filter α) (f : α → β) :
    @Quotient.mk' _ (germSetoid _ _) f = (f : Germ l β) 
Arguments: {α : Type u_1} {β : Type u_2} (l : Filter α) (f : α → β)
Goal: Quotient.mk' f = ↑f
-- Filter.Germ.inductionOn
@[elab_as_elim]
theorem inductionOn (f : Germ l β) {p : Germ l β → Prop} (h : ∀ f : α → β, p f) : p f 
Arguments: {α : Type u_1} {β : Type u_2} {l : Filter α} (f : l.Germ β) {p : l.Germ β → Prop} (h : ∀ (f : α → β), p ↑f)
Goal: p f
-- Filter.Germ.inductionOn₂
@[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 
Arguments: {α : Type u_1} {β : Type u_2} {γ : Type u_3} {l : Filter α} (f : l.Germ β) (g : l.Germ γ) {p : l.Germ β → l.Germ γ → Prop} (h : ∀ (f : α → β) (g : α → γ), p ↑f ↑g)
Goal: p f g
-- Filter.Germ.inductionOn₃
@[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 
Arguments: {α : Type u_1} {β : Type u_2} {γ : Type u_3} {δ : Type u_4} {l : Filter α} (f : l.Germ β) (g : l.Germ γ) (h : l.Germ δ) {p : l.Germ β → l.Germ γ → l.Germ δ → Prop} (H : ∀ (f : α → β) (g : α → γ) (h : α → δ), p ↑f ↑g ↑h)
Goal: p f g h
-- Filter.Germ.map'_coe
@[simp]
theorem map'_coe {lc : Filter γ} (F : (α → β) → γ → δ) (hF : (l.EventuallyEq ⇒ lc.EventuallyEq) F F)
    (f : α → β) : map' F hF f = F f 
Arguments: {α : Type u_1} {β : Type u_2} {γ : Type u_3} {δ : Type u_4} {l : Filter α} {lc : Filter γ} (F : (α → β) → γ → δ) (hF : (l.EventuallyEq ⇒ lc.EventuallyEq) F F) (f : α → β)
Goal: Filter.Germ.map' F hF ↑f = ↑(F f)
-- Filter.Germ.coe_eq
@[simp, norm_cast]
theorem coe_eq : (f : Germ l β) = g ↔ f =ᶠ[l] g 
Arguments: {α : Type u_1} {β : Type u_2} {l : Filter α} {f g : α → β}
Goal: ↑f = ↑g ↔ f =ᶠ[l] g
-- Filter.Germ.map_coe
@[simp]
theorem map_coe (op : β → γ) (f : α → β) : map op (f : Germ l β) = op ∘ f 
Arguments: {α : Type u_1} {β : Type u_2} {γ : Type u_3} {l : Filter α} (op : β → γ) (f : α → β)
Goal: Filter.Germ.map op ↑f = ↑(op ∘ f)
-- Filter.Germ.map_id
@[simp]
theorem map_id : map id = (id : Germ l β → Germ l β) 
Arguments: {α : Type u_1} {β : Type u_2} {l : Filter α}
Goal: Filter.Germ.map id = id
-- Filter.Germ.map_map
theorem map_map (op₁ : γ → δ) (op₂ : β → γ) (f : Germ l β) :
    map op₁ (map op₂ f) = map (op₁ ∘ op₂) f 
Arguments: {α : Type u_1} {β : Type u_2} {γ : Type u_3} {δ : Type u_4} {l : Filter α} (op₁ : γ → δ) (op₂ : β → γ) (f : l.Germ β)
Goal: Filter.Germ.map op₁ (Filter.Germ.map op₂ f) = Filter.Germ.map (op₁ ∘ op₂) f
-- Filter.Germ.map₂_coe
@[simp]
theorem map₂_coe (op : β → γ → δ) (f : α → β) (g : α → γ) :
    map₂ op (f : Germ l β) g = fun x => op (f x) (g x) 
Arguments: {α : Type u_1} {β : Type u_2} {γ : Type u_3} {δ : Type u_4} {l : Filter α} (op : β → γ → δ) (f : α → β) (g : α → γ)
Goal: Filter.Germ.map₂ op ↑f ↑g = ↑fun x => op (f x) (g x)
-- Filter.Germ.coe_tendsto
@[simp, norm_cast]
theorem coe_tendsto {f : α → β} {lb : Filter β} : (f : Germ l β).Tendsto lb ↔ Tendsto f l lb 
Arguments: {α : Type u_1} {β : Type u_2} {l : Filter α} {f : α → β} {lb : Filter β}
Goal: (↑f).Tendsto lb ↔ Filter.Tendsto f l lb
-- Filter.Germ.coe_compTendsto'
@[simp]
theorem coe_compTendsto' (f : α → β) {lc : Filter γ} {g : Germ lc α} (hg : g.Tendsto l) :
    (f : Germ l β).compTendsto' g hg = g.map f 
Arguments: {α : Type u_1} {β : Type u_2} {γ : Type u_3} {l : Filter α} (f : α → β) {lc : Filter γ} {g : lc.Germ α} (hg : g.Tendsto l)
Goal: (↑f).compTendsto' g hg = Filter.Germ.map f g
-- Filter.Germ.coe_compTendsto
@[simp]
theorem coe_compTendsto (f : α → β) {lc : Filter γ} {g : γ → α} (hg : Tendsto g lc l) :
    (f : Germ l β).compTendsto g hg = f ∘ g 
Arguments: {α : Type u_1} {β : Type u_2} {γ : Type u_3} {l : Filter α} (f : α → β) {lc : Filter γ} {g : γ → α} (hg : Filter.Tendsto g lc l)
Goal: (↑f).compTendsto g hg = ↑(f ∘ g)
-- Filter.Germ.compTendsto'_coe
@[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 
Arguments: {α : Type u_1} {β : Type u_2} {γ : Type u_3} {l : Filter α} (f : l.Germ β) {lc : Filter γ} {g : γ → α} (hg : Filter.Tendsto g lc l)
Goal: f.compTendsto' ↑g ⋯ = f.compTendsto g hg
-- Filter.Germ.Filter.Tendsto.congr_germ
theorem Filter.Tendsto.congr_germ {f g : β → γ} {l : Filter α} {l' : Filter β} (h : f =ᶠ[l'] g)
    {φ : α → β} (hφ : Tendsto φ l l') : (f ∘ φ : Germ l γ) = g ∘ φ 
Arguments: {α : Type u_1} {β : Type u_2} {γ : Type u_3} {f g : β → γ} {l : Filter α} {l' : Filter β} (h : f =ᶠ[l'] g) {φ : α → β} (hφ : Filter.Tendsto φ l l')
Goal: ↑(f ∘ φ) = ↑(g ∘ φ)
-- Filter.Germ.isConstant_comp_tendsto
lemma isConstant_comp_tendsto {lc : Filter γ} {g : γ → α}
    (hf : (f : Germ l β).IsConstant) (hg : Tendsto g lc l) : IsConstant (f ∘ g : Germ lc β) 
Arguments: {α : Type u_1} {β : Type u_2} {γ : Type u_3} {l : Filter α} {f : α → β} {lc : Filter γ} {g : γ → α} (hf : (↑f).IsConstant) (hg : Filter.Tendsto g lc l)
Goal: (↑(f ∘ g)).IsConstant
-- Filter.Germ.isConstant_compTendsto
lemma isConstant_compTendsto {f : Germ l β} {lc : Filter γ} {g : γ → α}
    (hf : f.IsConstant) (hg : Tendsto g lc l) : (f.compTendsto g hg).IsConstant 
Arguments: {α : Type u_1} {β : Type u_2} {γ : Type u_3} {l : Filter α} {f : l.Germ β} {lc : Filter γ} {g : γ → α} (hf : f.IsConstant) (hg : Filter.Tendsto g lc l)
Goal: (f.compTendsto g hg).IsConstant
-- Filter.Germ.const_inj
@[simp, norm_cast]
theorem const_inj [NeBot l] {a b : β} : (↑a : Germ l β) = ↑b ↔ a = b 
Arguments: {α : Type u_1} {β : Type u_2} {l : Filter α} [l.NeBot] {a b : β}
Goal: ↑a = ↑b ↔ a = b
-- Filter.Germ.map_const
@[simp]
theorem map_const (l : Filter α) (a : β) (f : β → γ) : (↑a : Germ l β).map f = ↑(f a) 
Arguments: {α : Type u_1} {β : Type u_2} {γ : Type u_3} (l : Filter α) (a : β) (f : β → γ)
Goal: Filter.Germ.map f ↑a = ↑(f a)
-- Filter.Germ.map₂_const
@[simp]
theorem map₂_const (l : Filter α) (b : β) (c : γ) (f : β → γ → δ) :
    map₂ f (↑b : Germ l β) ↑c = ↑(f b c) 
Arguments: {α : Type u_1} {β : Type u_2} {γ : Type u_3} {δ : Type u_4} (l : Filter α) (b : β) (c : γ) (f : β → γ → δ)
Goal: Filter.Germ.map₂ f ↑b ↑c = ↑(f b c)
-- Filter.Germ.const_compTendsto
@[simp]
theorem const_compTendsto {l : Filter α} (b : β) {lc : Filter γ} {g : γ → α} (hg : Tendsto g lc l) :
    (↑b : Germ l β).compTendsto g hg = ↑b 
Arguments: {α : Type u_1} {β : Type u_2} {γ : Type u_3} {l : Filter α} (b : β) {lc : Filter γ} {g : γ → α} (hg : Filter.Tendsto g lc l)
Goal: (↑b).compTendsto g hg = ↑b
-- Filter.Germ.const_compTendsto'
@[simp]
theorem const_compTendsto' {l : Filter α} (b : β) {lc : Filter γ} {g : Germ lc α}
    (hg : g.Tendsto l) : (↑b : Germ l β).compTendsto' g hg = ↑b 
Arguments: {α : Type u_1} {β : Type u_2} {γ : Type u_3} {l : Filter α} (b : β) {lc : Filter γ} {g : lc.Germ α} (hg : g.Tendsto l)
Goal: (↑b).compTendsto' g hg = ↑b
-- Filter.Germ.liftPred_coe
@[simp]
theorem liftPred_coe {p : β → Prop} {f : α → β} : LiftPred p (f : Germ l β) ↔ ∀ᶠ x in l, p (f x) 
Arguments: {α : Type u_1} {β : Type u_2} {l : Filter α} {p : β → Prop} {f : α → β}
Goal: Filter.Germ.LiftPred p ↑f ↔ ∀ᶠ (x : α) in l, p (f x)
-- Filter.Germ.liftPred_const
theorem liftPred_const {p : β → Prop} {x : β} (hx : p x) : LiftPred p (↑x : Germ l β) 
Arguments: {α : Type u_1} {β : Type u_2} {l : Filter α} {p : β → Prop} {x : β} (hx : p x)
Goal: Filter.Germ.LiftPred p ↑x
-- Filter.Germ.liftPred_const_iff
@[simp]
theorem liftPred_const_iff [NeBot l] {p : β → Prop} {x : β} : LiftPred p (↑x : Germ l β) ↔ p x 
Arguments: {α : Type u_1} {β : Type u_2} {l : Filter α} [l.NeBot] {p : β → Prop} {x : β}
Goal: Filter.Germ.LiftPred p ↑x ↔ p x
-- Filter.Germ.liftRel_coe
@[simp]
theorem liftRel_coe {r : β → γ → Prop} {f : α → β} {g : α → γ} :
    LiftRel r (f : Germ l β) g ↔ ∀ᶠ x in l, r (f x) (g x) 
Arguments: {α : Type u_1} {β : Type u_2} {γ : Type u_3} {l : Filter α} {r : β → γ → Prop} {f : α → β} {g : α → γ}
Goal: Filter.Germ.LiftRel r ↑f ↑g ↔ ∀ᶠ (x : α) in l, r (f x) (g x)
-- Filter.Germ.liftRel_const
theorem liftRel_const {r : β → γ → Prop} {x : β} {y : γ} (h : r x y) :
    LiftRel r (↑x : Germ l β) ↑y 
Arguments: {α : Type u_1} {β : Type u_2} {γ : Type u_3} {l : Filter α} {r : β → γ → Prop} {x : β} {y : γ} (h : r x y)
Goal: Filter.Germ.LiftRel r ↑x ↑y
-- Filter.Germ.liftRel_const_iff
@[simp]
theorem liftRel_const_iff [NeBot l] {r : β → γ → Prop} {x : β} {y : γ} :
    LiftRel r (↑x : Germ l β) ↑y ↔ r x y 
Arguments: {α : Type u_1} {β : Type u_2} {γ : Type u_3} {l : Filter α} [l.NeBot] {r : β → γ → Prop} {x : β} {y : γ}
Goal: Filter.Germ.LiftRel r ↑x ↑y ↔ r x y
-- Filter.Germ.coe_add
@[to_additive (attr := simp, norm_cast)]
theorem coe_mul [Mul M] (f g : α → M) : ↑(f * g) = (f * g : Germ l M) 
Arguments: {α : Type u_1} {l : Filter α} {M : Type u_5} [Add M] (f g : α → M)
Goal: ↑(f + g) = ↑f + ↑g
-- Filter.Germ.coe_mul
@[to_additive (attr := simp, norm_cast)]
theorem coe_mul [Mul M] (f g : α → M) : ↑(f * g) = (f * g : Germ l M) 
Arguments: {α : Type u_1} {l : Filter α} {M : Type u_5} [Mul M] (f g : α → M)
Goal: ↑(f * g) = ↑f * ↑g
-- Filter.Germ.coe_zero
@[to_additive (attr := simp, norm_cast)]
theorem coe_one [One M] : ↑(1 : α → M) = (1 : Germ l M) 
Arguments: {α : Type u_1} {l : Filter α} {M : Type u_5} [Zero M]
Goal: ↑0 = 0
-- Filter.Germ.coe_one
@[to_additive (attr := simp, norm_cast)]
theorem coe_one [One M] : ↑(1 : α → M) = (1 : Germ l M) 
Arguments: {α : Type u_1} {l : Filter α} {M : Type u_5} [One M]
Goal: ↑1 = 1
-- Filter.Germ.coe_vadd
@[to_additive (attr := simp, norm_cast)]
theorem coe_smul [SMul M G] (n : M) (f : α → G) : ↑(n • f) = n • (f : Germ l G) 
Arguments: {α : Type u_1} {l : Filter α} {M : Type u_5} {G : Type u_6} [VAdd M G] (n : M) (f : α → G)
Goal: ↑(n +ᵥ f) = n +ᵥ ↑f
-- Filter.Germ.coe_smul
@[to_additive (attr := simp, norm_cast)]
theorem coe_smul [SMul M G] (n : M) (f : α → G) : ↑(n • f) = n • (f : Germ l G) 
Arguments: {α : Type u_1} {l : Filter α} {M : Type u_5} {G : Type u_6} [SMul M G] (n : M) (f : α → G)
Goal: ↑(n • f) = n • ↑f
-- Filter.Germ.const_smul
@[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) 
Arguments: {α : Type u_1} {l : Filter α} {M : Type u_5} {G : Type u_6} [SMul M G] (n : M) (a : G)
Goal: ↑(n • a) = n • ↑a
-- Filter.Germ.const_vadd
@[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) 
Arguments: {α : Type u_1} {l : Filter α} {M : Type u_5} {G : Type u_6} [VAdd M G] (n : M) (a : G)
Goal: ↑(n +ᵥ a) = n +ᵥ ↑a
-- Filter.Germ.coe_pow
@[to_additive (attr := simp, norm_cast)]
theorem coe_pow [Pow G M] (f : α → G) (n : M) : ↑(f ^ n) = (f : Germ l G) ^ n 
Arguments: {α : Type u_1} {l : Filter α} {M : Type u_5} {G : Type u_6} [Pow G M] (f : α → G) (n : M)
Goal: ↑(f ^ n) = ↑f ^ n
-- Filter.Germ.coe_nsmul
@[to_additive (attr := simp, norm_cast)]
theorem coe_pow [Pow G M] (f : α → G) (n : M) : ↑(f ^ n) = (f : Germ l G) ^ n 
Arguments: {α : Type u_1} {l : Filter α} {M : Type u_5} {G : Type u_6} [SMul M G] (f : α → G) (n : M)
Goal: ↑(n • f) = n • ↑f