File: Mathlib/Order/Filter/Pi.lean

full_name: Filter.pi
code: /-- The product of an indexed family of filters. -/
def pi (f : ∀ i, Filter (α i)) : Filter (∀ i, α i) 
goal: Filter ((i : ι) → α i)

full_name: Filter.pi.isCountablyGenerated
code: instance pi.isCountablyGenerated [Countable ι] [∀ i, IsCountablyGenerated (f i)] :
    IsCountablyGenerated (pi f) 
goal: (Filter.pi f).IsCountablyGenerated

full_name: Filter.tendsto_eval_pi
code: theorem tendsto_eval_pi (f : ∀ i, Filter (α i)) (i : ι) : Tendsto (eval i) (pi f) (f i) 
goal: Filter.Tendsto (Function.eval i) (Filter.pi f) (f i)

full_name: Filter.tendsto_pi
code: theorem tendsto_pi {β : Type*} {m : β → ∀ i, α i} {l : Filter β} :
    Tendsto m l (pi f) ↔ ∀ i, Tendsto (fun x => m x i) l (f i) 
goal: Filter.Tendsto m l (Filter.pi f) ↔ ∀ (i : ι), Filter.Tendsto (fun x => m x i) l (f i)

full_name: Filter.le_pi
code: theorem le_pi {g : Filter (∀ i, α i)} : g ≤ pi f ↔ ∀ i, Tendsto (eval i) g (f i) 
goal: g ≤ Filter.pi f ↔ ∀ (i : ι), Filter.Tendsto (Function.eval i) g (f i)

full_name: Filter.pi_mono
code: @[mono]
theorem pi_mono (h : ∀ i, f₁ i ≤ f₂ i) : pi f₁ ≤ pi f₂ 
goal: Filter.pi f₁ ≤ Filter.pi f₂

full_name: Filter.mem_pi_of_mem
code: theorem mem_pi_of_mem (i : ι) {s : Set (α i)} (hs : s ∈ f i) : eval i ⁻¹' s ∈ pi f 
goal: Function.eval i ⁻¹' s ∈ Filter.pi f

full_name: Filter.pi_mem_pi
code: theorem pi_mem_pi {I : Set ι} (hI : I.Finite) (h : ∀ i ∈ I, s i ∈ f i) : I.pi s ∈ pi f 
goal: I.pi s ∈ Filter.pi f

full_name: Filter.mem_pi
code: 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 
goal: s ∈ Filter.pi f ↔ ∃ I, I.Finite ∧ ∃ t, (∀ (i : ι), t i ∈ f i) ∧ I.pi t ⊆ s

full_name: Filter.mem_pi'
code: 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 
goal: s ∈ Filter.pi f ↔ ∃ I t, (∀ (i : ι), t i ∈ f i) ∧ (↑I).pi t ⊆ s

full_name: Filter.mem_of_pi_mem_pi
code: 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 
goal: s i ∈ f i

full_name: Filter.pi_mem_pi_iff
code: @[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 
goal: I.pi s ∈ Filter.pi f ↔ ∀ i ∈ I, s i ∈ f i

full_name: Filter.Eventually.eval_pi
code: theorem Eventually.eval_pi {i : ι} (hf : ∀ᶠ x : α i in f i, p i x) :
    ∀ᶠ x : ∀ i : ι, α i in pi f, p i (x i) 
goal: ∀ᶠ (x : (i : ι) → α i) in Filter.pi f, p i (x i)

full_name: Filter.eventually_pi
code: theorem eventually_pi [Finite ι] (hf : ∀ i, ∀ᶠ x in f i, p i x) :
    ∀ᶠ x : ∀ i, α i in pi f, ∀ i, p i (x i) 
goal: ∀ᶠ (x : (i : ι) → α i) in Filter.pi f, ∀ (i : ι), p i (x i)

full_name: Filter.hasBasis_pi
code: 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 
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)

full_name: Filter.le_pi_principal
code: theorem le_pi_principal (s : (i : ι) → Set (α i)) :
    𝓟 (univ.pi s) ≤ pi fun i ↦ 𝓟 (s i) 
goal: 𝓟 (Set.univ.pi s) ≤ Filter.pi fun i => 𝓟 (s i)

full_name: Filter.pi_principal
code: @[simp]
theorem pi_principal [Finite ι] (s : (i : ι) → Set (α i)) :
    pi (fun i ↦ 𝓟 (s i)) = 𝓟 (univ.pi s) 
goal: (Filter.pi fun i => 𝓟 (s i)) = 𝓟 (Set.univ.pi s)

full_name: Filter.pi_pure
code: @[simp]
theorem pi_pure [Finite ι] (f : (i : ι) → α i) : pi (pure <| f ·) = pure f 
goal: (Filter.pi fun x => pure (f x)) = pure f

full_name: Filter.pi_inf_principal_univ_pi_eq_bot
code: @[simp]
theorem pi_inf_principal_univ_pi_eq_bot :
    pi f ⊓ 𝓟 (Set.pi univ s) = ⊥ ↔ ∃ i, f i ⊓ 𝓟 (s i) = ⊥ 
goal: Filter.pi f ⊓ 𝓟 (Set.univ.pi s) = ⊥ ↔ ∃ i, f i ⊓ 𝓟 (s i) = ⊥

full_name: Filter.pi_inf_principal_pi_eq_bot
code: @[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) = ⊥ 
goal: Filter.pi f ⊓ 𝓟 (I.pi s) = ⊥ ↔ ∃ i ∈ I, f i ⊓ 𝓟 (s i) = ⊥

full_name: Filter.pi_inf_principal_univ_pi_neBot
code: @[simp]
theorem pi_inf_principal_univ_pi_neBot :
    NeBot (pi f ⊓ 𝓟 (Set.pi univ s)) ↔ ∀ i, NeBot (f i ⊓ 𝓟 (s i)) 
goal: (Filter.pi f ⊓ 𝓟 (Set.univ.pi s)).NeBot ↔ ∀ (i : ι), (f i ⊓ 𝓟 (s i)).NeBot

full_name: Filter.pi_inf_principal_pi_neBot
code: @[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)) 
goal: (Filter.pi f ⊓ 𝓟 (I.pi s)).NeBot ↔ ∀ i ∈ I, (f i ⊓ 𝓟 (s i)).NeBot

full_name: Filter.PiInfPrincipalPi.neBot
code: instance PiInfPrincipalPi.neBot [h : ∀ i, NeBot (f i ⊓ 𝓟 (s i))] {I : Set ι} :
    NeBot (pi f ⊓ 𝓟 (I.pi s)) 
goal: (Filter.pi f ⊓ 𝓟 (I.pi s)).NeBot

full_name: Filter.pi_eq_bot
code: @[simp]
theorem pi_eq_bot : pi f = ⊥ ↔ ∃ i, f i = ⊥ 
goal: Filter.pi f = ⊥ ↔ ∃ i, f i = ⊥

full_name: Filter.pi_neBot
code: @[simp]
theorem pi_neBot : NeBot (pi f) ↔ ∀ i, NeBot (f i) 
goal: (Filter.pi f).NeBot ↔ ∀ (i : ι), (f i).NeBot

full_name: Filter.instNeBotForallPi
code: instance [∀ i, NeBot (f i)] : NeBot (pi f) 
goal: (Filter.pi f).NeBot

full_name: Filter.map_eval_pi
code: @[simp]
theorem map_eval_pi (f : ∀ i, Filter (α i)) [∀ i, NeBot (f i)] (i : ι) :
    map (eval i) (pi f) = f i 
goal: Filter.map (Function.eval i) (Filter.pi f) = f i

full_name: Filter.pi_le_pi
code: @[simp]
theorem pi_le_pi [∀ i, NeBot (f₁ i)] : pi f₁ ≤ pi f₂ ↔ ∀ i, f₁ i ≤ f₂ i 
goal: Filter.pi f₁ ≤ Filter.pi f₂ ↔ ∀ (i : ι), f₁ i ≤ f₂ i

full_name: Filter.pi_inj
code: @[simp]
theorem pi_inj [∀ i, NeBot (f₁ i)] : pi f₁ = pi f₂ ↔ f₁ = f₂ 
goal: Filter.pi f₁ = Filter.pi f₂ ↔ f₁ = f₂

full_name: Filter.coprodᵢ
code: /-- Coproduct of filters. -/
protected def coprodᵢ (f : ∀ i, Filter (α i)) : Filter (∀ i, α i) 
goal: Filter ((i : ι) → α i)

full_name: Filter.mem_coprodᵢ_iff
code: theorem mem_coprodᵢ_iff {s : Set (∀ i, α i)} :
    s ∈ Filter.coprodᵢ f ↔ ∀ i : ι, ∃ t₁ ∈ f i, eval i ⁻¹' t₁ ⊆ s 
goal: s ∈ Filter.coprodᵢ f ↔ ∀ (i : ι), ∃ t₁ ∈ f i, Function.eval i ⁻¹' t₁ ⊆ s

full_name: Filter.compl_mem_coprodᵢ
code: theorem compl_mem_coprodᵢ {s : Set (∀ i, α i)} :
    sᶜ ∈ Filter.coprodᵢ f ↔ ∀ i, (eval i '' s)ᶜ ∈ f i 
goal: sᶜ ∈ Filter.coprodᵢ f ↔ ∀ (i : ι), (Function.eval i '' s)ᶜ ∈ f i

full_name: Filter.coprodᵢ_neBot_iff'
code: theorem coprodᵢ_neBot_iff' :
    NeBot (Filter.coprodᵢ f) ↔ (∀ i, Nonempty (α i)) ∧ ∃ d, NeBot (f d) 
goal: (Filter.coprodᵢ f).NeBot ↔ (∀ (i : ι), Nonempty (α i)) ∧ ∃ d, (f d).NeBot

full_name: Filter.coprodᵢ_neBot_iff
code: @[simp]
theorem coprodᵢ_neBot_iff [∀ i, Nonempty (α i)] : NeBot (Filter.coprodᵢ f) ↔ ∃ d, NeBot (f d) 
goal: (Filter.coprodᵢ f).NeBot ↔ ∃ d, (f d).NeBot

full_name: Filter.coprodᵢ_eq_bot_iff'
code: theorem coprodᵢ_eq_bot_iff' : Filter.coprodᵢ f = ⊥ ↔ (∃ i, IsEmpty (α i)) ∨ f = ⊥ 
goal: Filter.coprodᵢ f = ⊥ ↔ (∃ i, IsEmpty (α i)) ∨ f = ⊥

full_name: Filter.coprodᵢ_eq_bot_iff
code: @[simp]
theorem coprodᵢ_eq_bot_iff [∀ i, Nonempty (α i)] : Filter.coprodᵢ f = ⊥ ↔ f = ⊥ 
goal: Filter.coprodᵢ f = ⊥ ↔ f = ⊥

full_name: Filter.coprodᵢ_bot'
code: @[simp] theorem coprodᵢ_bot' : Filter.coprodᵢ (⊥ : ∀ i, Filter (α i)) = ⊥ 
goal: Filter.coprodᵢ ⊥ = ⊥

full_name: Filter.coprodᵢ_bot
code: @[simp]
theorem coprodᵢ_bot : Filter.coprodᵢ (fun _ => ⊥ : ∀ i, Filter (α i)) = ⊥ 
goal: (Filter.coprodᵢ fun x => ⊥) = ⊥

full_name: Filter.NeBot.coprodᵢ
code: theorem NeBot.coprodᵢ [∀ i, Nonempty (α i)] {i : ι} (h : NeBot (f i)) : NeBot (Filter.coprodᵢ f) 
goal: (Filter.coprodᵢ f).NeBot

full_name: Filter.coprodᵢ_neBot
code: @[instance]
theorem coprodᵢ_neBot [∀ i, Nonempty (α i)] [Nonempty ι] (f : ∀ i, Filter (α i))
    [H : ∀ i, NeBot (f i)] : NeBot (Filter.coprodᵢ f) 
goal: (Filter.coprodᵢ f).NeBot

full_name: Filter.coprodᵢ_mono
code: @[mono]
theorem coprodᵢ_mono (hf : ∀ i, f₁ i ≤ f₂ i) : Filter.coprodᵢ f₁ ≤ Filter.coprodᵢ f₂ 
goal: Filter.coprodᵢ f₁ ≤ Filter.coprodᵢ f₂

full_name: Filter.map_pi_map_coprodᵢ_le
code: 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) 
goal: Filter.map (fun k i => m i (k i)) (Filter.coprodᵢ f) ≤ Filter.coprodᵢ fun i => Filter.map (m i) (f i)

full_name: Filter.Tendsto.pi_map_coprodᵢ
code: 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) 
goal: Filter.Tendsto (fun k i => m i (k i)) (Filter.coprodᵢ f) (Filter.coprodᵢ g)