[GOAL]
α : Type u
f g : Filter α
s t : Set α
⊢ f = g ↔ ∀ (s : Set α), s ∈ f ↔ s ∈ g
[PROOFSTEP]
simp only [filter_eq_iff, ext_iff, Filter.mem_sets]
[GOAL]
α : Type u
f g : Filter α
s✝ t : Set α
β : Type v
s : β → Set α
is : Set β
hf : Set.Finite is
⊢ ⋂ (i : β) (_ : i ∈ ∅), s i ∈ f ↔ ∀ (i : β), i ∈ ∅ → s i ∈ f
[PROOFSTEP]
simp
[GOAL]
α : Type u
f g : Filter α
s✝¹ t : Set α
β : Type v
s : β → Set α
is : Set β
hf : Set.Finite is
a✝ : β
s✝ : Set β
x✝¹ : ¬a✝ ∈ s✝
x✝ : Set.Finite s✝
hs : ⋂ (i : β) (_ : i ∈ s✝), s i ∈ f ↔ ∀ (i : β), i ∈ s✝ → s i ∈ f
⊢ ⋂ (i : β) (_ : i ∈ insert a✝ s✝), s i ∈ f ↔ ∀ (i : β), i ∈ insert a✝ s✝ → s i ∈ f
[PROOFSTEP]
simp [hs]
[GOAL]
α : Type u
f g : Filter α
s✝ t : Set α
s : Set (Set α)
hfin : Set.Finite s
⊢ ⋂₀ s ∈ f ↔ ∀ (U : Set α), U ∈ s → U ∈ f
[PROOFSTEP]
rw [sInter_eq_biInter, biInter_mem hfin]
[GOAL]
α : Type u
f g : Filter α
s t : Set α
P Q : Set α → Prop
hP : Antitone P
hQ : Antitone Q
⊢ ((∃ u, u ∈ f ∧ P u) ∧ ∃ u, u ∈ f ∧ Q u) ↔ ∃ u, u ∈ f ∧ P u ∧ Q u
[PROOFSTEP]
constructor
[GOAL]
case mp
α : Type u
f g : Filter α
s t : Set α
P Q : Set α → Prop
hP : Antitone P
hQ : Antitone Q
⊢ ((∃ u, u ∈ f ∧ P u) ∧ ∃ u, u ∈ f ∧ Q u) → ∃ u, u ∈ f ∧ P u ∧ Q u
[PROOFSTEP]
rintro ⟨⟨u, huf, hPu⟩, v, hvf, hQv⟩
[GOAL]
case mp.intro.intro.intro.intro.intro
α : Type u
f g : Filter α
s t : Set α
P Q : Set α → Prop
hP : Antitone P
hQ : Antitone Q
u : Set α
huf : u ∈ f
hPu : P u
v : Set α
hvf : v ∈ f
hQv : Q v
⊢ ∃ u, u ∈ f ∧ P u ∧ Q u
[PROOFSTEP]
exact ⟨u ∩ v, inter_mem huf hvf, hP (inter_subset_left _ _) hPu, hQ (inter_subset_right _ _) hQv⟩
[GOAL]
case mpr
α : Type u
f g : Filter α
s t : Set α
P Q : Set α → Prop
hP : Antitone P
hQ : Antitone Q
⊢ (∃ u, u ∈ f ∧ P u ∧ Q u) → (∃ u, u ∈ f ∧ P u) ∧ ∃ u, u ∈ f ∧ Q u
[PROOFSTEP]
rintro ⟨u, huf, hPu, hQu⟩
[GOAL]
case mpr.intro.intro.intro
α : Type u
f g : Filter α
s t : Set α
P Q : Set α → Prop
hP : Antitone P
hQ : Antitone Q
u : Set α
huf : u ∈ f
hPu : P u
hQu : Q u
⊢ (∃ u, u ∈ f ∧ P u) ∧ ∃ u, u ∈ f ∧ Q u
[PROOFSTEP]
exact ⟨⟨u, huf, hPu⟩, u, huf, hQu⟩
[GOAL]
α : Type u
β : Type v
γ : Type w
δ : Type u_1
ι : Sort x
f : Filter (Filter α)
⊢ univ ∈ {s | {t | s ∈ t} ∈ f}
[PROOFSTEP]
simp only [mem_setOf_eq, univ_sets, ← Filter.mem_sets, setOf_true]
[GOAL]
α : Type u
β : Type v
γ : Type w
δ : Type u_1
ι : Sort x
f g : Filter α
s t : Set α
⊢ ¬f ≤ g ↔ ∃ s, s ∈ g ∧ ¬s ∈ f
[PROOFSTEP]
simp_rw [le_def, not_forall, exists_prop]
[GOAL]
α : Type u
β : Type v
γ : Type w
δ : Type u_1
ι : Sort x
f g : Filter α
s✝ t : Set α
s : Set (Set α)
U : Set α
⊢ U ∈ generate s ↔ ∃ t x, Set.Finite t ∧ ⋂₀ t ⊆ U
[PROOFSTEP]
constructor
[GOAL]
case mp
α : Type u
β : Type v
γ : Type w
δ : Type u_1
ι : Sort x
f g : Filter α
s✝ t : Set α
s : Set (Set α)
U : Set α
⊢ U ∈ generate s → ∃ t x, Set.Finite t ∧ ⋂₀ t ⊆ U
[PROOFSTEP]
intro h
[GOAL]
case mpr
α : Type u
β : Type v
γ : Type w
δ : Type u_1
ι : Sort x
f g : Filter α
s✝ t : Set α
s : Set (Set α)
U : Set α
⊢ (∃ t x, Set.Finite t ∧ ⋂₀ t ⊆ U) → U ∈ generate s
[PROOFSTEP]
intro h
[GOAL]
case mp
α : Type u
β : Type v
γ : Type w
δ : Type u_1
ι : Sort x
f g : Filter α
s✝ t : Set α
s : Set (Set α)
U : Set α
h : U ∈ generate s
⊢ ∃ t x, Set.Finite t ∧ ⋂₀ t ⊆ U
[PROOFSTEP]
induction h
[GOAL]
case mp.basic
α : Type u
β : Type v
γ : Type w
δ : Type u_1
ι : Sort x
f g : Filter α
s✝¹ t : Set α
s : Set (Set α)
U s✝ : Set α
a✝ : s✝ ∈ s
⊢ ∃ t x, Set.Finite t ∧ ⋂₀ t ⊆ s✝
case mp.univ
α : Type u
β : Type v
γ : Type w
δ : Type u_1
ι : Sort x
f g : Filter α
s✝ t : Set α
s : Set (Set α)
U : Set α
⊢ ∃ t x, Set.Finite t ∧ ⋂₀ t ⊆ univ
case mp.superset
α : Type u
β : Type v
γ : Type w
δ : Type u_1
ι : Sort x
f g : Filter α
s✝¹ t : Set α
s : Set (Set α)
U s✝ t✝ : Set α
a✝¹ : GenerateSets s s✝
a✝ : s✝ ⊆ t✝
a_ih✝ : ∃ t x, Set.Finite t ∧ ⋂₀ t ⊆ s✝
⊢ ∃ t x, Set.Finite t ∧ ⋂₀ t ⊆ t✝
case mp.inter
α : Type u
β : Type v
γ : Type w
δ : Type u_1
ι : Sort x
f g : Filter α
s✝¹ t : Set α
s : Set (Set α)
U s✝ t✝ : Set α
a✝¹ : GenerateSets s s✝
a✝ : GenerateSets s t✝
a_ih✝¹ : ∃ t x, Set.Finite t ∧ ⋂₀ t ⊆ s✝
a_ih✝ : ∃ t x, Set.Finite t ∧ ⋂₀ t ⊆ t✝
⊢ ∃ t x, Set.Finite t ∧ ⋂₀ t ⊆ s✝ ∩ t✝
[PROOFSTEP]
case basic V V_in => exact ⟨{ V }, singleton_subset_iff.2 V_in, finite_singleton _, (sInter_singleton _).subset⟩
[GOAL]
α : Type u
β : Type v
γ : Type w
δ : Type u_1
ι : Sort x
f g : Filter α
s✝ t : Set α
s : Set (Set α)
U V : Set α
V_in : V ∈ s
⊢ ∃ t x, Set.Finite t ∧ ⋂₀ t ⊆ V
[PROOFSTEP]
case basic V V_in => exact ⟨{ V }, singleton_subset_iff.2 V_in, finite_singleton _, (sInter_singleton _).subset⟩
[GOAL]
α : Type u
β : Type v
γ : Type w
δ : Type u_1
ι : Sort x
f g : Filter α
s✝ t : Set α
s : Set (Set α)
U V : Set α
V_in : V ∈ s
⊢ ∃ t x, Set.Finite t ∧ ⋂₀ t ⊆ V
[PROOFSTEP]
exact ⟨{ V }, singleton_subset_iff.2 V_in, finite_singleton _, (sInter_singleton _).subset⟩
[GOAL]
case mp.univ
α : Type u
β : Type v
γ : Type w
δ : Type u_1
ι : Sort x
f g : Filter α
s✝ t : Set α
s : Set (Set α)
U : Set α
⊢ ∃ t x, Set.Finite t ∧ ⋂₀ t ⊆ univ
case mp.superset
α : Type u
β : Type v
γ : Type w
δ : Type u_1
ι : Sort x
f g : Filter α
s✝¹ t : Set α
s : Set (Set α)
U s✝ t✝ : Set α
a✝¹ : GenerateSets s s✝
a✝ : s✝ ⊆ t✝
a_ih✝ : ∃ t x, Set.Finite t ∧ ⋂₀ t ⊆ s✝
⊢ ∃ t x, Set.Finite t ∧ ⋂₀ t ⊆ t✝
case mp.inter
α : Type u
β : Type v
γ : Type w
δ : Type u_1
ι : Sort x
f g : Filter α
s✝¹ t : Set α
s : Set (Set α)
U s✝ t✝ : Set α
a✝¹ : GenerateSets s s✝
a✝ : GenerateSets s t✝
a_ih✝¹ : ∃ t x, Set.Finite t ∧ ⋂₀ t ⊆ s✝
a_ih✝ : ∃ t x, Set.Finite t ∧ ⋂₀ t ⊆ t✝
⊢ ∃ t x, Set.Finite t ∧ ⋂₀ t ⊆ s✝ ∩ t✝
[PROOFSTEP]
case univ => exact ⟨∅, empty_subset _, finite_empty, subset_univ _⟩
[GOAL]
α : Type u
β : Type v
γ : Type w
δ : Type u_1
ι : Sort x
f g : Filter α
s✝ t : Set α
s : Set (Set α)
U : Set α
⊢ ∃ t x, Set.Finite t ∧ ⋂₀ t ⊆ univ
[PROOFSTEP]
case univ => exact ⟨∅, empty_subset _, finite_empty, subset_univ _⟩
[GOAL]
α : Type u
β : Type v
γ : Type w
δ : Type u_1
ι : Sort x
f g : Filter α
s✝ t : Set α
s : Set (Set α)
U : Set α
⊢ ∃ t x, Set.Finite t ∧ ⋂₀ t ⊆ univ
[PROOFSTEP]
exact ⟨∅, empty_subset _, finite_empty, subset_univ _⟩
[GOAL]
case mp.superset
α : Type u
β : Type v
γ : Type w
δ : Type u_1
ι : Sort x
f g : Filter α
s✝¹ t : Set α
s : Set (Set α)
U s✝ t✝ : Set α
a✝¹ : GenerateSets s s✝
a✝ : s✝ ⊆ t✝
a_ih✝ : ∃ t x, Set.Finite t ∧ ⋂₀ t ⊆ s✝
⊢ ∃ t x, Set.Finite t ∧ ⋂₀ t ⊆ t✝
case mp.inter
α : Type u
β : Type v
γ : Type w
δ : Type u_1
ι : Sort x
f g : Filter α
s✝¹ t : Set α
s : Set (Set α)
U s✝ t✝ : Set α
a✝¹ : GenerateSets s s✝
a✝ : GenerateSets s t✝
a_ih✝¹ : ∃ t x, Set.Finite t ∧ ⋂₀ t ⊆ s✝
a_ih✝ : ∃ t x, Set.Finite t ∧ ⋂₀ t ⊆ t✝
⊢ ∃ t x, Set.Finite t ∧ ⋂₀ t ⊆ s✝ ∩ t✝
[PROOFSTEP]
case superset V W _ hVW hV =>
  rcases hV with ⟨t, hts, ht, htV⟩
  exact ⟨t, hts, ht, htV.trans hVW⟩
[GOAL]
α : Type u
β : Type v
γ : Type w
δ : Type u_1
ι : Sort x
f g : Filter α
s✝ t : Set α
s : Set (Set α)
U V W : Set α
a✝ : GenerateSets s V
hVW : V ⊆ W
hV : ∃ t x, Set.Finite t ∧ ⋂₀ t ⊆ V
⊢ ∃ t x, Set.Finite t ∧ ⋂₀ t ⊆ W
[PROOFSTEP]
case superset V W _ hVW hV =>
  rcases hV with ⟨t, hts, ht, htV⟩
  exact ⟨t, hts, ht, htV.trans hVW⟩
[GOAL]
α : Type u
β : Type v
γ : Type w
δ : Type u_1
ι : Sort x
f g : Filter α
s✝ t : Set α
s : Set (Set α)
U V W : Set α
a✝ : GenerateSets s V
hVW : V ⊆ W
hV : ∃ t x, Set.Finite t ∧ ⋂₀ t ⊆ V
⊢ ∃ t x, Set.Finite t ∧ ⋂₀ t ⊆ W
[PROOFSTEP]
rcases hV with ⟨t, hts, ht, htV⟩
[GOAL]
case intro.intro.intro
α : Type u
β : Type v
γ : Type w
δ : Type u_1
ι : Sort x
f g : Filter α
s✝ t✝ : Set α
s : Set (Set α)
U V W : Set α
a✝ : GenerateSets s V
hVW : V ⊆ W
t : Set (Set α)
hts : t ⊆ s
ht : Set.Finite t
htV : ⋂₀ t ⊆ V
⊢ ∃ t x, Set.Finite t ∧ ⋂₀ t ⊆ W
[PROOFSTEP]
exact ⟨t, hts, ht, htV.trans hVW⟩
[GOAL]
case mp.inter
α : Type u
β : Type v
γ : Type w
δ : Type u_1
ι : Sort x
f g : Filter α
s✝¹ t : Set α
s : Set (Set α)
U s✝ t✝ : Set α
a✝¹ : GenerateSets s s✝
a✝ : GenerateSets s t✝
a_ih✝¹ : ∃ t x, Set.Finite t ∧ ⋂₀ t ⊆ s✝
a_ih✝ : ∃ t x, Set.Finite t ∧ ⋂₀ t ⊆ t✝
⊢ ∃ t x, Set.Finite t ∧ ⋂₀ t ⊆ s✝ ∩ t✝
[PROOFSTEP]
case inter V W _ _ hV hW =>
  rcases hV, hW with ⟨⟨t, hts, ht, htV⟩, u, hus, hu, huW⟩
  exact ⟨t ∪ u, union_subset hts hus, ht.union hu, (sInter_union _ _).subset.trans <| inter_subset_inter htV huW⟩
[GOAL]
α : Type u
β : Type v
γ : Type w
δ : Type u_1
ι : Sort x
f g : Filter α
s✝ t : Set α
s : Set (Set α)
U V W : Set α
a✝¹ : GenerateSets s V
a✝ : GenerateSets s W
hV : ∃ t x, Set.Finite t ∧ ⋂₀ t ⊆ V
hW : ∃ t x, Set.Finite t ∧ ⋂₀ t ⊆ W
⊢ ∃ t x, Set.Finite t ∧ ⋂₀ t ⊆ V ∩ W
[PROOFSTEP]
case inter V W _ _ hV hW =>
  rcases hV, hW with ⟨⟨t, hts, ht, htV⟩, u, hus, hu, huW⟩
  exact ⟨t ∪ u, union_subset hts hus, ht.union hu, (sInter_union _ _).subset.trans <| inter_subset_inter htV huW⟩
[GOAL]
α : Type u
β : Type v
γ : Type w
δ : Type u_1
ι : Sort x
f g : Filter α
s✝ t : Set α
s : Set (Set α)
U V W : Set α
a✝¹ : GenerateSets s V
a✝ : GenerateSets s W
hV : ∃ t x, Set.Finite t ∧ ⋂₀ t ⊆ V
hW : ∃ t x, Set.Finite t ∧ ⋂₀ t ⊆ W
⊢ ∃ t x, Set.Finite t ∧ ⋂₀ t ⊆ V ∩ W
[PROOFSTEP]
rcases hV, hW with ⟨⟨t, hts, ht, htV⟩, u, hus, hu, huW⟩
[GOAL]
case intro.intro.intro.intro.intro.intro
α : Type u
β : Type v
γ : Type w
δ : Type u_1
ι : Sort x
f g : Filter α
s✝ t✝ : Set α
s : Set (Set α)
U V W : Set α
a✝¹ : GenerateSets s V
a✝ : GenerateSets s W
t : Set (Set α)
hts : t ⊆ s
ht : Set.Finite t
htV : ⋂₀ t ⊆ V
u : Set (Set α)
hus : u ⊆ s
hu : Set.Finite u
huW : ⋂₀ u ⊆ W
⊢ ∃ t x, Set.Finite t ∧ ⋂₀ t ⊆ V ∩ W
[PROOFSTEP]
exact ⟨t ∪ u, union_subset hts hus, ht.union hu, (sInter_union _ _).subset.trans <| inter_subset_inter htV huW⟩
[GOAL]
case mpr
α : Type u
β : Type v
γ : Type w
δ : Type u_1
ι : Sort x
f g : Filter α
s✝ t : Set α
s : Set (Set α)
U : Set α
h : ∃ t x, Set.Finite t ∧ ⋂₀ t ⊆ U
⊢ U ∈ generate s
[PROOFSTEP]
rcases h with ⟨t, hts, tfin, h⟩
[GOAL]
case mpr.intro.intro.intro
α : Type u
β : Type v
γ : Type w
δ : Type u_1
ι : Sort x
f g : Filter α
s✝ t✝ : Set α
s : Set (Set α)
U : Set α
t : Set (Set α)
hts : t ⊆ s
tfin : Set.Finite t
h : ⋂₀ t ⊆ U
⊢ U ∈ generate s
[PROOFSTEP]
exact mem_of_superset ((sInter_mem tfin).2 fun V hV => GenerateSets.basic <| hts hV) h
[GOAL]
α : Type u
β : Type v
γ : Type w
δ : Type u_1
ι : Sort x
f✝ g✝ : Filter α
s t : Set α
f g : Filter α
⊢ univ = univ ∩ univ
[PROOFSTEP]
simp
[GOAL]
α : Type u
β : Type v
γ : Type w
δ : Type u_1
ι : Sort x
f✝ g✝ : Filter α
s t : Set α
f g : Filter α
⊢ ∀ {x y : Set α}, x ∈ {s | ∃ a, a ∈ f ∧ ∃ b, b ∈ g ∧ s = a ∩ b} → x ⊆ y → y ∈ {s | ∃ a, a ∈ f ∧ ∃ b, b ∈ g ∧ s = a ∩ b}
[PROOFSTEP]
rintro x y ⟨a, ha, b, hb, rfl⟩ xy
[GOAL]
case intro.intro.intro.intro
α : Type u
β : Type v
γ : Type w
δ : Type u_1
ι : Sort x
f✝ g✝ : Filter α
s t : Set α
f g : Filter α
y a : Set α
ha : a ∈ f
b : Set α
hb : b ∈ g
xy : a ∩ b ⊆ y
⊢ y ∈ {s | ∃ a, a ∈ f ∧ ∃ b, b ∈ g ∧ s = a ∩ b}
[PROOFSTEP]
refine' ⟨a ∪ y, mem_of_superset ha (subset_union_left a y), b ∪ y, mem_of_superset hb (subset_union_left b y), _⟩
[GOAL]
case intro.intro.intro.intro
α : Type u
β : Type v
γ : Type w
δ : Type u_1
ι : Sort x
f✝ g✝ : Filter α
s t : Set α
f g : Filter α
y a : Set α
ha : a ∈ f
b : Set α
hb : b ∈ g
xy : a ∩ b ⊆ y
⊢ y = (a ∪ y) ∩ (b ∪ y)
[PROOFSTEP]
rw [← inter_union_distrib_right, union_eq_self_of_subset_left xy]
[GOAL]
α : Type u
β : Type v
γ : Type w
δ : Type u_1
ι : Sort x
f✝ g✝ : Filter α
s t : Set α
f g : Filter α
⊢ ∀ {x y : Set α},
    x ∈ {s | ∃ a, a ∈ f ∧ ∃ b, b ∈ g ∧ s = a ∩ b} →
      y ∈ {s | ∃ a, a ∈ f ∧ ∃ b, b ∈ g ∧ s = a ∩ b} → x ∩ y ∈ {s | ∃ a, a ∈ f ∧ ∃ b, b ∈ g ∧ s = a ∩ b}
[PROOFSTEP]
rintro x y ⟨a, ha, b, hb, rfl⟩ ⟨c, hc, d, hd, rfl⟩
[GOAL]
case intro.intro.intro.intro.intro.intro.intro.intro
α : Type u
β : Type v
γ : Type w
δ : Type u_1
ι : Sort x
f✝ g✝ : Filter α
s t : Set α
f g : Filter α
a : Set α
ha : a ∈ f
b : Set α
hb : b ∈ g
c : Set α
hc : c ∈ f
d : Set α
hd : d ∈ g
⊢ a ∩ b ∩ (c ∩ d) ∈ {s | ∃ a, a ∈ f ∧ ∃ b, b ∈ g ∧ s = a ∩ b}
[PROOFSTEP]
refine' ⟨a ∩ c, inter_mem ha hc, b ∩ d, inter_mem hb hd, _⟩
[GOAL]
case intro.intro.intro.intro.intro.intro.intro.intro
α : Type u
β : Type v
γ : Type w
δ : Type u_1
ι : Sort x
f✝ g✝ : Filter α
s t : Set α
f g : Filter α
a : Set α
ha : a ∈ f
b : Set α
hb : b ∈ g
c : Set α
hc : c ∈ f
d : Set α
hd : d ∈ g
⊢ a ∩ b ∩ (c ∩ d) = a ∩ c ∩ (b ∩ d)
[PROOFSTEP]
ac_rfl
[GOAL]
α : Type u
β : Type v
γ : Type w
δ : Type u_1
ι : Sort x
f g : Filter α
s✝ t s : Set α
⊢ s ∈ ⊤ ↔ s = univ
[PROOFSTEP]
rw [mem_top_iff_forall, eq_univ_iff_forall]
[GOAL]
α : Type u
β : Type v
γ : Type w
δ : Type u_1
ι : Sort x
f✝ g✝ : Filter α
s t : Set α
f g : Filter α
⊢ NeBot (f ⊔ g) ↔ NeBot f ∨ NeBot g
[PROOFSTEP]
simp only [neBot_iff, not_and_or, Ne.def, sup_eq_bot_iff]
[GOAL]
α : Type u
β : Type v
γ : Type w
δ : Type u_1
ι : Sort x
f g : Filter α
s t : Set α
⊢ ¬Disjoint f f ↔ NeBot f
[PROOFSTEP]
rw [disjoint_self, neBot_iff]
[GOAL]
α : Type u
β : Type v
γ : Type w
δ : Type u_1
ι : Sort x
f✝ g : Filter α
s t x : Set α
f : ι → Filter α
⊢ x ∈ iSup f ↔ ∀ (i : ι), x ∈ f i
[PROOFSTEP]
simp only [← Filter.mem_sets, iSup_sets_eq, iff_self_iff, mem_iInter]
[GOAL]
α : Type u
β : Type v
γ : Type w
δ : Type u_1
ι : Sort x
f✝ g : Filter α
s t : Set α
f : ι → Filter α
⊢ NeBot (⨆ (i : ι), f i) ↔ ∃ i, NeBot (f i)
[PROOFSTEP]
simp [neBot_iff]
[GOAL]
α : Type u
β : Type v
γ : Type w
δ : Type u_1
ι✝ : Sort x
f g : Filter α
s✝ t : Set α
ι : Type u_2
s : ι → Filter α
U : Set α
I : Set ι
I_fin : Set.Finite I
V : ↑I → Set α
hV : ∀ (i : ↑I), V i ∈ s ↑i
hU : ⋂ (i : ↑I), V i ⊆ U
⊢ U ∈ ⨅ (i : ι), s i
[PROOFSTEP]
haveI := I_fin.fintype
[GOAL]
α : Type u
β : Type v
γ : Type w
δ : Type u_1
ι✝ : Sort x
f g : Filter α
s✝ t : Set α
ι : Type u_2
s : ι → Filter α
U : Set α
I : Set ι
I_fin : Set.Finite I
V : ↑I → Set α
hV : ∀ (i : ↑I), V i ∈ s ↑i
hU : ⋂ (i : ↑I), V i ⊆ U
this : Fintype ↑I
⊢ U ∈ ⨅ (i : ι), s i
[PROOFSTEP]
refine' mem_of_superset (iInter_mem.2 fun i => _) hU
[GOAL]
α : Type u
β : Type v
γ : Type w
δ : Type u_1
ι✝ : Sort x
f g : Filter α
s✝ t : Set α
ι : Type u_2
s : ι → Filter α
U : Set α
I : Set ι
I_fin : Set.Finite I
V : ↑I → Set α
hV : ∀ (i : ↑I), V i ∈ s ↑i
hU : ⋂ (i : ↑I), V i ⊆ U
this : Fintype ↑I
i : ↑I
⊢ V i ∈ ⨅ (i : ι), s i
[PROOFSTEP]
exact mem_iInf_of_mem (i : ι) (hV _)
[GOAL]
α : Type u
β : Type v
γ : Type w
δ : Type u_1
ι✝ : Sort x
f g : Filter α
s✝ t : Set α
ι : Type u_2
s : ι → Filter α
U : Set α
⊢ U ∈ ⨅ (i : ι), s i ↔ ∃ I, Set.Finite I ∧ ∃ V, (∀ (i : ↑I), V i ∈ s ↑i) ∧ U = ⋂ (i : ↑I), V i
[PROOFSTEP]
constructor
[GOAL]
case mp
α : Type u
β : Type v
γ : Type w
δ : Type u_1
ι✝ : Sort x
f g : Filter α
s✝ t : Set α
ι : Type u_2
s : ι → Filter α
U : Set α
⊢ U ∈ ⨅ (i : ι), s i → ∃ I, Set.Finite I ∧ ∃ V, (∀ (i : ↑I), V i ∈ s ↑i) ∧ U = ⋂ (i : ↑I), V i
[PROOFSTEP]
rw [iInf_eq_generate, mem_generate_iff]
[GOAL]
case mp
α : Type u
β : Type v
γ : Type w
δ : Type u_1
ι✝ : Sort x
f g : Filter α
s✝ t : Set α
ι : Type u_2
s : ι → Filter α
U : Set α
⊢ (∃ t x, Set.Finite t ∧ ⋂₀ t ⊆ U) → ∃ I, Set.Finite I ∧ ∃ V, (∀ (i : ↑I), V i ∈ s ↑i) ∧ U = ⋂ (i : ↑I), V i
[PROOFSTEP]
rintro ⟨t, tsub, tfin, tinter⟩
[GOAL]
case mp.intro.intro.intro
α : Type u
β : Type v
γ : Type w
δ : Type u_1
ι✝ : Sort x
f g : Filter α
s✝ t✝ : Set α
ι : Type u_2
s : ι → Filter α
U : Set α
t : Set (Set α)
tsub : t ⊆ ⋃ (i : ι), (s i).sets
tfin : Set.Finite t
tinter : ⋂₀ t ⊆ U
⊢ ∃ I, Set.Finite I ∧ ∃ V, (∀ (i : ↑I), V i ∈ s ↑i) ∧ U = ⋂ (i : ↑I), V i
[PROOFSTEP]
rcases eq_finite_iUnion_of_finite_subset_iUnion tfin tsub with ⟨I, Ifin, σ, σfin, σsub, rfl⟩
[GOAL]
case mp.intro.intro.intro.intro.intro.intro.intro.intro
α : Type u
β : Type v
γ : Type w
δ : Type u_1
ι✝ : Sort x
f g : Filter α
s✝ t : Set α
ι : Type u_2
s : ι → Filter α
U : Set α
I : Set ι
Ifin : Set.Finite I
σ : ↑{i | i ∈ I} → Set (Set α)
σfin : ∀ (i : ↑{i | i ∈ I}), Set.Finite (σ i)
σsub : ∀ (i : ↑{i | i ∈ I}), σ i ⊆ (s ↑i).sets
tsub : ⋃ (i : ↑{i | i ∈ I}), σ i ⊆ ⋃ (i : ι), (s i).sets
tfin : Set.Finite (⋃ (i : ↑{i | i ∈ I}), σ i)
tinter : ⋂₀ ⋃ (i : ↑{i | i ∈ I}), σ i ⊆ U
⊢ ∃ I, Set.Finite I ∧ ∃ V, (∀ (i : ↑I), V i ∈ s ↑i) ∧ U = ⋂ (i : ↑I), V i
[PROOFSTEP]
rw [sInter_iUnion] at tinter
[GOAL]
case mp.intro.intro.intro.intro.intro.intro.intro.intro
α : Type u
β : Type v
γ : Type w
δ : Type u_1
ι✝ : Sort x
f g : Filter α
s✝ t : Set α
ι : Type u_2
s : ι → Filter α
U : Set α
I : Set ι
Ifin : Set.Finite I
σ : ↑{i | i ∈ I} → Set (Set α)
σfin : ∀ (i : ↑{i | i ∈ I}), Set.Finite (σ i)
σsub : ∀ (i : ↑{i | i ∈ I}), σ i ⊆ (s ↑i).sets
tsub : ⋃ (i : ↑{i | i ∈ I}), σ i ⊆ ⋃ (i : ι), (s i).sets
tfin : Set.Finite (⋃ (i : ↑{i | i ∈ I}), σ i)
tinter : ⋂ (i : ↑{i | i ∈ I}), ⋂₀ σ i ⊆ U
⊢ ∃ I, Set.Finite I ∧ ∃ V, (∀ (i : ↑I), V i ∈ s ↑i) ∧ U = ⋂ (i : ↑I), V i
[PROOFSTEP]
set V := fun i => U ∪ ⋂₀ σ i with hV
[GOAL]
case mp.intro.intro.intro.intro.intro.intro.intro.intro
α : Type u
β : Type v
γ : Type w
δ : Type u_1
ι✝ : Sort x
f g : Filter α
s✝ t : Set α
ι : Type u_2
s : ι → Filter α
U : Set α
I : Set ι
Ifin : Set.Finite I
σ : ↑{i | i ∈ I} → Set (Set α)
σfin : ∀ (i : ↑{i | i ∈ I}), Set.Finite (σ i)
σsub : ∀ (i : ↑{i | i ∈ I}), σ i ⊆ (s ↑i).sets
tsub : ⋃ (i : ↑{i | i ∈ I}), σ i ⊆ ⋃ (i : ι), (s i).sets
tfin : Set.Finite (⋃ (i : ↑{i | i ∈ I}), σ i)
tinter : ⋂ (i : ↑{i | i ∈ I}), ⋂₀ σ i ⊆ U
V : ↑{i | i ∈ I} → Set α := fun i => U ∪ ⋂₀ σ i
hV : V = fun i => U ∪ ⋂₀ σ i
⊢ ∃ I, Set.Finite I ∧ ∃ V, (∀ (i : ↑I), V i ∈ s ↑i) ∧ U = ⋂ (i : ↑I), V i
[PROOFSTEP]
have V_in : ∀ i, V i ∈ s i := by
  rintro i
  have : ⋂₀ σ i ∈ s i := by
    rw [sInter_mem (σfin _)]
    apply σsub
  exact mem_of_superset this (subset_union_right _ _)
[GOAL]
α : Type u
β : Type v
γ : Type w
δ : Type u_1
ι✝ : Sort x
f g : Filter α
s✝ t : Set α
ι : Type u_2
s : ι → Filter α
U : Set α
I : Set ι
Ifin : Set.Finite I
σ : ↑{i | i ∈ I} → Set (Set α)
σfin : ∀ (i : ↑{i | i ∈ I}), Set.Finite (σ i)
σsub : ∀ (i : ↑{i | i ∈ I}), σ i ⊆ (s ↑i).sets
tsub : ⋃ (i : ↑{i | i ∈ I}), σ i ⊆ ⋃ (i : ι), (s i).sets
tfin : Set.Finite (⋃ (i : ↑{i | i ∈ I}), σ i)
tinter : ⋂ (i : ↑{i | i ∈ I}), ⋂₀ σ i ⊆ U
V : ↑{i | i ∈ I} → Set α := fun i => U ∪ ⋂₀ σ i
hV : V = fun i => U ∪ ⋂₀ σ i
⊢ ∀ (i : ↑{i | i ∈ I}), V i ∈ s ↑i
[PROOFSTEP]
rintro i
[GOAL]
α : Type u
β : Type v
γ : Type w
δ : Type u_1
ι✝ : Sort x
f g : Filter α
s✝ t : Set α
ι : Type u_2
s : ι → Filter α
U : Set α
I : Set ι
Ifin : Set.Finite I
σ : ↑{i | i ∈ I} → Set (Set α)
σfin : ∀ (i : ↑{i | i ∈ I}), Set.Finite (σ i)
σsub : ∀ (i : ↑{i | i ∈ I}), σ i ⊆ (s ↑i).sets
tsub : ⋃ (i : ↑{i | i ∈ I}), σ i ⊆ ⋃ (i : ι), (s i).sets
tfin : Set.Finite (⋃ (i : ↑{i | i ∈ I}), σ i)
tinter : ⋂ (i : ↑{i | i ∈ I}), ⋂₀ σ i ⊆ U
V : ↑{i | i ∈ I} → Set α := fun i => U ∪ ⋂₀ σ i
hV : V = fun i => U ∪ ⋂₀ σ i
i : ↑{i | i ∈ I}
⊢ V i ∈ s ↑i
[PROOFSTEP]
have : ⋂₀ σ i ∈ s i := by
  rw [sInter_mem (σfin _)]
  apply σsub
[GOAL]
α : Type u
β : Type v
γ : Type w
δ : Type u_1
ι✝ : Sort x
f g : Filter α
s✝ t : Set α
ι : Type u_2
s : ι → Filter α
U : Set α
I : Set ι
Ifin : Set.Finite I
σ : ↑{i | i ∈ I} → Set (Set α)
σfin : ∀ (i : ↑{i | i ∈ I}), Set.Finite (σ i)
σsub : ∀ (i : ↑{i | i ∈ I}), σ i ⊆ (s ↑i).sets
tsub : ⋃ (i : ↑{i | i ∈ I}), σ i ⊆ ⋃ (i : ι), (s i).sets
tfin : Set.Finite (⋃ (i : ↑{i | i ∈ I}), σ i)
tinter : ⋂ (i : ↑{i | i ∈ I}), ⋂₀ σ i ⊆ U
V : ↑{i | i ∈ I} → Set α := fun i => U ∪ ⋂₀ σ i
hV : V = fun i => U ∪ ⋂₀ σ i
i : ↑{i | i ∈ I}
⊢ ⋂₀ σ i ∈ s ↑i
[PROOFSTEP]
rw [sInter_mem (σfin _)]
[GOAL]
α : Type u
β : Type v
γ : Type w
δ : Type u_1
ι✝ : Sort x
f g : Filter α
s✝ t : Set α
ι : Type u_2
s : ι → Filter α
U : Set α
I : Set ι
Ifin : Set.Finite I
σ : ↑{i | i ∈ I} → Set (Set α)
σfin : ∀ (i : ↑{i | i ∈ I}), Set.Finite (σ i)
σsub : ∀ (i : ↑{i | i ∈ I}), σ i ⊆ (s ↑i).sets
tsub : ⋃ (i : ↑{i | i ∈ I}), σ i ⊆ ⋃ (i : ι), (s i).sets
tfin : Set.Finite (⋃ (i : ↑{i | i ∈ I}), σ i)
tinter : ⋂ (i : ↑{i | i ∈ I}), ⋂₀ σ i ⊆ U
V : ↑{i | i ∈ I} → Set α := fun i => U ∪ ⋂₀ σ i
hV : V = fun i => U ∪ ⋂₀ σ i
i : ↑{i | i ∈ I}
⊢ ∀ (U : Set α), U ∈ σ i → U ∈ s ↑i
[PROOFSTEP]
apply σsub
[GOAL]
α : Type u
β : Type v
γ : Type w
δ : Type u_1
ι✝ : Sort x
f g : Filter α
s✝ t : Set α
ι : Type u_2
s : ι → Filter α
U : Set α
I : Set ι
Ifin : Set.Finite I
σ : ↑{i | i ∈ I} → Set (Set α)
σfin : ∀ (i : ↑{i | i ∈ I}), Set.Finite (σ i)
σsub : ∀ (i : ↑{i | i ∈ I}), σ i ⊆ (s ↑i).sets
tsub : ⋃ (i : ↑{i | i ∈ I}), σ i ⊆ ⋃ (i : ι), (s i).sets
tfin : Set.Finite (⋃ (i : ↑{i | i ∈ I}), σ i)
tinter : ⋂ (i : ↑{i | i ∈ I}), ⋂₀ σ i ⊆ U
V : ↑{i | i ∈ I} → Set α := fun i => U ∪ ⋂₀ σ i
hV : V = fun i => U ∪ ⋂₀ σ i
i : ↑{i | i ∈ I}
this : ⋂₀ σ i ∈ s ↑i
⊢ V i ∈ s ↑i
[PROOFSTEP]
exact mem_of_superset this (subset_union_right _ _)
[GOAL]
case mp.intro.intro.intro.intro.intro.intro.intro.intro
α : Type u
β : Type v
γ : Type w
δ : Type u_1
ι✝ : Sort x
f g : Filter α
s✝ t : Set α
ι : Type u_2
s : ι → Filter α
U : Set α
I : Set ι
Ifin : Set.Finite I
σ : ↑{i | i ∈ I} → Set (Set α)
σfin : ∀ (i : ↑{i | i ∈ I}), Set.Finite (σ i)
σsub : ∀ (i : ↑{i | i ∈ I}), σ i ⊆ (s ↑i).sets
tsub : ⋃ (i : ↑{i | i ∈ I}), σ i ⊆ ⋃ (i : ι), (s i).sets
tfin : Set.Finite (⋃ (i : ↑{i | i ∈ I}), σ i)
tinter : ⋂ (i : ↑{i | i ∈ I}), ⋂₀ σ i ⊆ U
V : ↑{i | i ∈ I} → Set α := fun i => U ∪ ⋂₀ σ i
hV : V = fun i => U ∪ ⋂₀ σ i
V_in : ∀ (i : ↑{i | i ∈ I}), V i ∈ s ↑i
⊢ ∃ I, Set.Finite I ∧ ∃ V, (∀ (i : ↑I), V i ∈ s ↑i) ∧ U = ⋂ (i : ↑I), V i
[PROOFSTEP]
refine' ⟨I, Ifin, V, V_in, _⟩
[GOAL]
case mp.intro.intro.intro.intro.intro.intro.intro.intro
α : Type u
β : Type v
γ : Type w
δ : Type u_1
ι✝ : Sort x
f g : Filter α
s✝ t : Set α
ι : Type u_2
s : ι → Filter α
U : Set α
I : Set ι
Ifin : Set.Finite I
σ : ↑{i | i ∈ I} → Set (Set α)
σfin : ∀ (i : ↑{i | i ∈ I}), Set.Finite (σ i)
σsub : ∀ (i : ↑{i | i ∈ I}), σ i ⊆ (s ↑i).sets
tsub : ⋃ (i : ↑{i | i ∈ I}), σ i ⊆ ⋃ (i : ι), (s i).sets
tfin : Set.Finite (⋃ (i : ↑{i | i ∈ I}), σ i)
tinter : ⋂ (i : ↑{i | i ∈ I}), ⋂₀ σ i ⊆ U
V : ↑{i | i ∈ I} → Set α := fun i => U ∪ ⋂₀ σ i
hV : V = fun i => U ∪ ⋂₀ σ i
V_in : ∀ (i : ↑{i | i ∈ I}), V i ∈ s ↑i
⊢ U = ⋂ (i : ↑I), V i
[PROOFSTEP]
rwa [hV, ← union_iInter, union_eq_self_of_subset_right]
[GOAL]
case mpr
α : Type u
β : Type v
γ : Type w
δ : Type u_1
ι✝ : Sort x
f g : Filter α
s✝ t : Set α
ι : Type u_2
s : ι → Filter α
U : Set α
⊢ (∃ I, Set.Finite I ∧ ∃ V, (∀ (i : ↑I), V i ∈ s ↑i) ∧ U = ⋂ (i : ↑I), V i) → U ∈ ⨅ (i : ι), s i
[PROOFSTEP]
rintro ⟨I, Ifin, V, V_in, rfl⟩
[GOAL]
case mpr.intro.intro.intro.intro
α : Type u
β : Type v
γ : Type w
δ : Type u_1
ι✝ : Sort x
f g : Filter α
s✝ t : Set α
ι : Type u_2
s : ι → Filter α
I : Set ι
Ifin : Set.Finite I
V : ↑I → Set α
V_in : ∀ (i : ↑I), V i ∈ s ↑i
⊢ ⋂ (i : ↑I), V i ∈ ⨅ (i : ι), s i
[PROOFSTEP]
exact mem_iInf_of_iInter Ifin V_in Subset.rfl
[GOAL]
α : Type u
β : Type v
γ : Type w
δ : Type u_1
ι✝ : Sort x
f g : Filter α
s✝ t : Set α
ι : Type u_2
s : ι → Filter α
U : Set α
⊢ U ∈ ⨅ (i : ι), s i ↔
    ∃ I,
      Set.Finite I ∧
        ∃ V,
          (∀ (i : ι), V i ∈ s i) ∧
            (∀ (i : ι), ¬i ∈ I → V i = univ) ∧ U = ⋂ (i : ι) (_ : i ∈ I), V i ∧ U = ⋂ (i : ι), V i
[PROOFSTEP]
simp only [mem_iInf, SetCoe.forall', biInter_eq_iInter]
[GOAL]
α : Type u
β : Type v
γ : Type w
δ : Type u_1
ι✝ : Sort x
f g : Filter α
s✝ t : Set α
ι : Type u_2
s : ι → Filter α
U : Set α
⊢ (∃ I, Set.Finite I ∧ ∃ V, (∀ (i : ↑I), V i ∈ s ↑i) ∧ U = ⋂ (i : ↑I), V i) ↔
    ∃ I,
      Set.Finite I ∧
        ∃ V, (∀ (i : ι), V i ∈ s i) ∧ (∀ (i : ι), ¬i ∈ I → V i = univ) ∧ U = ⋂ (x : ↑I), V ↑x ∧ U = ⋂ (i : ι), V i
[PROOFSTEP]
refine' ⟨_, fun ⟨I, If, V, hVs, _, hVU, _⟩ => ⟨I, If, fun i => V i, fun i => hVs i, hVU⟩⟩
[GOAL]
α : Type u
β : Type v
γ : Type w
δ : Type u_1
ι✝ : Sort x
f g : Filter α
s✝ t : Set α
ι : Type u_2
s : ι → Filter α
U : Set α
⊢ (∃ I, Set.Finite I ∧ ∃ V, (∀ (i : ↑I), V i ∈ s ↑i) ∧ U = ⋂ (i : ↑I), V i) →
    ∃ I,
      Set.Finite I ∧
        ∃ V, (∀ (i : ι), V i ∈ s i) ∧ (∀ (i : ι), ¬i ∈ I → V i = univ) ∧ U = ⋂ (x : ↑I), V ↑x ∧ U = ⋂ (i : ι), V i
[PROOFSTEP]
rintro ⟨I, If, V, hV, rfl⟩
[GOAL]
case intro.intro.intro.intro
α : Type u
β : Type v
γ : Type w
δ : Type u_1
ι✝ : Sort x
f g : Filter α
s✝ t : Set α
ι : Type u_2
s : ι → Filter α
I : Set ι
If : Set.Finite I
V : ↑I → Set α
hV : ∀ (i : ↑I), V i ∈ s ↑i
⊢ ∃ I_1,
    Set.Finite I_1 ∧
      ∃ V_1,
        (∀ (i : ι), V_1 i ∈ s i) ∧
          (∀ (i : ι), ¬i ∈ I_1 → V_1 i = univ) ∧
            ⋂ (i : ↑I), V i = ⋂ (x : ↑I_1), V_1 ↑x ∧ ⋂ (i : ↑I), V i = ⋂ (i : ι), V_1 i
[PROOFSTEP]
refine' ⟨I, If, fun i => if hi : i ∈ I then V ⟨i, hi⟩ else univ, fun i => _, fun i hi => _, _⟩
[GOAL]
case intro.intro.intro.intro.refine'_1
α : Type u
β : Type v
γ : Type w
δ : Type u_1
ι✝ : Sort x
f g : Filter α
s✝ t : Set α
ι : Type u_2
s : ι → Filter α
I : Set ι
If : Set.Finite I
V : ↑I → Set α
hV : ∀ (i : ↑I), V i ∈ s ↑i
i : ι
⊢ (fun i => if hi : i ∈ I then V { val := i, property := hi } else univ) i ∈ s i
[PROOFSTEP]
dsimp only
[GOAL]
case intro.intro.intro.intro.refine'_1
α : Type u
β : Type v
γ : Type w
δ : Type u_1
ι✝ : Sort x
f g : Filter α
s✝ t : Set α
ι : Type u_2
s : ι → Filter α
I : Set ι
If : Set.Finite I
V : ↑I → Set α
hV : ∀ (i : ↑I), V i ∈ s ↑i
i : ι
⊢ (if hi : i ∈ I then V { val := i, property := hi } else univ) ∈ s i
[PROOFSTEP]
split_ifs
[GOAL]
case pos
α : Type u
β : Type v
γ : Type w
δ : Type u_1
ι✝ : Sort x
f g : Filter α
s✝ t : Set α
ι : Type u_2
s : ι → Filter α
I : Set ι
If : Set.Finite I
V : ↑I → Set α
hV : ∀ (i : ↑I), V i ∈ s ↑i
i : ι
h✝ : i ∈ I
⊢ V { val := i, property := h✝ } ∈ s i
case neg
α : Type u
β : Type v
γ : Type w
δ : Type u_1
ι✝ : Sort x
f g : Filter α
s✝ t : Set α
ι : Type u_2
s : ι → Filter α
I : Set ι
If : Set.Finite I
V : ↑I → Set α
hV : ∀ (i : ↑I), V i ∈ s ↑i
i : ι
h✝ : ¬i ∈ I
⊢ univ ∈ s i
[PROOFSTEP]
exacts [hV _, univ_mem]
[GOAL]
case intro.intro.intro.intro.refine'_2
α : Type u
β : Type v
γ : Type w
δ : Type u_1
ι✝ : Sort x
f g : Filter α
s✝ t : Set α
ι : Type u_2
s : ι → Filter α
I : Set ι
If : Set.Finite I
V : ↑I → Set α
hV : ∀ (i : ↑I), V i ∈ s ↑i
i : ι
hi : ¬i ∈ I
⊢ (fun i => if hi : i ∈ I then V { val := i, property := hi } else univ) i = univ
[PROOFSTEP]
exact dif_neg hi
[GOAL]
case intro.intro.intro.intro.refine'_3
α : Type u
β : Type v
γ : Type w
δ : Type u_1
ι✝ : Sort x
f g : Filter α
s✝ t : Set α
ι : Type u_2
s : ι → Filter α
I : Set ι
If : Set.Finite I
V : ↑I → Set α
hV : ∀ (i : ↑I), V i ∈ s ↑i
⊢ ⋂ (i : ↑I), V i = ⋂ (x : ↑I), (fun i => if hi : i ∈ I then V { val := i, property := hi } else univ) ↑x ∧
    ⋂ (i : ↑I), V i = ⋂ (i : ι), (fun i => if hi : i ∈ I then V { val := i, property := hi } else univ) i
[PROOFSTEP]
simp only [iInter_dite, biInter_eq_iInter, dif_pos (Subtype.coe_prop _), Subtype.coe_eta, iInter_univ, inter_univ,
  eq_self_iff_true, true_and_iff]
[GOAL]
α✝ : Type u
β : Type v
γ : Type w
δ : Type u_1
ι✝ : Sort x
f✝ g : Filter α✝
s✝ t : Set α✝
ι : Type u_2
inst✝ : Finite ι
α : Type u_3
f : ι → Filter α
s : Set α
⊢ s ∈ ⨅ (i : ι), f i ↔ ∃ t, (∀ (i : ι), t i ∈ f i) ∧ s = ⋂ (i : ι), t i
[PROOFSTEP]
refine' ⟨exists_iInter_of_mem_iInf, _⟩
[GOAL]
α✝ : Type u
β : Type v
γ : Type w
δ : Type u_1
ι✝ : Sort x
f✝ g : Filter α✝
s✝ t : Set α✝
ι : Type u_2
inst✝ : Finite ι
α : Type u_3
f : ι → Filter α
s : Set α
⊢ (∃ t, (∀ (i : ι), t i ∈ f i) ∧ s = ⋂ (i : ι), t i) → s ∈ ⨅ (i : ι), f i
[PROOFSTEP]
rintro ⟨t, ht, rfl⟩
[GOAL]
case intro.intro
α✝ : Type u
β : Type v
γ : Type w
δ : Type u_1
ι✝ : Sort x
f✝ g : Filter α✝
s t✝ : Set α✝
ι : Type u_2
inst✝ : Finite ι
α : Type u_3
f : ι → Filter α
t : ι → Set α
ht : ∀ (i : ι), t i ∈ f i
⊢ ⋂ (i : ι), t i ∈ ⨅ (i : ι), f i
[PROOFSTEP]
exact iInter_mem.2 fun i => mem_iInf_of_mem i (ht i)
[GOAL]
α : Type u
β : Type v
γ : Type w
δ : Type u_1
ι : Sort x
f g : Filter α
s✝ t✝ s t : Set α
⊢ 𝓟 s ≤ 𝓟 t ↔ s ⊆ t
[PROOFSTEP]
simp only [le_principal_iff, iff_self_iff, mem_principal]
[GOAL]
α : Type u
β : Type v
γ : Type w
δ : Type u_1
ι : Sort x
f g : Filter α
s✝ t✝ s t : Set α
⊢ 𝓟 s = 𝓟 t ↔ s = t
[PROOFSTEP]
simp only [le_antisymm_iff, le_principal_iff, mem_principal]
[GOAL]
α : Type u
β : Type v
γ : Type w
δ : Type u_1
ι : Sort x
f g : Filter α
s✝ t✝ s t : Set α
⊢ s ⊆ t ∧ t ⊆ s ↔ s ≤ t ∧ t ≤ s
[PROOFSTEP]
rfl
[GOAL]
α : Type u
β : Type v
γ : Type w
δ : Type u_1
ι : Sort x
f g : Filter α
s t : Set α
⊢ ⊤ ≤ 𝓟 univ
[PROOFSTEP]
simp only [le_principal_iff, mem_top, eq_self_iff_true]
[GOAL]
α : Type u
β : Type v
γ : Type w
δ : Type u_1
ι : Sort x
f✝ g : Filter α
s t : Set α
S : Set (Set α)
f : Filter α
⊢ f ≤ generate S ↔ f ≤ ⨅ (s : Set α) (_ : s ∈ S), 𝓟 s
[PROOFSTEP]
simp [le_generate_iff, le_principal_iff, subset_def]
[GOAL]
α : Type u
β : Type v
γ : Type w
δ : Type u_1
ι : Sort x
f✝ g✝ : Filter α
s t : Set α
f g : Filter α
⊢ Disjoint f g ↔ ∃ s, s ∈ f ∧ ∃ t, t ∈ g ∧ Disjoint s t
[PROOFSTEP]
simp only [disjoint_iff, ← empty_mem_iff_bot, mem_inf_iff, inf_eq_inter, bot_eq_empty, @eq_comm _ ∅]
[GOAL]
α : Type u
β : Type v
γ : Type w
δ : Type u_1
ι : Sort x
f✝ g✝ : Filter α
s t : Set α
f g : Filter α
⊢ f ⊓ g = ⊥ ↔ ∃ U, U ∈ f ∧ ∃ V, V ∈ g ∧ U ∩ V = ∅
[PROOFSTEP]
simp only [← disjoint_iff, Filter.disjoint_iff, Set.disjoint_iff_inter_eq_empty]
[GOAL]
α : Type u
β : Type v
γ : Type w
δ : Type u_1
ι✝ : Sort x
f g : Filter α
s t : Set α
ι : Type u_2
inst✝ : Finite ι
l : ι → Filter α
hd : Pairwise (Disjoint on l)
⊢ ∃ s, (∀ (i : ι), s i ∈ l i) ∧ Pairwise (Disjoint on s)
[PROOFSTEP]
have : ∀ i j, i ≠ j → ∃ (s : { s // s ∈ l i }) (t : { t // t ∈ l j }), Disjoint s.1 t.1
[GOAL]
case this
α : Type u
β : Type v
γ : Type w
δ : Type u_1
ι✝ : Sort x
f g : Filter α
s t : Set α
ι : Type u_2
inst✝ : Finite ι
l : ι → Filter α
hd : Pairwise (Disjoint on l)
⊢ ∀ (i j : ι), i ≠ j → ∃ s t, Disjoint ↑s ↑t
[PROOFSTEP]
simpa only [Pairwise, Function.onFun, Filter.disjoint_iff, exists_prop, Subtype.exists] using hd
[GOAL]
α : Type u
β : Type v
γ : Type w
δ : Type u_1
ι✝ : Sort x
f g : Filter α
s t : Set α
ι : Type u_2
inst✝ : Finite ι
l : ι → Filter α
hd : Pairwise (Disjoint on l)
this : ∀ (i j : ι), i ≠ j → ∃ s t, Disjoint ↑s ↑t
⊢ ∃ s, (∀ (i : ι), s i ∈ l i) ∧ Pairwise (Disjoint on s)
[PROOFSTEP]
choose! s t hst using this
[GOAL]
α : Type u
β : Type v
γ : Type w
δ : Type u_1
ι✝ : Sort x
f g : Filter α
s✝ t✝ : Set α
ι : Type u_2
inst✝ : Finite ι
l : ι → Filter α
hd : Pairwise (Disjoint on l)
s : (i : ι) → ι → { s // s ∈ l i }
t : ι → (j : ι) → { t // t ∈ l j }
hst : ∀ (i j : ι), i ≠ j → Disjoint ↑(s i j) ↑(t i j)
⊢ ∃ s, (∀ (i : ι), s i ∈ l i) ∧ Pairwise (Disjoint on s)
[PROOFSTEP]
refine' ⟨fun i => ⋂ j, s i j ∩ t j i, fun i => _, fun i j hij => _⟩
[GOAL]
case refine'_1
α : Type u
β : Type v
γ : Type w
δ : Type u_1
ι✝ : Sort x
f g : Filter α
s✝ t✝ : Set α
ι : Type u_2
inst✝ : Finite ι
l : ι → Filter α
hd : Pairwise (Disjoint on l)
s : (i : ι) → ι → { s // s ∈ l i }
t : ι → (j : ι) → { t // t ∈ l j }
hst : ∀ (i j : ι), i ≠ j → Disjoint ↑(s i j) ↑(t i j)
i : ι
⊢ (fun i => ⋂ (j : ι), ↑(s i j) ∩ ↑(t j i)) i ∈ l i
case refine'_2
α : Type u
β : Type v
γ : Type w
δ : Type u_1
ι✝ : Sort x
f g : Filter α
s✝ t✝ : Set α
ι : Type u_2
inst✝ : Finite ι
l : ι → Filter α
hd : Pairwise (Disjoint on l)
s : (i : ι) → ι → { s // s ∈ l i }
t : ι → (j : ι) → { t // t ∈ l j }
hst : ∀ (i j : ι), i ≠ j → Disjoint ↑(s i j) ↑(t i j)
i j : ι
hij : i ≠ j
⊢ (Disjoint on fun i => ⋂ (j : ι), ↑(s i j) ∩ ↑(t j i)) i j
[PROOFSTEP]
exacts [iInter_mem.2 fun j => inter_mem (@s i j).2 (@t j i).2,
  (hst _ _ hij).mono ((iInter_subset _ j).trans (inter_subset_left _ _))
    ((iInter_subset _ i).trans (inter_subset_right _ _))]
[GOAL]
α : Type u
β : Type v
γ : Type w
δ : Type u_1
ι✝ : Sort x
f g : Filter α
s t✝ : Set α
ι : Type u_2
l : ι → Filter α
t : Set ι
hd : PairwiseDisjoint t l
ht : Set.Finite t
⊢ ∃ s, (∀ (i : ι), s i ∈ l i) ∧ PairwiseDisjoint t s
[PROOFSTEP]
haveI := ht.to_subtype
[GOAL]
α : Type u
β : Type v
γ : Type w
δ : Type u_1
ι✝ : Sort x
f g : Filter α
s t✝ : Set α
ι : Type u_2
l : ι → Filter α
t : Set ι
hd : PairwiseDisjoint t l
ht : Set.Finite t
this : Finite ↑t
⊢ ∃ s, (∀ (i : ι), s i ∈ l i) ∧ PairwiseDisjoint t s
[PROOFSTEP]
rcases(hd.subtype _ _).exists_mem_filter_of_disjoint with ⟨s, hsl, hsd⟩
[GOAL]
case intro.intro
α : Type u
β : Type v
γ : Type w
δ : Type u_1
ι✝ : Sort x
f g : Filter α
s✝ t✝ : Set α
ι : Type u_2
l : ι → Filter α
t : Set ι
hd : PairwiseDisjoint t l
ht : Set.Finite t
this : Finite ↑t
s : ↑t → Set α
hsl : ∀ (i : ↑t), s i ∈ l ↑i
hsd : Pairwise (Disjoint on s)
⊢ ∃ s, (∀ (i : ι), s i ∈ l i) ∧ PairwiseDisjoint t s
[PROOFSTEP]
lift s to (i : t) → { s // s ∈ l i } using hsl
[GOAL]
case intro.intro.intro
α : Type u
β : Type v
γ : Type w
δ : Type u_1
ι✝ : Sort x
f g : Filter α
s✝ t✝ : Set α
ι : Type u_2
l : ι → Filter α
t : Set ι
hd : PairwiseDisjoint t l
ht : Set.Finite t
this : Finite ↑t
s : (i : ↑t) → { s // s ∈ l ↑i }
hsd : Pairwise (Disjoint on fun i => ↑(s i))
⊢ ∃ s, (∀ (i : ι), s i ∈ l i) ∧ PairwiseDisjoint t s
[PROOFSTEP]
rcases@Subtype.exists_pi_extension ι (fun i => { s // s ∈ l i }) _ _ s with ⟨s, rfl⟩
[GOAL]
case intro.intro.intro.intro
α : Type u
β : Type v
γ : Type w
δ : Type u_1
ι✝ : Sort x
f g : Filter α
s✝ t✝ : Set α
ι : Type u_2
l : ι → Filter α
t : Set ι
hd : PairwiseDisjoint t l
ht : Set.Finite t
this : Finite ↑t
s : (i : ι) → { s // s ∈ l i }
hsd : Pairwise (Disjoint on fun i => ↑((fun i => s ↑i) i))
⊢ ∃ s, (∀ (i : ι), s i ∈ l i) ∧ PairwiseDisjoint t s
[PROOFSTEP]
exact ⟨fun i => s i, fun i => (s i).2, hsd.set_of_subtype _ _⟩
[GOAL]
α : Type u
β : Type v
γ : Type w
δ : Type u_1
ι : Sort x
f g : Filter α
s t : Set α
inst✝¹ : Subsingleton α
l : Filter α
inst✝ : NeBot l
⊢ l = ⊤
[PROOFSTEP]
refine' top_unique fun s hs => _
[GOAL]
α : Type u
β : Type v
γ : Type w
δ : Type u_1
ι : Sort x
f g : Filter α
s✝ t : Set α
inst✝¹ : Subsingleton α
l : Filter α
inst✝ : NeBot l
s : Set α
hs : s ∈ l
⊢ s ∈ ⊤
[PROOFSTEP]
obtain rfl : s = univ
[GOAL]
α : Type u
β : Type v
γ : Type w
δ : Type u_1
ι : Sort x
f g : Filter α
s✝ t : Set α
inst✝¹ : Subsingleton α
l : Filter α
inst✝ : NeBot l
s : Set α
hs : s ∈ l
⊢ s = univ
α : Type u
β : Type v
γ : Type w
δ : Type u_1
ι : Sort x
f g : Filter α
s t : Set α
inst✝¹ : Subsingleton α
l : Filter α
inst✝ : NeBot l
hs : univ ∈ l
⊢ univ ∈ ⊤
[PROOFSTEP]
exact Subsingleton.eq_univ_of_nonempty (nonempty_of_mem hs)
[GOAL]
α : Type u
β : Type v
γ : Type w
δ : Type u_1
ι : Sort x
f g : Filter α
s t : Set α
inst✝¹ : Subsingleton α
l : Filter α
inst✝ : NeBot l
hs : univ ∈ l
⊢ univ ∈ ⊤
[PROOFSTEP]
exact univ_mem
[GOAL]
α : Type u
β : Type v
γ : Type w
δ : Type u_1
ι : Sort x
f g : Filter α
s✝ t : Set α
inst✝ : Nonempty α
s : Set α
hs : s ∈ ⊤
⊢ Set.Nonempty s
[PROOFSTEP]
rwa [mem_top.1 hs, ← nonempty_iff_univ_nonempty]
[GOAL]
α : Type u
β : Type v
γ : Type w
δ : Type u_1
ι : Sort x
f✝ g : Filter α
s t : Set α
f : ι → Filter α
p : ι → Prop
l : Filter α
h : ∀ {s : Set α}, s ∈ l ↔ ∃ i, p i ∧ s ∈ f i
⊢ l = ⨅ (i : ι) (_ : p i), f i
[PROOFSTEP]
rw [iInf_subtype']
[GOAL]
α : Type u
β : Type v
γ : Type w
δ : Type u_1
ι : Sort x
f✝ g : Filter α
s t : Set α
f : ι → Filter α
p : ι → Prop
l : Filter α
h : ∀ {s : Set α}, s ∈ l ↔ ∃ i, p i ∧ s ∈ f i
⊢ l = ⨅ (x : { i // p i }), f ↑x
[PROOFSTEP]
exact eq_iInf_of_mem_iff_exists_mem <| fun {_} => by simp only [Subtype.exists, h, exists_prop]
[GOAL]
α : Type u
β : Type v
γ : Type w
δ : Type u_1
ι : Sort x
f✝ g : Filter α
s t : Set α
f : ι → Filter α
p : ι → Prop
l : Filter α
h : ∀ {s : Set α}, s ∈ l ↔ ∃ i, p i ∧ s ∈ f i
x✝ : Set α
⊢ x✝ ∈ l ↔ ∃ i, x✝ ∈ f ↑i
[PROOFSTEP]
simp only [Subtype.exists, h, exists_prop]
[GOAL]
α : Type u
β : Type v
γ : Type w
δ : Type u_1
ι : Sort x
f✝ g : Filter α
s t : Set α
f : ι → Filter α
h : Directed (fun x x_1 => x ≥ x_1) f
ne : Nonempty ι
i : ι
⊢ ∀ {x y : Set α}, x ∈ ⋃ (i : ι), (f i).sets → x ⊆ y → y ∈ ⋃ (i : ι), (f i).sets
[PROOFSTEP]
simp only [mem_iUnion, exists_imp]
[GOAL]
α : Type u
β : Type v
γ : Type w
δ : Type u_1
ι : Sort x
f✝ g : Filter α
s t : Set α
f : ι → Filter α
h : Directed (fun x x_1 => x ≥ x_1) f
ne : Nonempty ι
i : ι
⊢ ∀ {x y : Set α} (x_1 : ι), x ∈ (f x_1).sets → x ⊆ y → ∃ i, y ∈ (f i).sets
[PROOFSTEP]
exact fun i hx hxy => ⟨i, mem_of_superset hx hxy⟩
[GOAL]
α : Type u
β : Type v
γ : Type w
δ : Type u_1
ι : Sort x
f✝ g : Filter α
s t : Set α
f : ι → Filter α
h : Directed (fun x x_1 => x ≥ x_1) f
ne : Nonempty ι
i : ι
⊢ ∀ {x y : Set α}, x ∈ ⋃ (i : ι), (f i).sets → y ∈ ⋃ (i : ι), (f i).sets → x ∩ y ∈ ⋃ (i : ι), (f i).sets
[PROOFSTEP]
simp only [mem_iUnion, exists_imp]
[GOAL]
α : Type u
β : Type v
γ : Type w
δ : Type u_1
ι : Sort x
f✝ g : Filter α
s t : Set α
f : ι → Filter α
h : Directed (fun x x_1 => x ≥ x_1) f
ne : Nonempty ι
i : ι
⊢ ∀ {x y : Set α} (x_1 : ι), x ∈ (f x_1).sets → ∀ (x_2 : ι), y ∈ (f x_2).sets → ∃ i, x ∩ y ∈ (f i).sets
[PROOFSTEP]
intro x y a hx b hy
[GOAL]
α : Type u
β : Type v
γ : Type w
δ : Type u_1
ι : Sort x
f✝ g : Filter α
s t : Set α
f : ι → Filter α
h : Directed (fun x x_1 => x ≥ x_1) f
ne : Nonempty ι
i : ι
x y : Set α
a : ι
hx : x ∈ (f a).sets
b : ι
hy : y ∈ (f b).sets
⊢ ∃ i, x ∩ y ∈ (f i).sets
[PROOFSTEP]
rcases h a b with ⟨c, ha, hb⟩
[GOAL]
case intro.intro
α : Type u
β : Type v
γ : Type w
δ : Type u_1
ι : Sort x
f✝ g : Filter α
s t : Set α
f : ι → Filter α
h : Directed (fun x x_1 => x ≥ x_1) f
ne : Nonempty ι
i : ι
x y : Set α
a : ι
hx : x ∈ (f a).sets
b : ι
hy : y ∈ (f b).sets
c : ι
ha : f a ≥ f c
hb : f b ≥ f c
⊢ ∃ i, x ∩ y ∈ (f i).sets
[PROOFSTEP]
exact ⟨c, inter_mem (ha hx) (hb hy)⟩
[GOAL]
α : Type u
β : Type v
γ : Type w
δ : Type u_1
ι : Sort x
f✝ g : Filter α
s t : Set α
f : ι → Filter α
h : Directed (fun x x_1 => x ≥ x_1) f
ne : Nonempty ι
i : ι
u : Filter α :=
  { sets := ⋃ (i : ι), (f i).sets, univ_sets := (_ : univ ∈ ⋃ (i : ι), (f i).sets), sets_of_superset := ?m.89808,
    inter_sets := ?m.89809 }
this : u = iInf f
⊢ u.sets = ⋃ (i : ι), (f i).sets
[PROOFSTEP]
simp only
[GOAL]
α : Type u
β : Type v
γ : Type w
δ : Type u_1
ι : Sort x
f✝ g : Filter α
s✝ t : Set α
f : ι → Filter α
h : Directed (fun x x_1 => x ≥ x_1) f
inst✝ : Nonempty ι
s : Set α
⊢ s ∈ iInf f ↔ ∃ i, s ∈ f i
[PROOFSTEP]
simp only [← Filter.mem_sets, iInf_sets_eq h, mem_iUnion]
[GOAL]
α : Type u
β : Type v
γ : Type w
δ : Type u_1
ι : Sort x
f✝ g : Filter α
s✝ t✝ : Set α
f : β → Filter α
s : Set β
h : DirectedOn (f ⁻¹'o fun x x_1 => x ≥ x_1) s
ne : Set.Nonempty s
t : Set α
⊢ t ∈ ⨅ (i : β) (_ : i ∈ s), f i ↔ ∃ i, i ∈ s ∧ t ∈ f i
[PROOFSTEP]
haveI := ne.to_subtype
[GOAL]
α : Type u
β : Type v
γ : Type w
δ : Type u_1
ι : Sort x
f✝ g : Filter α
s✝ t✝ : Set α
f : β → Filter α
s : Set β
h : DirectedOn (f ⁻¹'o fun x x_1 => x ≥ x_1) s
ne : Set.Nonempty s
t : Set α
this : Nonempty ↑s
⊢ t ∈ ⨅ (i : β) (_ : i ∈ s), f i ↔ ∃ i, i ∈ s ∧ t ∈ f i
[PROOFSTEP]
simp_rw [iInf_subtype', mem_iInf_of_directed h.directed_val, Subtype.exists, exists_prop]
[GOAL]
α : Type u
β : Type v
γ : Type w
δ : Type u_1
ι : Sort x
f✝ g : Filter α
s✝ t✝ : Set α
f : β → Filter α
s : Set β
h : DirectedOn (f ⁻¹'o fun x x_1 => x ≥ x_1) s
ne : Set.Nonempty s
t : Set α
⊢ t ∈ (⨅ (i : β) (_ : i ∈ s), f i).sets ↔ t ∈ ⋃ (i : β) (_ : i ∈ s), (f i).sets
[PROOFSTEP]
simp [mem_biInf_of_directed h ne]
[GOAL]
α : Type u
β : Type v
γ : Type w
δ : Type u_1
ι✝ : Sort x
f✝ g : Filter α
s t : Set α
ι : Type u_2
f : ι → Filter α
⊢ (⨅ (i : ι), f i).sets = ⋃ (t : Finset ι), (⨅ (i : ι) (_ : i ∈ t), f i).sets
[PROOFSTEP]
rw [iInf_eq_iInf_finset, iInf_sets_eq]
[GOAL]
case h
α : Type u
β : Type v
γ : Type w
δ : Type u_1
ι✝ : Sort x
f✝ g : Filter α
s t : Set α
ι : Type u_2
f : ι → Filter α
⊢ Directed (fun x x_1 => x ≥ x_1) fun t => ⨅ (i : ι) (_ : i ∈ t), f i
[PROOFSTEP]
exact directed_of_sup fun _ _ => biInf_mono
[GOAL]
α : Type u
β : Type v
γ : Type w
δ : Type u_1
ι : Sort x
f✝ g : Filter α
s t : Set α
f : ι → Filter α
⊢ (⨅ (i : ι), f i).sets = ⋃ (t : Finset (PLift ι)), (⨅ (i : PLift ι) (_ : i ∈ t), f i.down).sets
[PROOFSTEP]
rw [← iInf_sets_eq_finite, ← Equiv.plift.surjective.iInf_comp]
[GOAL]
α : Type u
β : Type v
γ : Type w
δ : Type u_1
ι : Sort x
f✝ g : Filter α
s t : Set α
f : ι → Filter α
⊢ (⨅ (x : PLift ι), f (↑Equiv.plift x)).sets = (⨅ (i : PLift ι), f i.down).sets
[PROOFSTEP]
rfl
[GOAL]
α : Type u
β : Type v
γ : Type w
δ : Type u_1
ι : Sort x
f g : Filter α
s t : Set α
f₁ f₂ : Filter (Filter α)
x : Set α
⊢ x ∈ join f₁ ⊔ join f₂ ↔ x ∈ join (f₁ ⊔ f₂)
[PROOFSTEP]
simp only [mem_sup, mem_join]
[GOAL]
α : Type u
β : Type v
γ : Type w
δ : Type u_1
ι✝ : Sort x
f✝ g : Filter α
s t : Set α
ι : Sort w
f : ι → Filter (Filter α)
x : Set α
⊢ x ∈ ⨆ (x : ι), join (f x) ↔ x ∈ join (⨆ (x : ι), f x)
[PROOFSTEP]
simp only [mem_iSup, mem_join]
[GOAL]
α : Type u
β : Type v
γ : Type w
δ : Type u_1
ι : Sort x
f g : Filter α
s t : Set α
src✝ : CompleteLattice (Filter α) := instCompleteLatticeFilter
⊢ ∀ (x y z : Filter α), (x ⊔ y) ⊓ (x ⊔ z) ≤ x ⊔ y ⊓ z
[PROOFSTEP]
intro x y z s
[GOAL]
α : Type u
β : Type v
γ : Type w
δ : Type u_1
ι : Sort x
f g : Filter α
s✝ t : Set α
src✝ : CompleteLattice (Filter α) := instCompleteLatticeFilter
x y z : Filter α
s : Set α
⊢ s ∈ x ⊔ y ⊓ z → s ∈ (x ⊔ y) ⊓ (x ⊔ z)
[PROOFSTEP]
simp only [and_assoc, mem_inf_iff, mem_sup, exists_prop, exists_imp, and_imp]
[GOAL]
α : Type u
β : Type v
γ : Type w
δ : Type u_1
ι : Sort x
f g : Filter α
s✝ t : Set α
src✝ : CompleteLattice (Filter α) := instCompleteLatticeFilter
x y z : Filter α
s : Set α
⊢ s ∈ x →
    ∀ (x_1 : Set α),
      x_1 ∈ y → ∀ (x_2 : Set α), x_2 ∈ z → s = x_1 ∩ x_2 → ∃ t₁, t₁ ∈ x ∧ t₁ ∈ y ∧ ∃ t₂, t₂ ∈ x ∧ t₂ ∈ z ∧ s = t₁ ∩ t₂
[PROOFSTEP]
rintro hs t₁ ht₁ t₂ ht₂ rfl
[GOAL]
α : Type u
β : Type v
γ : Type w
δ : Type u_1
ι : Sort x
f g : Filter α
s t : Set α
src✝ : CompleteLattice (Filter α) := instCompleteLatticeFilter
x y z : Filter α
t₁ : Set α
ht₁ : t₁ ∈ y
t₂ : Set α
ht₂ : t₂ ∈ z
hs : t₁ ∩ t₂ ∈ x
⊢ ∃ t₁_1, t₁_1 ∈ x ∧ t₁_1 ∈ y ∧ ∃ t₂_1, t₂_1 ∈ x ∧ t₂_1 ∈ z ∧ t₁ ∩ t₂ = t₁_1 ∩ t₂_1
[PROOFSTEP]
exact
  ⟨t₁, x.sets_of_superset hs (inter_subset_left t₁ t₂), ht₁, t₂, x.sets_of_superset hs (inter_subset_right t₁ t₂), ht₂,
    rfl⟩
[GOAL]
α : Type u
β : Type v
γ : Type w
δ : Type u_1
ι : Sort x
f✝ g : Filter α
s✝ t✝ : Set α
src✝ : CompleteLattice (Filter α) := instCompleteLatticeFilter
f : Filter α
s : Set (Filter α)
t : Set α
x✝ : t ∈ f ⊔ sInf s
h₁ : t ∈ f.sets
h₂ : t ∈ (sInf s).sets
⊢ t ∈ ⨅ (b : Filter α) (_ : b ∈ s), f ⊔ b
[PROOFSTEP]
rw [iInf_subtype']
[GOAL]
α : Type u
β : Type v
γ : Type w
δ : Type u_1
ι : Sort x
f✝ g : Filter α
s✝ t✝ : Set α
src✝ : CompleteLattice (Filter α) := instCompleteLatticeFilter
f : Filter α
s : Set (Filter α)
t : Set α
x✝ : t ∈ f ⊔ sInf s
h₁ : t ∈ f.sets
h₂ : t ∈ (sInf s).sets
⊢ t ∈ ⨅ (x : { b // b ∈ s }), f ⊔ ↑x
[PROOFSTEP]
rw [sInf_eq_iInf', iInf_sets_eq_finite, mem_iUnion] at h₂
[GOAL]
α : Type u
β : Type v
γ : Type w
δ : Type u_1
ι : Sort x
f✝ g : Filter α
s✝ t✝ : Set α
src✝ : CompleteLattice (Filter α) := instCompleteLatticeFilter
f : Filter α
s : Set (Filter α)
t : Set α
x✝ : t ∈ f ⊔ sInf s
h₁ : t ∈ f.sets
h₂ : ∃ i, t ∈ (⨅ (i_1 : ↑s) (_ : i_1 ∈ i), ↑i_1).sets
⊢ t ∈ ⨅ (x : { b // b ∈ s }), f ⊔ ↑x
[PROOFSTEP]
obtain ⟨u, hu⟩ := h₂
[GOAL]
case intro
α : Type u
β : Type v
γ : Type w
δ : Type u_1
ι : Sort x
f✝ g : Filter α
s✝ t✝ : Set α
src✝ : CompleteLattice (Filter α) := instCompleteLatticeFilter
f : Filter α
s : Set (Filter α)
t : Set α
x✝ : t ∈ f ⊔ sInf s
h₁ : t ∈ f.sets
u : Finset ↑s
hu : t ∈ (⨅ (i : ↑s) (_ : i ∈ u), ↑i).sets
⊢ t ∈ ⨅ (x : { b // b ∈ s }), f ⊔ ↑x
[PROOFSTEP]
rw [← Finset.inf_eq_iInf] at hu
[GOAL]
case intro
α : Type u
β : Type v
γ : Type w
δ : Type u_1
ι : Sort x
f✝ g : Filter α
s✝ t✝ : Set α
src✝ : CompleteLattice (Filter α) := instCompleteLatticeFilter
f : Filter α
s : Set (Filter α)
t : Set α
x✝ : t ∈ f ⊔ sInf s
h₁ : t ∈ f.sets
u : Finset ↑s
hu : t ∈ (Finset.inf u fun i => ↑i).sets
⊢ t ∈ ⨅ (x : { b // b ∈ s }), f ⊔ ↑x
[PROOFSTEP]
suffices ⨅ i : s, f ⊔ ↑i ≤ f ⊔ u.inf fun i => ↑i from this ⟨h₁, hu⟩
[GOAL]
case intro
α : Type u
β : Type v
γ : Type w
δ : Type u_1
ι : Sort x
f✝ g : Filter α
s✝ t✝ : Set α
src✝ : CompleteLattice (Filter α) := instCompleteLatticeFilter
f : Filter α
s : Set (Filter α)
t : Set α
x✝ : t ∈ f ⊔ sInf s
h₁ : t ∈ f.sets
u : Finset ↑s
hu : t ∈ (Finset.inf u fun i => ↑i).sets
⊢ ⨅ (i : ↑s), f ⊔ ↑i ≤ f ⊔ Finset.inf u fun i => ↑i
[PROOFSTEP]
refine' Finset.induction_on u (le_sup_of_le_right le_top) _
[GOAL]
case intro
α : Type u
β : Type v
γ : Type w
δ : Type u_1
ι : Sort x
f✝ g : Filter α
s✝ t✝ : Set α
src✝ : CompleteLattice (Filter α) := instCompleteLatticeFilter
f : Filter α
s : Set (Filter α)
t : Set α
x✝ : t ∈ f ⊔ sInf s
h₁ : t ∈ f.sets
u : Finset ↑s
hu : t ∈ (Finset.inf u fun i => ↑i).sets
⊢ ∀ ⦃a : ↑s⦄ {s_1 : Finset ↑s},
    ¬a ∈ s_1 →
      (⨅ (i : ↑s), f ⊔ ↑i ≤ f ⊔ Finset.inf s_1 fun i => ↑i) →
        ⨅ (i : ↑s), f ⊔ ↑i ≤ f ⊔ Finset.inf (insert a s_1) fun i => ↑i
[PROOFSTEP]
rintro ⟨i⟩ u _ ih
[GOAL]
case intro.mk
α : Type u
β : Type v
γ : Type w
δ : Type u_1
ι : Sort x
f✝ g : Filter α
s✝ t✝ : Set α
src✝ : CompleteLattice (Filter α) := instCompleteLatticeFilter
f : Filter α
s : Set (Filter α)
t : Set α
x✝ : t ∈ f ⊔ sInf s
h₁ : t ∈ f.sets
u✝ : Finset ↑s
hu : t ∈ (Finset.inf u✝ fun i => ↑i).sets
i : Filter α
property✝ : i ∈ s
u : Finset ↑s
a✝ : ¬{ val := i, property := property✝ } ∈ u
ih : ⨅ (i : ↑s), f ⊔ ↑i ≤ f ⊔ Finset.inf u fun i => ↑i
⊢ ⨅ (i : ↑s), f ⊔ ↑i ≤ f ⊔ Finset.inf (insert { val := i, property := property✝ } u) fun i => ↑i
[PROOFSTEP]
rw [Finset.inf_insert, sup_inf_left]
[GOAL]
case intro.mk
α : Type u
β : Type v
γ : Type w
δ : Type u_1
ι : Sort x
f✝ g : Filter α
s✝ t✝ : Set α
src✝ : CompleteLattice (Filter α) := instCompleteLatticeFilter
f : Filter α
s : Set (Filter α)
t : Set α
x✝ : t ∈ f ⊔ sInf s
h₁ : t ∈ f.sets
u✝ : Finset ↑s
hu : t ∈ (Finset.inf u✝ fun i => ↑i).sets
i : Filter α
property✝ : i ∈ s
u : Finset ↑s
a✝ : ¬{ val := i, property := property✝ } ∈ u
ih : ⨅ (i : ↑s), f ⊔ ↑i ≤ f ⊔ Finset.inf u fun i => ↑i
⊢ ⨅ (i : ↑s), f ⊔ ↑i ≤ (f ⊔ ↑{ val := i, property := property✝ }) ⊓ (f ⊔ Finset.inf u fun i => ↑i)
[PROOFSTEP]
exact le_inf (iInf_le _ _) ih
[GOAL]
α : Type u
β : Type v
γ : Type w
δ : Type u_1
ι : Sort x
f✝ g : Filter α
s✝ t✝ : Set α
s : Finset α
f : α → Filter β
t : Set β
⊢ t ∈ ⨅ (a : α) (_ : a ∈ s), f a ↔ ∃ p, (∀ (a : α), a ∈ s → p a ∈ f a) ∧ t = ⋂ (a : α) (_ : a ∈ s), p a
[PROOFSTEP]
simp only [← Finset.set_biInter_coe, biInter_eq_iInter, iInf_subtype']
[GOAL]
α : Type u
β : Type v
γ : Type w
δ : Type u_1
ι : Sort x
f✝ g : Filter α
s✝ t✝ : Set α
s : Finset α
f : α → Filter β
t : Set β
⊢ t ∈ ⨅ (x : { i // i ∈ s }), f ↑x ↔ ∃ p, (∀ (a : α), a ∈ s → p a ∈ f a) ∧ t = ⋂ (x : ↑↑s), p ↑x
[PROOFSTEP]
refine' ⟨fun h => _, _⟩
[GOAL]
case refine'_1
α : Type u
β : Type v
γ : Type w
δ : Type u_1
ι : Sort x
f✝ g : Filter α
s✝ t✝ : Set α
s : Finset α
f : α → Filter β
t : Set β
h : t ∈ ⨅ (x : { i // i ∈ s }), f ↑x
⊢ ∃ p, (∀ (a : α), a ∈ s → p a ∈ f a) ∧ t = ⋂ (x : ↑↑s), p ↑x
[PROOFSTEP]
rcases(mem_iInf_of_finite _).1 h with ⟨p, hp, rfl⟩
[GOAL]
case refine'_1.intro.intro
α : Type u
β : Type v
γ : Type w
δ : Type u_1
ι : Sort x
f✝ g : Filter α
s✝ t : Set α
s : Finset α
f : α → Filter β
p : { i // i ∈ s } → Set β
hp : ∀ (i : { i // i ∈ s }), p i ∈ f ↑i
h : ⋂ (i : { i // i ∈ s }), p i ∈ ⨅ (x : { i // i ∈ s }), f ↑x
⊢ ∃ p_1, (∀ (a : α), a ∈ s → p_1 a ∈ f a) ∧ ⋂ (i : { i // i ∈ s }), p i = ⋂ (x : ↑↑s), p_1 ↑x
[PROOFSTEP]
refine' ⟨fun a => if h : a ∈ s then p ⟨a, h⟩ else univ, fun a ha => by simpa [ha] using hp ⟨a, ha⟩, _⟩
[GOAL]
α : Type u
β : Type v
γ : Type w
δ : Type u_1
ι : Sort x
f✝ g : Filter α
s✝ t : Set α
s : Finset α
f : α → Filter β
p : { i // i ∈ s } → Set β
hp : ∀ (i : { i // i ∈ s }), p i ∈ f ↑i
h : ⋂ (i : { i // i ∈ s }), p i ∈ ⨅ (x : { i // i ∈ s }), f ↑x
a : α
ha : a ∈ s
⊢ (fun a => if h : a ∈ s then p { val := a, property := h } else univ) a ∈ f a
[PROOFSTEP]
simpa [ha] using hp ⟨a, ha⟩
[GOAL]
case refine'_1.intro.intro
α : Type u
β : Type v
γ : Type w
δ : Type u_1
ι : Sort x
f✝ g : Filter α
s✝ t : Set α
s : Finset α
f : α → Filter β
p : { i // i ∈ s } → Set β
hp : ∀ (i : { i // i ∈ s }), p i ∈ f ↑i
h : ⋂ (i : { i // i ∈ s }), p i ∈ ⨅ (x : { i // i ∈ s }), f ↑x
⊢ ⋂ (i : { i // i ∈ s }), p i = ⋂ (x : ↑↑s), (fun a => if h : a ∈ s then p { val := a, property := h } else univ) ↑x
[PROOFSTEP]
refine' iInter_congr_of_surjective id surjective_id _
[GOAL]
case refine'_1.intro.intro
α : Type u
β : Type v
γ : Type w
δ : Type u_1
ι : Sort x
f✝ g : Filter α
s✝ t : Set α
s : Finset α
f : α → Filter β
p : { i // i ∈ s } → Set β
hp : ∀ (i : { i // i ∈ s }), p i ∈ f ↑i
h : ⋂ (i : { i // i ∈ s }), p i ∈ ⨅ (x : { i // i ∈ s }), f ↑x
⊢ ∀ (x : { i // i ∈ s }), (fun a => if h : a ∈ s then p { val := a, property := h } else univ) ↑(id x) = p x
[PROOFSTEP]
rintro ⟨a, ha⟩
[GOAL]
case refine'_1.intro.intro.mk
α : Type u
β : Type v
γ : Type w
δ : Type u_1
ι : Sort x
f✝ g : Filter α
s✝ t : Set α
s : Finset α
f : α → Filter β
p : { i // i ∈ s } → Set β
hp : ∀ (i : { i // i ∈ s }), p i ∈ f ↑i
h : ⋂ (i : { i // i ∈ s }), p i ∈ ⨅ (x : { i // i ∈ s }), f ↑x
a : α
ha : a ∈ s
⊢ (fun a => if h : a ∈ s then p { val := a, property := h } else univ) ↑(id { val := a, property := ha }) =
    p { val := a, property := ha }
[PROOFSTEP]
simp [ha]
[GOAL]
case refine'_2
α : Type u
β : Type v
γ : Type w
δ : Type u_1
ι : Sort x
f✝ g : Filter α
s✝ t✝ : Set α
s : Finset α
f : α → Filter β
t : Set β
⊢ (∃ p, (∀ (a : α), a ∈ s → p a ∈ f a) ∧ t = ⋂ (x : ↑↑s), p ↑x) → t ∈ ⨅ (x : { i // i ∈ s }), f ↑x
[PROOFSTEP]
rintro ⟨p, hpf, rfl⟩
[GOAL]
case refine'_2.intro.intro
α : Type u
β : Type v
γ : Type w
δ : Type u_1
ι : Sort x
f✝ g : Filter α
s✝ t : Set α
s : Finset α
f : α → Filter β
p : α → Set β
hpf : ∀ (a : α), a ∈ s → p a ∈ f a
⊢ ⋂ (x : ↑↑s), p ↑x ∈ ⨅ (x : { i // i ∈ s }), f ↑x
[PROOFSTEP]
exact iInter_mem.2 fun a => mem_iInf_of_mem a (hpf a a.2)
[GOAL]
α : Type u
β : Type v
γ : Type w
δ : Type u_1
ι : Sort x
f✝ g : Filter α
s t : Set α
f : ι → Filter α
inst✝ : Nonempty ι
hd : Directed (fun x x_1 => x ≥ x_1) f
⊢ ¬NeBot (iInf f) → ¬∀ (i : ι), NeBot (f i)
[PROOFSTEP]
simpa only [not_forall, not_neBot, ← empty_mem_iff_bot, mem_iInf_of_directed hd] using id
[GOAL]
α : Type u
β : Type v
γ : Type w
δ : Type u_1
ι : Sort x
f✝ g : Filter α
s t : Set α
f : ι → Filter α
hn : Nonempty α
hd : Directed (fun x x_1 => x ≥ x_1) f
hb : ∀ (i : ι), NeBot (f i)
⊢ NeBot (iInf f)
[PROOFSTEP]
cases isEmpty_or_nonempty ι
[GOAL]
case inl
α : Type u
β : Type v
γ : Type w
δ : Type u_1
ι : Sort x
f✝ g : Filter α
s t : Set α
f : ι → Filter α
hn : Nonempty α
hd : Directed (fun x x_1 => x ≥ x_1) f
hb : ∀ (i : ι), NeBot (f i)
h✝ : IsEmpty ι
⊢ NeBot (iInf f)
[PROOFSTEP]
constructor
[GOAL]
case inl.ne'
α : Type u
β : Type v
γ : Type w
δ : Type u_1
ι : Sort x
f✝ g : Filter α
s t : Set α
f : ι → Filter α
hn : Nonempty α
hd : Directed (fun x x_1 => x ≥ x_1) f
hb : ∀ (i : ι), NeBot (f i)
h✝ : IsEmpty ι
⊢ iInf f ≠ ⊥
[PROOFSTEP]
simp [iInf_of_empty f, top_ne_bot]
[GOAL]
case inr
α : Type u
β : Type v
γ : Type w
δ : Type u_1
ι : Sort x
f✝ g : Filter α
s t : Set α
f : ι → Filter α
hn : Nonempty α
hd : Directed (fun x x_1 => x ≥ x_1) f
hb : ∀ (i : ι), NeBot (f i)
h✝ : Nonempty ι
⊢ NeBot (iInf f)
[PROOFSTEP]
exact iInf_neBot_of_directed' hd hb
[GOAL]
α : Type u
β : Type v
γ : Type w
δ : Type u_1
ι : Sort x
f✝ g : Filter α
s✝ t : Set α
f : ι → Filter α
s : Set α
hs : s ∈ iInf f
p : Set α → Prop
uni : p univ
ins : ∀ {i : ι} {s₁ s₂ : Set α}, s₁ ∈ f i → p s₂ → p (s₁ ∩ s₂)
⊢ p s
[PROOFSTEP]
rw [mem_iInf_finite'] at hs
[GOAL]
α : Type u
β : Type v
γ : Type w
δ : Type u_1
ι : Sort x
f✝ g : Filter α
s✝ t : Set α
f : ι → Filter α
s : Set α
hs : ∃ t, s ∈ ⨅ (i : PLift ι) (_ : i ∈ t), f i.down
p : Set α → Prop
uni : p univ
ins : ∀ {i : ι} {s₁ s₂ : Set α}, s₁ ∈ f i → p s₂ → p (s₁ ∩ s₂)
⊢ p s
[PROOFSTEP]
simp only [← Finset.inf_eq_iInf] at hs
[GOAL]
α : Type u
β : Type v
γ : Type w
δ : Type u_1
ι : Sort x
f✝ g : Filter α
s✝ t : Set α
f : ι → Filter α
s : Set α
p : Set α → Prop
uni : p univ
ins : ∀ {i : ι} {s₁ s₂ : Set α}, s₁ ∈ f i → p s₂ → p (s₁ ∩ s₂)
hs : ∃ t, s ∈ Finset.inf t fun a => f a.down
⊢ p s
[PROOFSTEP]
rcases hs with ⟨is, his⟩
[GOAL]
case intro
α : Type u
β : Type v
γ : Type w
δ : Type u_1
ι : Sort x
f✝ g : Filter α
s✝ t : Set α
f : ι → Filter α
s : Set α
p : Set α → Prop
uni : p univ
ins : ∀ {i : ι} {s₁ s₂ : Set α}, s₁ ∈ f i → p s₂ → p (s₁ ∩ s₂)
is : Finset (PLift ι)
his : s ∈ Finset.inf is fun a => f a.down
⊢ p s
[PROOFSTEP]
induction is using Finset.induction_on generalizing s
[GOAL]
case intro.empty
α : Type u
β : Type v
γ : Type w
δ : Type u_1
ι : Sort x
f✝ g : Filter α
s✝ t : Set α
f : ι → Filter α
p : Set α → Prop
uni : p univ
ins : ∀ {i : ι} {s₁ s₂ : Set α}, s₁ ∈ f i → p s₂ → p (s₁ ∩ s₂)
s : Set α
his : s ∈ Finset.inf ∅ fun a => f a.down
⊢ p s
case intro.insert
α : Type u
β : Type v
γ : Type w
δ : Type u_1
ι : Sort x
f✝ g : Filter α
s✝¹ t : Set α
f : ι → Filter α
p : Set α → Prop
uni : p univ
ins : ∀ {i : ι} {s₁ s₂ : Set α}, s₁ ∈ f i → p s₂ → p (s₁ ∩ s₂)
a✝² : PLift ι
s✝ : Finset (PLift ι)
a✝¹ : ¬a✝² ∈ s✝
a✝ : ∀ {s : Set α}, (s ∈ Finset.inf s✝ fun a => f a.down) → p s
s : Set α
his : s ∈ Finset.inf (insert a✝² s✝) fun a => f a.down
⊢ p s
[PROOFSTEP]
case empty => rwa [mem_top.1 his]
[GOAL]
α : Type u
β : Type v
γ : Type w
δ : Type u_1
ι : Sort x
f✝ g : Filter α
s✝ t : Set α
f : ι → Filter α
p : Set α → Prop
uni : p univ
ins : ∀ {i : ι} {s₁ s₂ : Set α}, s₁ ∈ f i → p s₂ → p (s₁ ∩ s₂)
s : Set α
his : s ∈ Finset.inf ∅ fun a => f a.down
⊢ p s
[PROOFSTEP]
case empty => rwa [mem_top.1 his]
[GOAL]
α : Type u
β : Type v
γ : Type w
δ : Type u_1
ι : Sort x
f✝ g : Filter α
s✝ t : Set α
f : ι → Filter α
p : Set α → Prop
uni : p univ
ins : ∀ {i : ι} {s₁ s₂ : Set α}, s₁ ∈ f i → p s₂ → p (s₁ ∩ s₂)
s : Set α
his : s ∈ Finset.inf ∅ fun a => f a.down
⊢ p s
[PROOFSTEP]
rwa [mem_top.1 his]
[GOAL]
case intro.insert
α : Type u
β : Type v
γ : Type w
δ : Type u_1
ι : Sort x
f✝ g : Filter α
s✝¹ t : Set α
f : ι → Filter α
p : Set α → Prop
uni : p univ
ins : ∀ {i : ι} {s₁ s₂ : Set α}, s₁ ∈ f i → p s₂ → p (s₁ ∩ s₂)
a✝² : PLift ι
s✝ : Finset (PLift ι)
a✝¹ : ¬a✝² ∈ s✝
a✝ : ∀ {s : Set α}, (s ∈ Finset.inf s✝ fun a => f a.down) → p s
s : Set α
his : s ∈ Finset.inf (insert a✝² s✝) fun a => f a.down
⊢ p s
[PROOFSTEP]
case insert ih =>
  rw [Finset.inf_insert, mem_inf_iff] at his
  rcases his with ⟨s₁, hs₁, s₂, hs₂, rfl⟩
  exact ins hs₁ (ih hs₂)
[GOAL]
α : Type u
β : Type v
γ : Type w
δ : Type u_1
ι : Sort x
f✝ g : Filter α
s✝¹ t : Set α
f : ι → Filter α
p : Set α → Prop
uni : p univ
ins : ∀ {i : ι} {s₁ s₂ : Set α}, s₁ ∈ f i → p s₂ → p (s₁ ∩ s₂)
a✝¹ : PLift ι
s✝ : Finset (PLift ι)
a✝ : ¬a✝¹ ∈ s✝
ih : ∀ {s : Set α}, (s ∈ Finset.inf s✝ fun a => f a.down) → p s
s : Set α
his : s ∈ Finset.inf (insert a✝¹ s✝) fun a => f a.down
⊢ p s
[PROOFSTEP]
case insert ih =>
  rw [Finset.inf_insert, mem_inf_iff] at his
  rcases his with ⟨s₁, hs₁, s₂, hs₂, rfl⟩
  exact ins hs₁ (ih hs₂)
[GOAL]
α : Type u
β : Type v
γ : Type w
δ : Type u_1
ι : Sort x
f✝ g : Filter α
s✝¹ t : Set α
f : ι → Filter α
p : Set α → Prop
uni : p univ
ins : ∀ {i : ι} {s₁ s₂ : Set α}, s₁ ∈ f i → p s₂ → p (s₁ ∩ s₂)
a✝¹ : PLift ι
s✝ : Finset (PLift ι)
a✝ : ¬a✝¹ ∈ s✝
ih : ∀ {s : Set α}, (s ∈ Finset.inf s✝ fun a => f a.down) → p s
s : Set α
his : s ∈ Finset.inf (insert a✝¹ s✝) fun a => f a.down
⊢ p s
[PROOFSTEP]
rw [Finset.inf_insert, mem_inf_iff] at his
[GOAL]
α : Type u
β : Type v
γ : Type w
δ : Type u_1
ι : Sort x
f✝ g : Filter α
s✝¹ t : Set α
f : ι → Filter α
p : Set α → Prop
uni : p univ
ins : ∀ {i : ι} {s₁ s₂ : Set α}, s₁ ∈ f i → p s₂ → p (s₁ ∩ s₂)
a✝¹ : PLift ι
s✝ : Finset (PLift ι)
a✝ : ¬a✝¹ ∈ s✝
ih : ∀ {s : Set α}, (s ∈ Finset.inf s✝ fun a => f a.down) → p s
s : Set α
his : ∃ t₁, t₁ ∈ f a✝¹.down ∧ ∃ t₂, (t₂ ∈ Finset.inf s✝ fun a => f a.down) ∧ s = t₁ ∩ t₂
⊢ p s
[PROOFSTEP]
rcases his with ⟨s₁, hs₁, s₂, hs₂, rfl⟩
[GOAL]
case intro.intro.intro.intro
α : Type u
β : Type v
γ : Type w
δ : Type u_1
ι : Sort x
f✝ g : Filter α
s t : Set α
f : ι → Filter α
p : Set α → Prop
uni : p univ
ins : ∀ {i : ι} {s₁ s₂ : Set α}, s₁ ∈ f i → p s₂ → p (s₁ ∩ s₂)
a✝¹ : PLift ι
s✝ : Finset (PLift ι)
a✝ : ¬a✝¹ ∈ s✝
ih : ∀ {s : Set α}, (s ∈ Finset.inf s✝ fun a => f a.down) → p s
s₁ : Set α
hs₁ : s₁ ∈ f a✝¹.down
s₂ : Set α
hs₂ : s₂ ∈ Finset.inf s✝ fun a => f a.down
⊢ p (s₁ ∩ s₂)
[PROOFSTEP]
exact ins hs₁ (ih hs₂)
[GOAL]
α : Type u
β : Type v
γ : Type w
δ : Type u_1
ι : Sort x
f g : Filter α
s✝ t✝ s t : Set α
⊢ 𝓟 s ⊓ 𝓟 t ≤ 𝓟 (s ∩ t)
[PROOFSTEP]
simp only [le_principal_iff, mem_inf_iff]
[GOAL]
α : Type u
β : Type v
γ : Type w
δ : Type u_1
ι : Sort x
f g : Filter α
s✝ t✝ s t : Set α
⊢ ∃ t₁, t₁ ∈ 𝓟 s ∧ ∃ t₂, t₂ ∈ 𝓟 t ∧ s ∩ t = t₁ ∩ t₂
[PROOFSTEP]
exact ⟨s, Subset.rfl, t, Subset.rfl, rfl⟩
[GOAL]
α : Type u
β : Type v
γ : Type w
δ : Type u_1
ι : Sort x
f g : Filter α
s✝ t✝ s t : Set α
⊢ 𝓟 (s ∩ t) ≤ 𝓟 s ⊓ 𝓟 t
[PROOFSTEP]
simp [le_inf_iff, inter_subset_left, inter_subset_right]
[GOAL]
α : Type u
β : Type v
γ : Type w
δ : Type u_1
ι : Sort x
f g : Filter α
s✝ t✝ s t u : Set α
⊢ u ∈ 𝓟 s ⊔ 𝓟 t ↔ u ∈ 𝓟 (s ∪ t)
[PROOFSTEP]
simp only [union_subset_iff, mem_sup, mem_principal]
[GOAL]
α : Type u
β : Type v
γ : Type w
δ : Type u_1
ι✝ : Sort x
f g : Filter α
s✝ t : Set α
ι : Sort w
s : ι → Set α
x : Set α
⊢ x ∈ ⨆ (x : ι), 𝓟 (s x) ↔ x ∈ 𝓟 (⋃ (i : ι), s i)
[PROOFSTEP]
simp only [mem_iSup, mem_principal, iUnion_subset_iff]
[GOAL]
α : Type u
β : Type v
γ : Type w
δ : Type u_1
ι : Sort x
f g : Filter α
s✝ t s : Set α
⊢ 𝓟 s ⊓ 𝓟 sᶜ = ⊥
[PROOFSTEP]
rw [inf_principal, inter_compl_self, principal_empty]
[GOAL]
α : Type u
β : Type v
γ : Type w
δ : Type u_1
ι : Sort x
f g : Filter α
s✝ t s : Set α
⊢ 𝓟 s ⊔ 𝓟 sᶜ = ⊤
[PROOFSTEP]
rw [sup_principal, union_compl_self, principal_univ]
[GOAL]
α : Type u
β : Type v
γ : Type w
δ : Type u_1
ι : Sort x
f✝ g : Filter α
s✝ t✝ : Set α
f : Filter α
s t : Set α
⊢ s ∈ f ⊓ 𝓟 t ↔ tᶜ ∪ s ∈ f
[PROOFSTEP]
simp only [← le_principal_iff, (isCompl_principal s).le_left_iff, disjoint_assoc, inf_principal, ←
  (isCompl_principal (t ∩ sᶜ)).le_right_iff, compl_inter, compl_compl]
[GOAL]
α : Type u
β : Type v
γ : Type w
δ : Type u_1
ι : Sort x
f✝ g : Filter α
s✝ t✝ : Set α
f : Filter α
s t : Set α
⊢ s ∈ f ⊓ 𝓟 t ↔ {x | x ∈ t → x ∈ s} ∈ f
[PROOFSTEP]
simp only [mem_inf_principal', imp_iff_not_or]
[GOAL]
α : Type u
β : Type v
γ : Type w
δ : Type u_1
ι : Sort x
f✝ g : Filter α
s✝ t✝ : Set α
f : Filter α
s t : Set α
⊢ tᶜ ∪ s ∈ f ↔ {x | ¬x ∈ t ∨ x ∈ s} ∈ f
[PROOFSTEP]
rfl
[GOAL]
α : Type u
β : Type v
γ : Type w
δ : Type u_1
ι : Sort x
f✝ g : Filter α
s✝ t : Set α
f : ι → Filter α
s : Set α
⊢ ⨆ (i : ι), f i ⊓ 𝓟 s = (⨆ (i : ι), f i) ⊓ 𝓟 s
[PROOFSTEP]
ext
[GOAL]
case a
α : Type u
β : Type v
γ : Type w
δ : Type u_1
ι : Sort x
f✝ g : Filter α
s✝¹ t : Set α
f : ι → Filter α
s s✝ : Set α
⊢ s✝ ∈ ⨆ (i : ι), f i ⊓ 𝓟 s ↔ s✝ ∈ (⨆ (i : ι), f i) ⊓ 𝓟 s
[PROOFSTEP]
simp only [mem_iSup, mem_inf_principal]
[GOAL]
α : Type u
β : Type v
γ : Type w
δ : Type u_1
ι : Sort x
f✝ g : Filter α
s✝ t : Set α
f : Filter α
s : Set α
⊢ f ⊓ 𝓟 s = ⊥ ↔ sᶜ ∈ f
[PROOFSTEP]
rw [← empty_mem_iff_bot, mem_inf_principal]
[GOAL]
α : Type u
β : Type v
γ : Type w
δ : Type u_1
ι : Sort x
f✝ g : Filter α
s✝ t : Set α
f : Filter α
s : Set α
⊢ {x | x ∈ s → x ∈ ∅} ∈ f ↔ sᶜ ∈ f
[PROOFSTEP]
rfl
[GOAL]
α : Type u
β : Type v
γ : Type w
δ : Type u_1
ι : Sort x
f✝ g : Filter α
s✝ t : Set α
f : Filter α
s : Set α
h : f ⊓ 𝓟 sᶜ = ⊥
⊢ s ∈ f
[PROOFSTEP]
rwa [inf_principal_eq_bot, compl_compl] at h
[GOAL]
α : Type u
β : Type v
γ : Type w
δ : Type u_1
ι : Sort x
f✝ g : Filter α
s✝ t s : Set α
f : Filter α
⊢ 𝓟 s ≤ f ↔ ∀ (V : Set α), V ∈ f → s ⊆ V
[PROOFSTEP]
change (∀ V, V ∈ f → V ∈ _) ↔ _
[GOAL]
α : Type u
β : Type v
γ : Type w
δ : Type u_1
ι : Sort x
f✝ g : Filter α
s✝ t s : Set α
f : Filter α
⊢ (∀ (V : Set α), V ∈ f → V ∈ 𝓟 s) ↔ ∀ (V : Set α), V ∈ f → s ⊆ V
[PROOFSTEP]
simp_rw [mem_principal]
[GOAL]
α : Type u
β : Type v
γ : Type w
δ : Type u_1
ι✝ : Sort x
f✝ g : Filter α
s✝ t : Set α
ι : Type w
s : Finset ι
f : ι → Set α
⊢ ⨅ (i : ι) (_ : i ∈ s), 𝓟 (f i) = 𝓟 (⋂ (i : ι) (_ : i ∈ s), f i)
[PROOFSTEP]
induction' s using Finset.induction_on with i s _ hs
[GOAL]
case empty
α : Type u
β : Type v
γ : Type w
δ : Type u_1
ι✝ : Sort x
f✝ g : Filter α
s t : Set α
ι : Type w
f : ι → Set α
⊢ ⨅ (i : ι) (_ : i ∈ ∅), 𝓟 (f i) = 𝓟 (⋂ (i : ι) (_ : i ∈ ∅), f i)
[PROOFSTEP]
simp
[GOAL]
case insert
α : Type u
β : Type v
γ : Type w
δ : Type u_1
ι✝ : Sort x
f✝ g : Filter α
s✝ t : Set α
ι : Type w
f : ι → Set α
i : ι
s : Finset ι
a✝ : ¬i ∈ s
hs : ⨅ (i : ι) (_ : i ∈ s), 𝓟 (f i) = 𝓟 (⋂ (i : ι) (_ : i ∈ s), f i)
⊢ ⨅ (i_1 : ι) (_ : i_1 ∈ insert i s), 𝓟 (f i_1) = 𝓟 (⋂ (i_1 : ι) (_ : i_1 ∈ insert i s), f i_1)
[PROOFSTEP]
rw [Finset.iInf_insert, Finset.set_biInter_insert, hs, inf_principal]
[GOAL]
α : Type u
β : Type v
γ : Type w
δ : Type u_1
ι✝ : Sort x
f✝ g : Filter α
s t : Set α
ι : Type w
inst✝ : Finite ι
f : ι → Set α
⊢ ⨅ (i : ι), 𝓟 (f i) = 𝓟 (⋂ (i : ι), f i)
[PROOFSTEP]
cases nonempty_fintype ι
[GOAL]
case intro
α : Type u
β : Type v
γ : Type w
δ : Type u_1
ι✝ : Sort x
f✝ g : Filter α
s t : Set α
ι : Type w
inst✝ : Finite ι
f : ι → Set α
val✝ : Fintype ι
⊢ ⨅ (i : ι), 𝓟 (f i) = 𝓟 (⋂ (i : ι), f i)
[PROOFSTEP]
simpa using iInf_principal_finset Finset.univ f
[GOAL]
α : Type u
β : Type v
γ : Type w
δ : Type u_1
ι✝ : Sort x
f✝ g : Filter α
s✝ t : Set α
ι : Type w
s : Set ι
hs : Set.Finite s
f : ι → Set α
⊢ ⨅ (i : ι) (_ : i ∈ s), 𝓟 (f i) = 𝓟 (⋂ (i : ι) (_ : i ∈ s), f i)
[PROOFSTEP]
lift s to Finset ι using hs
[GOAL]
case intro
α : Type u
β : Type v
γ : Type w
δ : Type u_1
ι✝ : Sort x
f✝ g : Filter α
s✝ t : Set α
ι : Type w
f : ι → Set α
s : Finset ι
⊢ ⨅ (i : ι) (_ : i ∈ ↑s), 𝓟 (f i) = 𝓟 (⋂ (i : ι) (_ : i ∈ ↑s), f i)
[PROOFSTEP]
exact_mod_cast iInf_principal_finset s f
[GOAL]
α : Type u
β : Type v
γ : Type w
δ : Type u_1
ι : Sort x
f : Filter α
t : NeBot f
p : Prop
h : p
⊢ (∀ᶠ (x : α) in f, p) ↔ p
[PROOFSTEP]
simp [h]
[GOAL]
α : Type u
β : Type v
γ : Type w
δ : Type u_1
ι : Sort x
f : Filter α
t : NeBot f
p : Prop
h : ¬p
⊢ (∀ᶠ (x : α) in f, p) ↔ p
[PROOFSTEP]
simpa [h] using t.ne
[GOAL]
α : Type u
β : Type v
γ : Type w
δ : Type u_1
ι : Sort x
f : Filter α
p q : α → Prop
h : ∀ᶠ (x : α) in f, p x ↔ q x
hq : ∀ᶠ (x : α) in f, q x
⊢ ∀ᶠ (x : α) in f, q x ↔ p x
[PROOFSTEP]
simpa only [Iff.comm] using h
[GOAL]
α : Type u
β : Type v
γ : Type w
δ : Type u_1
ι✝ : Sort x
ι : Type u_2
inst✝ : Finite ι
l : Filter α
p : ι → α → Prop
⊢ (∀ᶠ (x : α) in l, ∀ (i : ι), p i x) ↔ ∀ (i : ι), ∀ᶠ (x : α) in l, p i x
[PROOFSTEP]
cases nonempty_fintype ι
[GOAL]
case intro
α : Type u
β : Type v
γ : Type w
δ : Type u_1
ι✝ : Sort x
ι : Type u_2
inst✝ : Finite ι
l : Filter α
p : ι → α → Prop
val✝ : Fintype ι
⊢ (∀ᶠ (x : α) in l, ∀ (i : ι), p i x) ↔ ∀ (i : ι), ∀ᶠ (x : α) in l, p i x
[PROOFSTEP]
simpa only [Filter.Eventually, setOf_forall] using iInter_mem
[GOAL]
α : Type u
β : Type v
γ : Type w
δ : Type u_1
ι✝ : Sort x
ι : Type u_2
I : Set ι
hI : Set.Finite I
l : Filter α
p : ι → α → Prop
⊢ (∀ᶠ (x : α) in l, ∀ (i : ι), i ∈ I → p i x) ↔ ∀ (i : ι), i ∈ I → ∀ᶠ (x : α) in l, p i x
[PROOFSTEP]
simpa only [Filter.Eventually, setOf_forall] using biInter_mem hI
[GOAL]
α : Type u
β : Type v
γ : Type w
δ : Type u_1
ι : Sort x
f : Filter α
p : Prop
q : α → Prop
h : p
⊢ (∀ᶠ (x : α) in f, p ∨ q x) ↔ p ∨ ∀ᶠ (x : α) in f, q x
[PROOFSTEP]
simp [h]
[GOAL]
α : Type u
β : Type v
γ : Type w
δ : Type u_1
ι : Sort x
f : Filter α
p : Prop
q : α → Prop
h : ¬p
⊢ (∀ᶠ (x : α) in f, p ∨ q x) ↔ p ∨ ∀ᶠ (x : α) in f, q x
[PROOFSTEP]
simp [h]
[GOAL]
α : Type u
β : Type v
γ : Type w
δ : Type u_1
ι : Sort x
f : Filter α
p : α → Prop
q : Prop
⊢ (∀ᶠ (x : α) in f, p x ∨ q) ↔ (∀ᶠ (x : α) in f, p x) ∨ q
[PROOFSTEP]
simp only [@or_comm _ q, eventually_or_distrib_left]
[GOAL]
α : Type u
β : Type v
γ : Type w
δ : Type u_1
ι : Sort x
f : Filter α
p : Prop
q : α → Prop
⊢ (∀ᶠ (x : α) in f, p → q x) ↔ p → ∀ᶠ (x : α) in f, q x
[PROOFSTEP]
simp only [imp_iff_not_or, eventually_or_distrib_left]
[GOAL]
α : Type u
β : Type v
γ : Type w
δ : Type u_1
ι : Sort x
p q : α → Prop
f : Filter α
hp : ∃ᶠ (x : α) in f, p x
hq : ∀ᶠ (x : α) in f, q x
⊢ ∃ᶠ (x : α) in f, p x ∧ q x
[PROOFSTEP]
refine' mt (fun h => hq.mp <| h.mono _) hp
[GOAL]
α : Type u
β : Type v
γ : Type w
δ : Type u_1
ι : Sort x
p q : α → Prop
f : Filter α
hp : ∃ᶠ (x : α) in f, p x
hq : ∀ᶠ (x : α) in f, q x
h : ∀ᶠ (x : α) in f, ¬(fun x => p x ∧ q x) x
⊢ ∀ (x : α), ¬(fun x => p x ∧ q x) x → q x → ¬(fun x => p x) x
[PROOFSTEP]
exact fun x hpq hq hp => hpq ⟨hp, hq⟩
[GOAL]
α : Type u
β : Type v
γ : Type w
δ : Type u_1
ι : Sort x
p q : α → Prop
f : Filter α
hp : ∀ᶠ (x : α) in f, p x
hq : ∃ᶠ (x : α) in f, q x
⊢ ∃ᶠ (x : α) in f, p x ∧ q x
[PROOFSTEP]
simpa only [and_comm] using hq.and_eventually hp
[GOAL]
α : Type u
β : Type v
γ : Type w
δ : Type u_1
ι : Sort x
p : α → Prop
f : Filter α
hp : ∃ᶠ (x : α) in f, p x
⊢ ∃ x, p x
[PROOFSTEP]
by_contra H
[GOAL]
α : Type u
β : Type v
γ : Type w
δ : Type u_1
ι : Sort x
p : α → Prop
f : Filter α
hp : ∃ᶠ (x : α) in f, p x
H : ¬∃ x, p x
⊢ False
[PROOFSTEP]
replace H : ∀ᶠ x in f, ¬p x
[GOAL]
case H
α : Type u
β : Type v
γ : Type w
δ : Type u_1
ι : Sort x
p : α → Prop
f : Filter α
hp : ∃ᶠ (x : α) in f, p x
H : ¬∃ x, p x
⊢ ∀ᶠ (x : α) in f, ¬p x
α : Type u
β : Type v
γ : Type w
δ : Type u_1
ι : Sort x
p : α → Prop
f : Filter α
hp : ∃ᶠ (x : α) in f, p x
H : ∀ᶠ (x : α) in f, ¬p x
⊢ False
[PROOFSTEP]
exact eventually_of_forall (not_exists.1 H)
[GOAL]
α : Type u
β : Type v
γ : Type w
δ : Type u_1
ι : Sort x
p : α → Prop
f : Filter α
hp : ∃ᶠ (x : α) in f, p x
H : ∀ᶠ (x : α) in f, ¬p x
⊢ False
[PROOFSTEP]
exact hp H
[GOAL]
α : Type u
β : Type v
γ : Type w
δ : Type u_1
ι : Sort x
p : α → Prop
f : Filter α
H : ∀ {q : α → Prop}, (∀ᶠ (x : α) in f, q x) → ∃ x, p x ∧ q x
hp : ∀ᶠ (x : α) in f, ¬(fun x => p x) x
⊢ False
[PROOFSTEP]
simpa only [and_not_self_iff, exists_false] using H hp
[GOAL]
α : Type u
β : Type v
γ : Type w
δ : Type u_1
ι : Sort x
f : Filter α
P : α → Prop
⊢ (∃ᶠ (x : α) in f, P x) ↔ ∀ {U : Set α}, U ∈ f → ∃ x, x ∈ U ∧ P x
[PROOFSTEP]
simp only [frequently_iff_forall_eventually_exists_and, exists_prop, @and_comm (P _)]
[GOAL]
α : Type u
β : Type v
γ : Type w
δ : Type u_1
ι : Sort x
f : Filter α
P : α → Prop
⊢ (∀ {q : α → Prop}, (∀ᶠ (x : α) in f, q x) → ∃ x, q x ∧ P x) ↔ ∀ {U : Set α}, U ∈ f → ∃ x, x ∈ U ∧ P x
[PROOFSTEP]
rfl
[GOAL]
α : Type u
β : Type v
γ : Type w
δ : Type u_1
ι : Sort x
p : α → Prop
f : Filter α
⊢ (¬∀ᶠ (x : α) in f, p x) ↔ ∃ᶠ (x : α) in f, ¬p x
[PROOFSTEP]
simp [Filter.Frequently]
[GOAL]
α : Type u
β : Type v
γ : Type w
δ : Type u_1
ι : Sort x
p : α → Prop
f : Filter α
⊢ (¬∃ᶠ (x : α) in f, p x) ↔ ∀ᶠ (x : α) in f, ¬p x
[PROOFSTEP]
simp only [Filter.Frequently, not_not]
[GOAL]
α : Type u
β : Type v
γ : Type w
δ : Type u_1
ι : Sort x
f : Filter α
⊢ (∃ᶠ (x : α) in f, True) ↔ NeBot f
[PROOFSTEP]
simp [Filter.Frequently, -not_eventually, eventually_false_iff_eq_bot, neBot_iff]
[GOAL]
α : Type u
β : Type v
γ : Type w
δ : Type u_1
ι : Sort x
f : Filter α
⊢ ¬∃ᶠ (x : α) in f, False
[PROOFSTEP]
simp
[GOAL]
α : Type u
β : Type v
γ : Type w
δ : Type u_1
ι : Sort x
f : Filter α
inst✝ : NeBot f
p : Prop
h : p
⊢ (∃ᶠ (x : α) in f, p) ↔ p
[PROOFSTEP]
simpa [h]
[GOAL]
α : Type u
β : Type v
γ : Type w
δ : Type u_1
ι : Sort x
f : Filter α
inst✝ : NeBot f
p : Prop
h : ¬p
⊢ (∃ᶠ (x : α) in f, p) ↔ p
[PROOFSTEP]
simp [h]
[GOAL]
α : Type u
β : Type v
γ : Type w
δ : Type u_1
ι : Sort x
f : Filter α
p q : α → Prop
⊢ (∃ᶠ (x : α) in f, p x ∨ q x) ↔ (∃ᶠ (x : α) in f, p x) ∨ ∃ᶠ (x : α) in f, q x
[PROOFSTEP]
simp only [Filter.Frequently, ← not_and_or, not_or, eventually_and]
[GOAL]
α : Type u
β : Type v
γ : Type w
δ : Type u_1
ι : Sort x
f : Filter α
inst✝ : NeBot f
p : Prop
q : α → Prop
⊢ (∃ᶠ (x : α) in f, p ∨ q x) ↔ p ∨ ∃ᶠ (x : α) in f, q x
[PROOFSTEP]
simp
[GOAL]
α : Type u
β : Type v
γ : Type w
δ : Type u_1
ι : Sort x
f : Filter α
inst✝ : NeBot f
p : α → Prop
q : Prop
⊢ (∃ᶠ (x : α) in f, p x ∨ q) ↔ (∃ᶠ (x : α) in f, p x) ∨ q
[PROOFSTEP]
simp
[GOAL]
α : Type u
β : Type v
γ : Type w
δ : Type u_1
ι : Sort x
f : Filter α
p q : α → Prop
⊢ (∃ᶠ (x : α) in f, p x → q x) ↔ (∀ᶠ (x : α) in f, p x) → ∃ᶠ (x : α) in f, q x
[PROOFSTEP]
simp [imp_iff_not_or, not_eventually, frequently_or_distrib]
[GOAL]
α : Type u
β : Type v
γ : Type w
δ : Type u_1
ι : Sort x
f : Filter α
inst✝ : NeBot f
p : Prop
q : α → Prop
⊢ (∃ᶠ (x : α) in f, p → q x) ↔ p → ∃ᶠ (x : α) in f, q x
[PROOFSTEP]
simp
[GOAL]
α : Type u
β : Type v
γ : Type w
δ : Type u_1
ι : Sort x
f : Filter α
inst✝ : NeBot f
p : α → Prop
q : Prop
⊢ (∃ᶠ (x : α) in f, p x → q) ↔ (∀ᶠ (x : α) in f, p x) → q
[PROOFSTEP]
simp
[GOAL]
α : Type u
β : Type v
γ : Type w
δ : Type u_1
ι : Sort x
f : Filter α
p : α → Prop
q : Prop
⊢ (∀ᶠ (x : α) in f, p x → q) ↔ (∃ᶠ (x : α) in f, p x) → q
[PROOFSTEP]
simp only [imp_iff_not_or, eventually_or_distrib_right, not_frequently]
[GOAL]
α : Type u
β : Type v
γ : Type w
δ : Type u_1
ι : Sort x
f : Filter α
p : Prop
q : α → Prop
⊢ (∃ᶠ (x : α) in f, p ∧ q x) ↔ p ∧ ∃ᶠ (x : α) in f, q x
[PROOFSTEP]
simp only [Filter.Frequently, not_and, eventually_imp_distrib_left, not_imp]
[GOAL]
α : Type u
β : Type v
γ : Type w
δ : Type u_1
ι : Sort x
f : Filter α
p : α → Prop
q : Prop
⊢ (∃ᶠ (x : α) in f, p x ∧ q) ↔ (∃ᶠ (x : α) in f, p x) ∧ q
[PROOFSTEP]
simp only [@and_comm _ q, frequently_and_distrib_left]
[GOAL]
α : Type u
β : Type v
γ : Type w
δ : Type u_1
ι : Sort x
p : α → Prop
⊢ ¬∃ᶠ (x : α) in ⊥, p x
[PROOFSTEP]
simp
[GOAL]
α : Type u
β : Type v
γ : Type w
δ : Type u_1
ι : Sort x
p : α → Prop
⊢ (∃ᶠ (x : α) in ⊤, p x) ↔ ∃ x, p x
[PROOFSTEP]
simp [Filter.Frequently]
[GOAL]
α : Type u
β : Type v
γ : Type w
δ : Type u_1
ι : Sort x
a : Set α
p : α → Prop
⊢ (∃ᶠ (x : α) in 𝓟 a, p x) ↔ ∃ x, x ∈ a ∧ p x
[PROOFSTEP]
simp [Filter.Frequently, not_forall]
[GOAL]
α : Type u
β : Type v
γ : Type w
δ : Type u_1
ι : Sort x
p : α → Prop
f g : Filter α
⊢ (∃ᶠ (x : α) in f ⊔ g, p x) ↔ (∃ᶠ (x : α) in f, p x) ∨ ∃ᶠ (x : α) in g, p x
[PROOFSTEP]
simp only [Filter.Frequently, eventually_sup, not_and_or]
[GOAL]
α : Type u
β : Type v
γ : Type w
δ : Type u_1
ι : Sort x
p : α → Prop
fs : Set (Filter α)
⊢ (∃ᶠ (x : α) in sSup fs, p x) ↔ ∃ f, f ∈ fs ∧ ∃ᶠ (x : α) in f, p x
[PROOFSTEP]
simp only [Filter.Frequently, not_forall, eventually_sSup, exists_prop]
[GOAL]
α : Type u
β : Type v
γ : Type w
δ : Type u_1
ι : Sort x
p : α → Prop
fs : β → Filter α
⊢ (∃ᶠ (x : α) in ⨆ (b : β), fs b, p x) ↔ ∃ b, ∃ᶠ (x : α) in fs b, p x
[PROOFSTEP]
simp only [Filter.Frequently, eventually_iSup, not_forall]
[GOAL]
α : Type u
β : Type v
γ : Type w
δ : Type u_1
ι : Sort x
r : α → β → Prop
l : Filter α
inst✝ : NeBot l
h : ∀ᶠ (x : α) in l, ∃ y, r x y
⊢ ∃ f, ∀ᶠ (x : α) in l, r x (f x)
[PROOFSTEP]
haveI : Nonempty β :=
  let ⟨_, hx⟩ := h.exists;
  hx.nonempty
[GOAL]
α : Type u
β : Type v
γ : Type w
δ : Type u_1
ι : Sort x
r : α → β → Prop
l : Filter α
inst✝ : NeBot l
h : ∀ᶠ (x : α) in l, ∃ y, r x y
this : Nonempty β
⊢ ∃ f, ∀ᶠ (x : α) in l, r x (f x)
[PROOFSTEP]
choose! f hf using fun x (hx : ∃ y, r x y) => hx
[GOAL]
α : Type u
β : Type v
γ : Type w
δ : Type u_1
ι : Sort x
r : α → β → Prop
l : Filter α
inst✝ : NeBot l
h : ∀ᶠ (x : α) in l, ∃ y, r x y
this : Nonempty β
f : α → β
hf : ∀ (x : α), (∃ y, r x y) → r x (f x)
⊢ ∃ f, ∀ᶠ (x : α) in l, r x (f x)
[PROOFSTEP]
exact ⟨f, h.mono hf⟩
[GOAL]
α : Type u
β : Type v
γ : Type w
δ : Type u_1
ι : Sort x
s : Set α
l : Filter α
⊢ s =ᶠ[l] univ ↔ s ∈ l
[PROOFSTEP]
simp [eventuallyEq_set]
[GOAL]
α : Type u
β : Type v
γ : Type w
δ : Type u_1
ι : Sort x
l : Filter α
f f' : α → β
hf : f =ᶠ[l] f'
g g' : α → γ
hg : g =ᶠ[l] g'
⊢ ∀ (x : α), g x = g' x → f x = f' x → (fun x => (f x, g x)) x = (fun x => (f' x, g' x)) x
[PROOFSTEP]
intros
[GOAL]
α : Type u
β : Type v
γ : Type w
δ : Type u_1
ι : Sort x
l : Filter α
f f' : α → β
hf : f =ᶠ[l] f'
g g' : α → γ
hg : g =ᶠ[l] g'
x✝ : α
a✝¹ : g x✝ = g' x✝
a✝ : f x✝ = f' x✝
⊢ (fun x => (f x, g x)) x✝ = (fun x => (f' x, g' x)) x✝
[PROOFSTEP]
simp only [*]
[GOAL]
α : Type u
β : Type v
γ : Type w
δ : Type u_1
ι : Sort x
s : Set α
l : Filter α
⊢ (∀ᶠ (x : α) in l, x ∈ s ↔ x ∈ ∅) ↔ ∀ᶠ (x : α) in l, ¬x ∈ s
[PROOFSTEP]
simp
[GOAL]
α : Type u
β : Type v
γ : Type w
δ : Type u_1
ι : Sort x
s t : Set α
l : Filter α
⊢ s ∩ t =ᶠ[l] s ↔ ∀ᶠ (x : α) in l, x ∈ s → x ∈ t
[PROOFSTEP]
simp only [eventuallyEq_set, mem_inter_iff, and_iff_left_iff_imp]
[GOAL]
α : Type u
β : Type v
γ : Type w
δ : Type u_1
ι : Sort x
s t : Set α
l : Filter α
⊢ s ∩ t =ᶠ[l] t ↔ ∀ᶠ (x : α) in l, x ∈ t → x ∈ s
[PROOFSTEP]
rw [inter_comm, inter_eventuallyEq_left]
[GOAL]
α : Type u
β : Type v
γ : Type w
δ : Type u_1
ι : Sort x
inst✝ : AddGroup β
f g : α → β
l : Filter α
h : f =ᶠ[l] g
⊢ f - g =ᶠ[l] 0
[PROOFSTEP]
simpa using ((EventuallyEq.refl l f).sub h).symm
[GOAL]
α : Type u
β : Type v
γ : Type w
δ : Type u_1
ι : Sort x
inst✝ : AddGroup β
f g : α → β
l : Filter α
h : f - g =ᶠ[l] 0
⊢ f =ᶠ[l] g
[PROOFSTEP]
simpa using h.add (EventuallyEq.refl l g)
[GOAL]
α : Type u
β : Type v
γ : Type w
δ : Type u_1
ι : Sort x
inst✝ : LE β
l : Filter α
f f' g g' : α → β
H✝ : f ≤ᶠ[l] g
hf✝ : f =ᶠ[l] f'
hg✝ : g =ᶠ[l] g'
x : α
hf : f x = f' x
hg : g x = g' x
H : f x ≤ g x
⊢ f' x ≤ g' x
[PROOFSTEP]
rwa [hf, hg] at H
[GOAL]
α : Type u
β : Type v
γ : Type w
δ : Type u_1
ι : Sort x
inst✝ : PartialOrder β
l : Filter α
f g : α → β
⊢ f =ᶠ[l] g ↔ f ≤ᶠ[l] g ∧ g ≤ᶠ[l] f
[PROOFSTEP]
simp only [EventuallyEq, EventuallyLE, le_antisymm_iff, eventually_and]
[GOAL]
α : Type u
β : Type v
γ : Type w
δ : Type u_1
ι : Sort x
s t : Set α
l : Filter α
⊢ t ∈ l ⊓ 𝓟 s ↔ l ⊓ 𝓟 s ≤ l ⊓ 𝓟 t
[PROOFSTEP]
simp only [le_inf_iff, inf_le_left, true_and_iff, le_principal_iff]
[GOAL]
α : Type u
β : Type v
γ : Type w
δ : Type u_1
ι : Sort x
s t : Set α
l : Filter α
⊢ s =ᶠ[l] t ↔ l ⊓ 𝓟 s = l ⊓ 𝓟 t
[PROOFSTEP]
simp only [eventuallyLE_antisymm_iff, le_antisymm_iff, set_eventuallyLE_iff_inf_principal_le]
[GOAL]
α : Type u
β : Type v
γ : Type w
δ : Type u_1
ι : Sort x
inst✝³ : MulZeroClass β
inst✝² : PartialOrder β
inst✝¹ : PosMulMono β
inst✝ : MulPosMono β
l : Filter α
f₁ f₂ g₁ g₂ : α → β
hf : f₁ ≤ᶠ[l] f₂
hg : g₁ ≤ᶠ[l] g₂
hg₀ : 0 ≤ᶠ[l] g₁
hf₀ : 0 ≤ᶠ[l] f₂
⊢ f₁ * g₁ ≤ᶠ[l] f₂ * g₂
[PROOFSTEP]
filter_upwards [hf, hg, hg₀, hf₀] with x using _root_.mul_le_mul
[GOAL]
α : Type u
β : Type v
γ : Type w
δ : Type u_1
ι : Sort x
inst✝³ : Mul β
inst✝² : Preorder β
inst✝¹ : CovariantClass β β (fun x x_1 => x * x_1) fun x x_1 => x ≤ x_1
inst✝ : CovariantClass β β (swap fun x x_1 => x * x_1) fun x x_1 => x ≤ x_1
l : Filter α
f₁ f₂ g₁ g₂ : α → β
hf : f₁ ≤ᶠ[l] f₂
hg : g₁ ≤ᶠ[l] g₂
⊢ f₁ * g₁ ≤ᶠ[l] f₂ * g₂
[PROOFSTEP]
filter_upwards [hf, hg] with x hfx hgx using _root_.mul_le_mul' hfx hgx
[GOAL]
α : Type u
β : Type v
γ : Type w
δ : Type u_1
ι : Sort x
inst✝ : OrderedSemiring β
l : Filter α
f g : α → β
hf : 0 ≤ᶠ[l] f
hg : 0 ≤ᶠ[l] g
⊢ 0 ≤ᶠ[l] f * g
[PROOFSTEP]
filter_upwards [hf, hg] with x using _root_.mul_nonneg
[GOAL]
α : Type u
β : Type v
γ : Type w
δ : Type u_1
ι : Sort x
inst✝ : SemilatticeSup β
l : Filter α
f₁ f₂ g₁ g₂ : α → β
hf : f₁ ≤ᶠ[l] f₂
hg : g₁ ≤ᶠ[l] g₂
⊢ f₁ ⊔ g₁ ≤ᶠ[l] f₂ ⊔ g₂
[PROOFSTEP]
filter_upwards [hf, hg] with x hfx hgx using sup_le_sup hfx hgx
[GOAL]
α : Type u
β : Type v
γ : Type w
δ : Type u_1
ι : Sort x
inst✝ : SemilatticeSup β
l : Filter α
f g h : α → β
hf : f ≤ᶠ[l] h
hg : g ≤ᶠ[l] h
⊢ f ⊔ g ≤ᶠ[l] h
[PROOFSTEP]
filter_upwards [hf, hg] with x hfx hgx using _root_.sup_le hfx hgx
[GOAL]
α : Type u
β : Type v
γ : Type w
δ : Type u_1
ι : Sort x
f : Filter α
m : α → β
m' : β → γ
s : Set α
t : Set β
hf : Injective m
h : m '' s ∈ map m f
⊢ s ∈ f
[PROOFSTEP]
rwa [← preimage_image_eq s hf]
[GOAL]
α : Type u
β : Type v
γ : Type w
δ : Type u_1
ι : Sort x
f : Filter α
m : α → β
m' : β → γ
s : Set α
t : Set β
⊢ range m ∈ map m f
[PROOFSTEP]
rw [← image_univ]
[GOAL]
α : Type u
β : Type v
γ : Type w
δ : Type u_1
ι : Sort x
f : Filter α
m : α → β
m' : β → γ
s : Set α
t : Set β
⊢ m '' univ ∈ map m f
[PROOFSTEP]
exact image_mem_map univ_mem
[GOAL]
α : Type u
β : Type v
γ : Type w
δ : Type u_1
ι : Sort x
m : α → β
f : Filter β
⊢ m ⁻¹' univ ⊆ univ
[PROOFSTEP]
simp only [subset_univ, preimage_univ]
[GOAL]
α : Type u
β : Type v
γ : Type w
δ : Type u_1
ι : Sort x
f : α → β
l : Filter β
p : α → Prop
s : Set α
x✝ : s ∈ comap f l
t : Set β
ht : t ∈ l
hts : f ⁻¹' t ⊆ s
y : β
hy : y ∈ t
x : α
hx : f x = y
⊢ f x ∈ t
[PROOFSTEP]
rwa [hx]
[GOAL]
α : Type u
β : Type v
γ : Type w
δ : Type u_1
ι : Sort x
f : α → β
l : Filter β
p : α → Prop
s✝ : Set α
x : α
s : Set β
F : Filter (α × β)
⊢ s ∈ comap (Prod.mk x) F ↔ {p | p.fst = x → p.snd ∈ s} ∈ F
[PROOFSTEP]
simp_rw [mem_comap', Prod.ext_iff, and_imp, @forall_swap β (_ = _), forall_eq, eq_comm]
[GOAL]
α : Type u
β : Type v
γ : Type w
δ : Type u_1
ι : Sort x
f : α → β
l : Filter β
p : α → Prop
s : Set α
⊢ (∃ᶠ (a : α) in comap f l, p a) ↔ ∃ᶠ (b : β) in l, ∃ a, f a = b ∧ p a
[PROOFSTEP]
simp only [Filter.Frequently, eventually_comap, not_exists, not_and]
[GOAL]
α : Type u
β : Type v
γ : Type w
δ : Type u_1
ι : Sort x
f : α → β
l : Filter β
p : α → Prop
s : Set α
⊢ s ∈ comap f l ↔ (f '' sᶜ)ᶜ ∈ l
[PROOFSTEP]
simp only [mem_comap'', kernImage_eq_compl]
[GOAL]
α : Type u
β : Type v
γ : Type w
δ : Type u_1
ι : Sort x
f : α → β
l : Filter β
p : α → Prop
s : Set α
⊢ sᶜ ∈ comap f l ↔ (f '' s)ᶜ ∈ l
[PROOFSTEP]
rw [mem_comap_iff_compl, compl_compl]
[GOAL]
α : Type u
β : Type v
γ : Type w
δ : Type u_1
ι : Sort x
m : α → β
f : Filter α
⊢ kernImage m univ = univ
[PROOFSTEP]
simp [kernImage_eq_compl]
[GOAL]
α : Type u
β : Type v
γ : Type w
δ : Type u_1
ι : Sort x
m : α → β
f : Filter α
⊢ ∀ {x y : Set β}, x ∈ kernImage m '' f.sets → x ⊆ y → y ∈ kernImage m '' f.sets
[PROOFSTEP]
rintro _ t ⟨s, hs, rfl⟩ hst
[GOAL]
case intro.intro
α : Type u
β : Type v
γ : Type w
δ : Type u_1
ι : Sort x
m : α → β
f : Filter α
t : Set β
s : Set α
hs : s ∈ f.sets
hst : kernImage m s ⊆ t
⊢ t ∈ kernImage m '' f.sets
[PROOFSTEP]
refine ⟨s ∪ m ⁻¹' t, mem_of_superset hs (subset_union_left s _), ?_⟩
[GOAL]
case intro.intro
α : Type u
β : Type v
γ : Type w
δ : Type u_1
ι : Sort x
m : α → β
f : Filter α
t : Set β
s : Set α
hs : s ∈ f.sets
hst : kernImage m s ⊆ t
⊢ kernImage m (s ∪ m ⁻¹' t) = t
[PROOFSTEP]
rw [kernImage_union_preimage, union_eq_right_iff_subset.mpr hst]
[GOAL]
α : Type u
β : Type v
γ : Type w
δ : Type u_1
ι : Sort x
m : α → β
f : Filter α
⊢ ∀ {x y : Set β}, x ∈ kernImage m '' f.sets → y ∈ kernImage m '' f.sets → x ∩ y ∈ kernImage m '' f.sets
[PROOFSTEP]
rintro _ _ ⟨s₁, h₁, rfl⟩ ⟨s₂, h₂, rfl⟩
[GOAL]
case intro.intro.intro.intro
α : Type u
β : Type v
γ : Type w
δ : Type u_1
ι : Sort x
m : α → β
f : Filter α
s₁ : Set α
h₁ : s₁ ∈ f.sets
s₂ : Set α
h₂ : s₂ ∈ f.sets
⊢ kernImage m s₁ ∩ kernImage m s₂ ∈ kernImage m '' f.sets
[PROOFSTEP]
exact ⟨s₁ ∩ s₂, f.inter_sets h₁ h₂, Set.preimage_kernImage.u_inf⟩
[GOAL]
α : Type u
β : Type v
γ : Type w
δ : Type u_1
ι : Sort x
m : α → β
f : Filter α
s : Set β
⊢ s ∈ kernMap m f ↔ ∃ t, tᶜ ∈ f ∧ m '' t = sᶜ
[PROOFSTEP]
rw [mem_kernMap, compl_surjective.exists]
[GOAL]
α : Type u
β : Type v
γ : Type w
δ : Type u_1
ι : Sort x
m : α → β
f : Filter α
s : Set β
⊢ (∃ x, xᶜ ∈ f ∧ kernImage m xᶜ = s) ↔ ∃ t, tᶜ ∈ f ∧ m '' t = sᶜ
[PROOFSTEP]
refine exists_congr (fun x ↦ and_congr_right fun _ ↦ ?_)
[GOAL]
α : Type u
β : Type v
γ : Type w
δ : Type u_1
ι : Sort x
m : α → β
f : Filter α
s : Set β
x : Set α
x✝ : xᶜ ∈ f
⊢ kernImage m xᶜ = s ↔ m '' x = sᶜ
[PROOFSTEP]
rw [kernImage_compl, compl_eq_comm, eq_comm]
[GOAL]
α : Type u
β : Type v
γ : Type w
δ : Type u_1
ι : Sort x
m : α → β
f : Filter α
s : Set β
⊢ sᶜ ∈ kernMap m f ↔ ∃ t, tᶜ ∈ f ∧ m '' t = s
[PROOFSTEP]
simp_rw [mem_kernMap_iff_compl, compl_compl]
[GOAL]
α : Type u
β : Type v
γ : Type w
δ : Type u_1
ι : Sort x
a : α
s : Set α
⊢ s ∈ 𝓟 {a} ↔ s ∈ pure a
[PROOFSTEP]
simp only [mem_pure, mem_principal, singleton_subset_iff]
[GOAL]
α : Type u
β : Type v
γ : Type w
δ : Type u_1
ι : Sort x
a : α
m : α → Filter β
⊢ bind (pure a) m = m a
[PROOFSTEP]
simp only [Bind.bind, bind, map_pure, join_pure]
[GOAL]
α : Type u
β : Type v
γ : Type w
δ : Type u_1
ι : Sort x
f f₁ f₂ : Filter α
g g₁ g₂ : Filter β
m : α → β
m' : β → γ
s : Set α
t : Set β
inst✝ : NeBot f
c : β
⊢ map (fun x => c) f = pure c
[PROOFSTEP]
ext s
[GOAL]
case a
α : Type u
β : Type v
γ : Type w
δ : Type u_1
ι : Sort x
f f₁ f₂ : Filter α
g g₁ g₂ : Filter β
m : α → β
m' : β → γ
s✝ : Set α
t : Set β
inst✝ : NeBot f
c : β
s : Set β
⊢ s ∈ map (fun x => c) f ↔ s ∈ pure c
[PROOFSTEP]
by_cases h : c ∈ s
[GOAL]
case pos
α : Type u
β : Type v
γ : Type w
δ : Type u_1
ι : Sort x
f f₁ f₂ : Filter α
g g₁ g₂ : Filter β
m : α → β
m' : β → γ
s✝ : Set α
t : Set β
inst✝ : NeBot f
c : β
s : Set β
h : c ∈ s
⊢ s ∈ map (fun x => c) f ↔ s ∈ pure c
[PROOFSTEP]
simp [h]
[GOAL]
case neg
α : Type u
β : Type v
γ : Type w
δ : Type u_1
ι : Sort x
f f₁ f₂ : Filter α
g g₁ g₂ : Filter β
m : α → β
m' : β → γ
s✝ : Set α
t : Set β
inst✝ : NeBot f
c : β
s : Set β
h : ¬c ∈ s
⊢ s ∈ map (fun x => c) f ↔ s ∈ pure c
[PROOFSTEP]
simp [h]
[GOAL]
α : Type u
β : Type v
γ : Type w
δ : Type u_1
ι : Sort x
f f₁ f₂ : Filter α
g g₁ g₂ : Filter β
m✝ : α → β
m' : β → γ
s✝ : Set α
t : Set β
m : γ → β
n : β → α
s : Set γ
⊢ sᶜ ∈ comap m (comap n f) ↔ sᶜ ∈ comap (n ∘ m) f
[PROOFSTEP]
simp only [compl_mem_comap, image_image, (· ∘ ·)]
[GOAL]
α : Type u
β : Type v
γ : Type w
δ : Type u_1
ι : Sort x
f f₁ f₂ : Filter α
g g₁ g₂ : Filter β
m : α → β
m' : β → γ
s : Set α
t : Set β
φ : α → β
θ : α → γ
ψ : β → δ
ρ : γ → δ
H : ψ ∘ φ = ρ ∘ θ
F : Filter α
⊢ map ψ (map φ F) = map ρ (map θ F)
[PROOFSTEP]
rw [Filter.map_map, H, ← Filter.map_map]
[GOAL]
α : Type u
β : Type v
γ : Type w
δ : Type u_1
ι : Sort x
f f₁ f₂ : Filter α
g g₁ g₂ : Filter β
m : α → β
m' : β → γ
s : Set α
t : Set β
φ : α → β
θ : α → γ
ψ : β → δ
ρ : γ → δ
H : ψ ∘ φ = ρ ∘ θ
G : Filter δ
⊢ comap φ (comap ψ G) = comap θ (comap ρ G)
[PROOFSTEP]
rw [Filter.comap_comap, H, ← Filter.comap_comap]
[GOAL]
α : Type u
β : Type v
γ : Type w
δ : Type u_1
ι : Sort x
f f₁ f₂ : Filter α
g g₁ g₂ : Filter β
m : α → β
m' : β → γ
s : Set α
t : Set β
b : β
⊢ comap m (pure b) = 𝓟 (m ⁻¹' {b})
[PROOFSTEP]
rw [← principal_singleton, comap_principal]
[GOAL]
α : Type u
β : Type v
γ : Type w
δ : Type u_1
ι : Sort x
f f₁ f₂ : Filter α
g g₁ g₂ : Filter β
m : α → β
m' : β → γ
s : Set α
t : Set β
⊢ comap m g ≤ f ↔ g ≤ kernMap m f
[PROOFSTEP]
simp [Filter.le_def, mem_comap'', mem_kernMap, -mem_comap]
[GOAL]
α : Type u
β : Type v
γ : Type w
δ : Type u_1
ι : Sort x
f f₁ f₂ : Filter α
g g₁ g₂ : Filter β
m : α → β
m' : β → γ
s✝ : Set α
t : Set β
s : Set α
⊢ kernMap m (𝓟 s) = 𝓟 (kernImage m s)
[PROOFSTEP]
refine eq_of_forall_le_iff (fun g ↦ ?_)
[GOAL]
α : Type u
β : Type v
γ : Type w
δ : Type u_1
ι : Sort x
f f₁ f₂ : Filter α
g✝ g₁ g₂ : Filter β
m : α → β
m' : β → γ
s✝ : Set α
t : Set β
s : Set α
g : Filter β
⊢ g ≤ kernMap m (𝓟 s) ↔ g ≤ 𝓟 (kernImage m s)
[PROOFSTEP]
rw [← comap_le_iff_le_kernMap, le_principal_iff, le_principal_iff, mem_comap'']
[GOAL]
α : Type u
β : Type v
γ : Type w
δ : Type u_1
ι : Sort x
f✝ f₁ f₂ : Filter α
g g₁ g₂ : Filter β
m : α → β
m' : β → γ
s : Set α
t : Set β
f : α → β
⊢ map f ⊤ = 𝓟 (range f)
[PROOFSTEP]
rw [← principal_univ, map_principal, image_univ]
[GOAL]
α : Type u
β : Type v
γ : Type w
δ : Type u_1
ι : Sort x
f✝ f₁ f₂ : Filter α
g g₁ g₂ : Filter β
m : α → β
m' : β → γ
s : Set α
t : Set β
f : α → β
l : Filter α
⊢ l ≤ comap f ⊤
[PROOFSTEP]
rw [comap_top]
[GOAL]
α : Type u
β : Type v
γ : Type w
δ : Type u_1
ι : Sort x
f✝ f₁ f₂ : Filter α
g g₁ g₂ : Filter β
m : α → β
m' : β → γ
s : Set α
t : Set β
f : α → β
l : Filter α
⊢ l ≤ ⊤
[PROOFSTEP]
exact le_top
[GOAL]
α : Type u
β : Type v
γ : Type w
δ : Type u_1
ι : Sort x
f f₁ f₂ : Filter α
g g₁ g₂ : Filter β
m : α → β
m' : β → γ
s✝ : Set α
t : Set β
s : Set α
x✝ : s ∈ ⊥
⊢ m ⁻¹' ∅ ⊆ s
[PROOFSTEP]
simp only [empty_subset, preimage_empty]
[GOAL]
α : Type u
β : Type v
γ : Type w
δ : Type u_1
ι : Sort x
f f₁ f₂ : Filter α
g g₁ g₂ : Filter β
m : α → β
m' : β → γ
s : Set α
t : Set β
h : NeBot (comap m g)
⊢ NeBot g
[PROOFSTEP]
rw [neBot_iff] at *
[GOAL]
α : Type u
β : Type v
γ : Type w
δ : Type u_1
ι : Sort x
f f₁ f₂ : Filter α
g g₁ g₂ : Filter β
m : α → β
m' : β → γ
s : Set α
t : Set β
h : comap m g ≠ ⊥
⊢ g ≠ ⊥
[PROOFSTEP]
contrapose! h
[GOAL]
α : Type u
β : Type v
γ : Type w
δ : Type u_1
ι : Sort x
f f₁ f₂ : Filter α
g g₁ g₂ : Filter β
m : α → β
m' : β → γ
s : Set α
t : Set β
h : g = ⊥
⊢ comap m g = ⊥
[PROOFSTEP]
rw [h]
[GOAL]
α : Type u
β : Type v
γ : Type w
δ : Type u_1
ι : Sort x
f f₁ f₂ : Filter α
g g₁ g₂ : Filter β
m : α → β
m' : β → γ
s : Set α
t : Set β
h : g = ⊥
⊢ comap m ⊥ = ⊥
[PROOFSTEP]
exact comap_bot
[GOAL]
α : Type u
β : Type v
γ : Type w
δ : Type u_1
ι : Sort x
f f₁ f₂ : Filter α
g g₁ g₂ : Filter β
m : α → β
m' : β → γ
s : Set α
t : Set β
⊢ comap m (g ⊓ 𝓟 (range m)) = comap m g
[PROOFSTEP]
simpa only [le_principal_iff, comap_inf, comap_principal, preimage_range, principal_univ, inf_eq_left] using le_top
[GOAL]
α : Type u
β : Type v
γ : Type w
δ : Type u_1
ι : Sort x
f f₁ f₂ : Filter α
g g₁ g₂ : Filter β
m : α → β
m' : β → γ
s : Set α
t : Set β
h : Disjoint g₁ g₂
⊢ Disjoint (comap m g₁) (comap m g₂)
[PROOFSTEP]
simp only [disjoint_iff, ← comap_inf, h.eq_bot, comap_bot]
[GOAL]
α : Type u
β : Type v
γ : Type w
δ : Type u_1
ι : Sort x
f f₁ f₂ : Filter α
g g₁ g₂ : Filter β
m✝ : α → β
m' : β → γ
s✝ : Set α
t : Set β
s : Set (Filter β)
m : α → β
⊢ comap m (sSup s) = ⨆ (f : Filter β) (_ : f ∈ s), comap m f
[PROOFSTEP]
simp only [sSup_eq_iSup, comap_iSup, eq_self_iff_true]
[GOAL]
α : Type u
β : Type v
γ : Type w
δ : Type u_1
ι : Sort x
f f₁ f₂ : Filter α
g g₁ g₂ : Filter β
m : α → β
m' : β → γ
s : Set α
t : Set β
⊢ comap m (g₁ ⊔ g₂) = comap m g₁ ⊔ comap m g₂
[PROOFSTEP]
rw [sup_eq_iSup, comap_iSup, iSup_bool_eq, Bool.cond_true, Bool.cond_false]
[GOAL]
α : Type u
β : Type v
γ : Type w
δ : Type u_1
ι : Sort x
f✝ f₁ f₂ : Filter α
g g₁ g₂ : Filter β
m✝ : α → β
m' : β → γ
s : Set α
t : Set β
f : Filter β
m : α → β
⊢ map m (comap m f) = f ⊓ 𝓟 (range m)
[PROOFSTEP]
refine' le_antisymm (le_inf map_comap_le <| le_principal_iff.2 range_mem_map) _
[GOAL]
α : Type u
β : Type v
γ : Type w
δ : Type u_1
ι : Sort x
f✝ f₁ f₂ : Filter α
g g₁ g₂ : Filter β
m✝ : α → β
m' : β → γ
s : Set α
t : Set β
f : Filter β
m : α → β
⊢ f ⊓ 𝓟 (range m) ≤ map m (comap m f)
[PROOFSTEP]
rintro t' ⟨t, ht, sub⟩
[GOAL]
case intro.intro
α : Type u
β : Type v
γ : Type w
δ : Type u_1
ι : Sort x
f✝ f₁ f₂ : Filter α
g g₁ g₂ : Filter β
m✝ : α → β
m' : β → γ
s : Set α
t✝ : Set β
f : Filter β
m : α → β
t' t : Set β
ht : t ∈ f
sub : m ⁻¹' t ⊆ m ⁻¹' t'
⊢ t' ∈ f ⊓ 𝓟 (range m)
[PROOFSTEP]
refine' mem_inf_principal.2 (mem_of_superset ht _)
[GOAL]
case intro.intro
α : Type u
β : Type v
γ : Type w
δ : Type u_1
ι : Sort x
f✝ f₁ f₂ : Filter α
g g₁ g₂ : Filter β
m✝ : α → β
m' : β → γ
s : Set α
t✝ : Set β
f : Filter β
m : α → β
t' t : Set β
ht : t ∈ f
sub : m ⁻¹' t ⊆ m ⁻¹' t'
⊢ t ⊆ {x | x ∈ range m → x ∈ t'}
[PROOFSTEP]
rintro _ hxt ⟨x, rfl⟩
[GOAL]
case intro.intro.intro
α : Type u
β : Type v
γ : Type w
δ : Type u_1
ι : Sort x
f✝ f₁ f₂ : Filter α
g g₁ g₂ : Filter β
m✝ : α → β
m' : β → γ
s : Set α
t✝ : Set β
f : Filter β
m : α → β
t' t : Set β
ht : t ∈ f
sub : m ⁻¹' t ⊆ m ⁻¹' t'
x : α
hxt : m x ∈ t
⊢ m x ∈ t'
[PROOFSTEP]
exact sub hxt
[GOAL]
α : Type u
β : Type v
γ : Type w
δ : Type u_1
ι : Sort x
f✝ f₁ f₂ : Filter α
g g₁ g₂ : Filter β
m : α → β
m' : β → γ
s✝ : Set α
t : Set β
f : Filter β
s : Set β
⊢ map Subtype.val (comap Subtype.val f) = f ⊓ 𝓟 s
[PROOFSTEP]
rw [map_comap, Subtype.range_val]
[GOAL]
α : Type u
β : Type v
γ : Type w
δ : Type u_1
ι : Sort x
f✝ f₁ f₂ : Filter α
g g₁ g₂ : Filter β
m✝ : α → β
m' : β → γ
s : Set α
t : Set β
f : Filter β
m : α → β
hf : range m ∈ f
⊢ map m (comap m f) = f
[PROOFSTEP]
rw [map_comap, inf_eq_left.2 (le_principal_iff.2 hf)]
[GOAL]
α : Type u
β : Type v
γ : Type w
δ : Type u_1
ι : Sort x
f✝ f₁ f₂ : Filter α
g g₁ g₂ : Filter β
m : α → β
m' : β → γ
s : Set α
t : Set β
f : α → β
hf : Surjective f
l : Filter β
⊢ range f ∈ l
[PROOFSTEP]
simp only [hf.range_eq, univ_mem]
[GOAL]
α : Type u
β : Type v
γ : Type w
δ : Type u_1
ι : Sort x
f✝ f₁ f₂ : Filter α
g g₁ g₂ : Filter β
m : α → β
m' : β → γ
s✝ : Set α
t : Set β
s : Set α
f : Filter α
⊢ map Subtype.val (comap Subtype.val f) = f ⊓ 𝓟 s
[PROOFSTEP]
rw [map_comap, Subtype.range_coe]
[GOAL]
α : Type u
β : Type v
γ : Type w
δ : Type u_1
ι : Sort x
f✝ f₁ f₂ : Filter α
g g₁ g₂ : Filter β
m : α → β
m' : β → γ
s : Set α
t : Set β
f : Filter α
c : β → α
h : range c ∈ f
W : Set β
W_in : W ∈ comap c f
⊢ c '' W ∈ f
[PROOFSTEP]
rw [← map_comap_of_mem h]
[GOAL]
α : Type u
β : Type v
γ : Type w
δ : Type u_1
ι : Sort x
f✝ f₁ f₂ : Filter α
g g₁ g₂ : Filter β
m : α → β
m' : β → γ
s : Set α
t : Set β
f : Filter α
c : β → α
h : range c ∈ f
W : Set β
W_in : W ∈ comap c f
⊢ c '' W ∈ map c (comap c f)
[PROOFSTEP]
exact image_mem_map W_in
[GOAL]
α : Type u
β : Type v
γ : Type w
δ : Type u_1
ι : Sort x
f✝ f₁ f₂ : Filter α
g g₁ g₂ : Filter β
m : α → β
m' : β → γ
s : Set α
t : Set β
f : Filter α
U : Set α
h : U ∈ f
W : Set ↑U
W_in : W ∈ comap Subtype.val f
⊢ range Subtype.val ∈ f
[PROOFSTEP]
simp [h]
[GOAL]
α : Type u
β : Type v
γ : Type w
δ : Type u_1
ι : Sort x
f✝ f₁ f₂ : Filter α
g g₁ g₂ : Filter β
m✝ : α → β
m' : β → γ
s✝ : Set α
t : Set β
f : Filter α
m : α → β
h : Injective m
s : Set α
hs : s ∈ f
⊢ m ⁻¹' (m '' s) ⊆ s
[PROOFSTEP]
simp only [preimage_image_eq s h, Subset.rfl]
[GOAL]
α : Type u
β : Type v
γ : Type w
δ : Type u_1
ι : Sort x
f✝ f₁ f₂ : Filter α
g g₁ g₂ : Filter β
m✝ : α → β
m' : β → γ
s : Set α
t : Set β
f : Filter β
m : α → β
inj : Injective m
large : range m ∈ f
S : Set α
⊢ S ∈ comap m f ↔ m '' S ∈ f
[PROOFSTEP]
rw [← image_mem_map_iff inj, map_comap_of_mem large]
[GOAL]
α : Type u
β : Type v
γ : Type w
δ : Type u_1
ι : Sort x
f✝ f₁ f₂ : Filter α
g✝ g₁ g₂ : Filter β
m✝ : α → β
m' : β → γ
s : Set α
t : Set β
f g : Filter α
m : α → β
hm : Injective m
⊢ map m f ≤ map m g ↔ f ≤ g
[PROOFSTEP]
rw [map_le_iff_le_comap, comap_map hm]
[GOAL]
α : Type u
β : Type v
γ : Type w
δ : Type u_1
ι : Sort x
f✝ f₁ f₂ : Filter α
g✝ g₁ g₂ : Filter β
m✝ : α → β
m' : β → γ
s✝ : Set α
t : Set β
f g : Filter α
m : α → β
s : Set α
hsf : s ∈ f
hsg : s ∈ g
hm : InjOn m s
⊢ map m f = map m g ↔ f = g
[PROOFSTEP]
simp only [le_antisymm_iff, map_le_map_iff_of_injOn hsf hsg hm, map_le_map_iff_of_injOn hsg hsf hm]
[GOAL]
α : Type u
β : Type v
γ : Type w
δ : Type u_1
ι : Sort x
f✝ f₁ f₂ : Filter α
g g₁ g₂ : Filter β
m✝ : α → β
m' : β → γ
s : Set α
t : Set β
f : Filter β
m : α → β
⊢ NeBot (comap m f) ↔ ∀ (t : Set β), t ∈ f → ∃ a, m a ∈ t
[PROOFSTEP]
simp only [← forall_mem_nonempty_iff_neBot, mem_comap, forall_exists_index, and_imp]
[GOAL]
α : Type u
β : Type v
γ : Type w
δ : Type u_1
ι : Sort x
f✝ f₁ f₂ : Filter α
g g₁ g₂ : Filter β
m✝ : α → β
m' : β → γ
s : Set α
t : Set β
f : Filter β
m : α → β
⊢ (∀ (s : Set α) (x : Set β), x ∈ f → m ⁻¹' x ⊆ s → Set.Nonempty s) ↔ ∀ (t : Set β), t ∈ f → ∃ a, m a ∈ t
[PROOFSTEP]
exact ⟨fun h t t_in => h (m ⁻¹' t) t t_in Subset.rfl, fun h s t ht hst => (h t ht).imp hst⟩
[GOAL]
α : Type u
β : Type v
γ : Type w
δ : Type u_1
ι : Sort x
f✝ f₁ f₂ : Filter α
g g₁ g₂ : Filter β
m✝ : α → β
m' : β → γ
s : Set α
t : Set β
f : Filter β
m : α → β
⊢ NeBot (comap m f) ↔ ∃ᶠ (y : β) in f, y ∈ range m
[PROOFSTEP]
simp only [comap_neBot_iff, frequently_iff, mem_range, @and_comm (_ ∈ _), exists_exists_eq_and]
[GOAL]
α : Type u
β : Type v
γ : Type w
δ : Type u_1
ι : Sort x
f✝ f₁ f₂ : Filter α
g g₁ g₂ : Filter β
m✝ : α → β
m' : β → γ
s : Set α
t : Set β
f : Filter β
m : α → β
hm : Surjective m
⊢ comap m f = ⊥ ↔ f = ⊥
[PROOFSTEP]
rw [comap_eq_bot_iff_compl_range, hm.range_eq, compl_univ, empty_mem_iff_bot]
[GOAL]
α : Type u
β : Type v
γ : Type w
δ : Type u_1
ι : Sort x
f f₁ f₂ : Filter α
g g₁ g₂ : Filter β
m : α → β
m' : β → γ
s : Set α
t : Set β
h : Surjective m
⊢ Disjoint (comap m g₁) (comap m g₂) ↔ Disjoint g₁ g₂
[PROOFSTEP]
rw [disjoint_iff, disjoint_iff, ← comap_inf, comap_surjective_eq_bot h]
[GOAL]
α : Type u
β : Type v
γ : Type w
δ : Type u_1
ι : Sort x
f✝ f₁ f₂ : Filter α
g g₁ g₂ : Filter β
m : α → β
m' : β → γ
s : Set α
t : Set β
f : Filter α
⊢ NeBot (comap Prod.fst f) ↔ NeBot f ∧ Nonempty β
[PROOFSTEP]
cases isEmpty_or_nonempty β
[GOAL]
case inl
α : Type u
β : Type v
γ : Type w
δ : Type u_1
ι : Sort x
f✝ f₁ f₂ : Filter α
g g₁ g₂ : Filter β
m : α → β
m' : β → γ
s : Set α
t : Set β
f : Filter α
h✝ : IsEmpty β
⊢ NeBot (comap Prod.fst f) ↔ NeBot f ∧ Nonempty β
[PROOFSTEP]
rw [filter_eq_bot_of_isEmpty (f.comap _), ← not_iff_not]
[GOAL]
case inl
α : Type u
β : Type v
γ : Type w
δ : Type u_1
ι : Sort x
f✝ f₁ f₂ : Filter α
g g₁ g₂ : Filter β
m : α → β
m' : β → γ
s : Set α
t : Set β
f : Filter α
h✝ : IsEmpty β
⊢ ¬NeBot ⊥ ↔ ¬(NeBot f ∧ Nonempty β)
[PROOFSTEP]
simp [*]
[GOAL]
case inr
α : Type u
β : Type v
γ : Type w
δ : Type u_1
ι : Sort x
f✝ f₁ f₂ : Filter α
g g₁ g₂ : Filter β
m : α → β
m' : β → γ
s : Set α
t : Set β
f : Filter α
h✝ : Nonempty β
⊢ NeBot (comap Prod.fst f) ↔ NeBot f ∧ Nonempty β
[PROOFSTEP]
simp [comap_neBot_iff_frequently, *]
[GOAL]
α : Type u
β : Type v
γ : Type w
δ : Type u_1
ι : Sort x
f✝ f₁ f₂ : Filter α
g g₁ g₂ : Filter β
m : α → β
m' : β → γ
s : Set α
t : Set β
f : Filter β
⊢ NeBot (comap Prod.snd f) ↔ Nonempty α ∧ NeBot f
[PROOFSTEP]
cases' isEmpty_or_nonempty α with hα hα
[GOAL]
case inl
α : Type u
β : Type v
γ : Type w
δ : Type u_1
ι : Sort x
f✝ f₁ f₂ : Filter α
g g₁ g₂ : Filter β
m : α → β
m' : β → γ
s : Set α
t : Set β
f : Filter β
hα : IsEmpty α
⊢ NeBot (comap Prod.snd f) ↔ Nonempty α ∧ NeBot f
[PROOFSTEP]
rw [filter_eq_bot_of_isEmpty (f.comap _), ← not_iff_not]
[GOAL]
case inl
α : Type u
β : Type v
γ : Type w
δ : Type u_1
ι : Sort x
f✝ f₁ f₂ : Filter α
g g₁ g₂ : Filter β
m : α → β
m' : β → γ
s : Set α
t : Set β
f : Filter β
hα : IsEmpty α
⊢ ¬NeBot ⊥ ↔ ¬(Nonempty α ∧ NeBot f)
[PROOFSTEP]
simp
[GOAL]
case inr
α : Type u
β : Type v
γ : Type w
δ : Type u_1
ι : Sort x
f✝ f₁ f₂ : Filter α
g g₁ g₂ : Filter β
m : α → β
m' : β → γ
s : Set α
t : Set β
f : Filter β
hα : Nonempty α
⊢ NeBot (comap Prod.snd f) ↔ Nonempty α ∧ NeBot f
[PROOFSTEP]
simp [comap_neBot_iff_frequently, hα]
[GOAL]
α✝ : Type u
β : Type v
γ : Type w
δ : Type u_1
ι✝ : Sort x
f✝ f₁ f₂ : Filter α✝
g g₁ g₂ : Filter β
m : α✝ → β
m' : β → γ
s : Set α✝
t : Set β
ι : Type u_2
α : ι → Type u_3
i : ι
f : Filter (α i)
⊢ NeBot (comap (eval i) f) ↔ (∀ (j : ι), Nonempty (α j)) ∧ NeBot f
[PROOFSTEP]
cases' isEmpty_or_nonempty (∀ j, α j) with H H
[GOAL]
case inl
α✝ : Type u
β : Type v
γ : Type w
δ : Type u_1
ι✝ : Sort x
f✝ f₁ f₂ : Filter α✝
g g₁ g₂ : Filter β
m : α✝ → β
m' : β → γ
s : Set α✝
t : Set β
ι : Type u_2
α : ι → Type u_3
i : ι
f : Filter (α i)
H : IsEmpty ((j : ι) → α j)
⊢ NeBot (comap (eval i) f) ↔ (∀ (j : ι), Nonempty (α j)) ∧ NeBot f
[PROOFSTEP]
rw [filter_eq_bot_of_isEmpty (f.comap _), ← not_iff_not]
[GOAL]
case inl
α✝ : Type u
β : Type v
γ : Type w
δ : Type u_1
ι✝ : Sort x
f✝ f₁ f₂ : Filter α✝
g g₁ g₂ : Filter β
m : α✝ → β
m' : β → γ
s : Set α✝
t : Set β
ι : Type u_2
α : ι → Type u_3
i : ι
f : Filter (α i)
H : IsEmpty ((j : ι) → α j)
⊢ ¬NeBot ⊥ ↔ ¬((∀ (j : ι), Nonempty (α j)) ∧ NeBot f)
[PROOFSTEP]
simp [← Classical.nonempty_pi]
[GOAL]
case inr
α✝ : Type u
β : Type v
γ : Type w
δ : Type u_1
ι✝ : Sort x
f✝ f₁ f₂ : Filter α✝
g g₁ g₂ : Filter β
m : α✝ → β
m' : β → γ
s : Set α✝
t : Set β
ι : Type u_2
α : ι → Type u_3
i : ι
f : Filter (α i)
H : Nonempty ((j : ι) → α j)
⊢ NeBot (comap (eval i) f) ↔ (∀ (j : ι), Nonempty (α j)) ∧ NeBot f
[PROOFSTEP]
have : ∀ j, Nonempty (α j) := Classical.nonempty_pi.1 H
[GOAL]
case inr
α✝ : Type u
β : Type v
γ : Type w
δ : Type u_1
ι✝ : Sort x
f✝ f₁ f₂ : Filter α✝
g g₁ g₂ : Filter β
m : α✝ → β
m' : β → γ
s : Set α✝
t : Set β
ι : Type u_2
α : ι → Type u_3
i : ι
f : Filter (α i)
H : Nonempty ((j : ι) → α j)
this : ∀ (j : ι), Nonempty (α j)
⊢ NeBot (comap (eval i) f) ↔ (∀ (j : ι), Nonempty (α j)) ∧ NeBot f
[PROOFSTEP]
simp [comap_neBot_iff_frequently, *]
[GOAL]
α✝ : Type u
β : Type v
γ : Type w
δ : Type u_1
ι✝ : Sort x
f✝ f₁ f₂ : Filter α✝
g g₁ g₂ : Filter β
m : α✝ → β
m' : β → γ
s : Set α✝
t : Set β
ι : Type u_2
α : ι → Type u_3
inst✝ : ∀ (j : ι), Nonempty (α j)
i : ι
f : Filter (α i)
⊢ NeBot (comap (eval i) f) ↔ NeBot f
[PROOFSTEP]
simp [comap_eval_neBot_iff', *]
[GOAL]
α : Type u
β : Type v
γ : Type w
δ : Type u_1
ι : Sort x
f✝ f₁ f₂ : Filter α
g g₁ g₂ : Filter β
m✝ : α → β
m' : β → γ
s✝ : Set α
t : Set β
f : Filter β
m : α → β
hf : NeBot f
s : Set α
hs : m '' s ∈ f
⊢ NeBot (comap m f ⊓ 𝓟 s)
[PROOFSTEP]
refine' ⟨compl_compl s ▸ mt mem_of_eq_bot _⟩
[GOAL]
α : Type u
β : Type v
γ : Type w
δ : Type u_1
ι : Sort x
f✝ f₁ f₂ : Filter α
g g₁ g₂ : Filter β
m✝ : α → β
m' : β → γ
s✝ : Set α
t : Set β
f : Filter β
m : α → β
hf : NeBot f
s : Set α
hs : m '' s ∈ f
⊢ ¬sᶜ ∈ comap m f
[PROOFSTEP]
rintro ⟨t, ht, hts⟩
[GOAL]
case intro.intro
α : Type u
β : Type v
γ : Type w
δ : Type u_1
ι : Sort x
f✝ f₁ f₂ : Filter α
g g₁ g₂ : Filter β
m✝ : α → β
m' : β → γ
s✝ : Set α
t✝ : Set β
f : Filter β
m : α → β
hf : NeBot f
s : Set α
hs : m '' s ∈ f
t : Set β
ht : t ∈ f
hts : m ⁻¹' t ⊆ sᶜ
⊢ False
[PROOFSTEP]
rcases hf.nonempty_of_mem (inter_mem hs ht) with ⟨_, ⟨x, hxs, rfl⟩, hxt⟩
[GOAL]
case intro.intro.intro.intro.intro.intro
α : Type u
β : Type v
γ : Type w
δ : Type u_1
ι : Sort x
f✝ f₁ f₂ : Filter α
g g₁ g₂ : Filter β
m✝ : α → β
m' : β → γ
s✝ : Set α
t✝ : Set β
f : Filter β
m : α → β
hf : NeBot f
s : Set α
hs : m '' s ∈ f
t : Set β
ht : t ∈ f
hts : m ⁻¹' t ⊆ sᶜ
x : α
hxs : x ∈ s
hxt : m x ∈ t
⊢ False
[PROOFSTEP]
exact absurd hxs (hts hxt)
[GOAL]
α : Type u
β : Type v
γ : Type w
δ : Type u_1
ι : Sort x
f f₁ f₂ : Filter α
g g₁ g₂ : Filter β
m : α → β
m' : β → γ
s : Set α
t : Set β
⊢ map m f = ⊥ → f = ⊥
[PROOFSTEP]
rw [← empty_mem_iff_bot, ← empty_mem_iff_bot]
[GOAL]
α : Type u
β : Type v
γ : Type w
δ : Type u_1
ι : Sort x
f f₁ f₂ : Filter α
g g₁ g₂ : Filter β
m : α → β
m' : β → γ
s : Set α
t : Set β
⊢ ∅ ∈ map m f → ∅ ∈ f
[PROOFSTEP]
exact id
[GOAL]
α : Type u
β : Type v
γ : Type w
δ : Type u_1
ι : Sort x
f f₁ f₂ : Filter α
g g₁ g₂ : Filter β
m : α → β
m' : β → γ
s : Set α
t : Set β
h : f = ⊥
⊢ map m f = ⊥
[PROOFSTEP]
simp only [h, map_bot]
[GOAL]
α : Type u
β : Type v
γ : Type w
δ : Type u_1
ι : Sort x
f✝ f₁ f₂ : Filter α
g g₁ g₂ : Filter β
m : α → β
m' : β → γ
s : Set α
t : Set β
f : α → β
F : Filter α
⊢ NeBot (map f F) ↔ NeBot F
[PROOFSTEP]
simp only [neBot_iff, Ne, map_eq_bot_iff]
[GOAL]
α : Type u
β : Type v
γ : Type w
δ : Type u_1
ι : Sort x
f✝ f₁ f₂ : Filter α
g g₁ g₂ : Filter β
m : α → β
m' : β → γ
s : Set α
t : Set β
f : α → β
F : Filter β
⊢ ⋂₀ (comap f F).sets = ⋂ (U : Set β) (_ : U ∈ F), f ⁻¹' U
[PROOFSTEP]
ext x
[GOAL]
case h
α : Type u
β : Type v
γ : Type w
δ : Type u_1
ι : Sort x
f✝ f₁ f₂ : Filter α
g g₁ g₂ : Filter β
m : α → β
m' : β → γ
s : Set α
t : Set β
f : α → β
F : Filter β
x : α
⊢ x ∈ ⋂₀ (comap f F).sets ↔ x ∈ ⋂ (U : Set β) (_ : U ∈ F), f ⁻¹' U
[PROOFSTEP]
suffices (∀ (A : Set α) (B : Set β), B ∈ F → f ⁻¹' B ⊆ A → x ∈ A) ↔ ∀ B : Set β, B ∈ F → f x ∈ B by
  simp only [mem_sInter, mem_iInter, Filter.mem_sets, mem_comap, this, and_imp, exists_prop, mem_preimage, exists_imp]
[GOAL]
α : Type u
β : Type v
γ : Type w
δ : Type u_1
ι : Sort x
f✝ f₁ f₂ : Filter α
g g₁ g₂ : Filter β
m : α → β
m' : β → γ
s : Set α
t : Set β
f : α → β
F : Filter β
x : α
this : (∀ (A : Set α) (B : Set β), B ∈ F → f ⁻¹' B ⊆ A → x ∈ A) ↔ ∀ (B : Set β), B ∈ F → f x ∈ B
⊢ x ∈ ⋂₀ (comap f F).sets ↔ x ∈ ⋂ (U : Set β) (_ : U ∈ F), f ⁻¹' U
[PROOFSTEP]
simp only [mem_sInter, mem_iInter, Filter.mem_sets, mem_comap, this, and_imp, exists_prop, mem_preimage, exists_imp]
[GOAL]
case h
α : Type u
β : Type v
γ : Type w
δ : Type u_1
ι : Sort x
f✝ f₁ f₂ : Filter α
g g₁ g₂ : Filter β
m : α → β
m' : β → γ
s : Set α
t : Set β
f : α → β
F : Filter β
x : α
⊢ (∀ (A : Set α) (B : Set β), B ∈ F → f ⁻¹' B ⊆ A → x ∈ A) ↔ ∀ (B : Set β), B ∈ F → f x ∈ B
[PROOFSTEP]
constructor
[GOAL]
case h.mp
α : Type u
β : Type v
γ : Type w
δ : Type u_1
ι : Sort x
f✝ f₁ f₂ : Filter α
g g₁ g₂ : Filter β
m : α → β
m' : β → γ
s : Set α
t : Set β
f : α → β
F : Filter β
x : α
⊢ (∀ (A : Set α) (B : Set β), B ∈ F → f ⁻¹' B ⊆ A → x ∈ A) → ∀ (B : Set β), B ∈ F → f x ∈ B
[PROOFSTEP]
intro h U U_in
[GOAL]
case h.mp
α : Type u
β : Type v
γ : Type w
δ : Type u_1
ι : Sort x
f✝ f₁ f₂ : Filter α
g g₁ g₂ : Filter β
m : α → β
m' : β → γ
s : Set α
t : Set β
f : α → β
F : Filter β
x : α
h : ∀ (A : Set α) (B : Set β), B ∈ F → f ⁻¹' B ⊆ A → x ∈ A
U : Set β
U_in : U ∈ F
⊢ f x ∈ U
[PROOFSTEP]
simpa only [Subset.rfl, forall_prop_of_true, mem_preimage] using h (f ⁻¹' U) U U_in
[GOAL]
case h.mpr
α : Type u
β : Type v
γ : Type w
δ : Type u_1
ι : Sort x
f✝ f₁ f₂ : Filter α
g g₁ g₂ : Filter β
m : α → β
m' : β → γ
s : Set α
t : Set β
f : α → β
F : Filter β
x : α
⊢ (∀ (B : Set β), B ∈ F → f x ∈ B) → ∀ (A : Set α) (B : Set β), B ∈ F → f ⁻¹' B ⊆ A → x ∈ A
[PROOFSTEP]
intro h V U U_in f_U_V
[GOAL]
case h.mpr
α : Type u
β : Type v
γ : Type w
δ : Type u_1
ι : Sort x
f✝ f₁ f₂ : Filter α
g g₁ g₂ : Filter β
m : α → β
m' : β → γ
s : Set α
t : Set β
f : α → β
F : Filter β
x : α
h : ∀ (B : Set β), B ∈ F → f x ∈ B
V : Set α
U : Set β
U_in : U ∈ F
f_U_V : f ⁻¹' U ⊆ V
⊢ x ∈ V
[PROOFSTEP]
exact f_U_V (h U U_in)
[GOAL]
α : Type u
β : Type v
γ : Type w
δ : Type u_1
ι : Sort x
f : ι → Filter α
m : α → β
hf : Directed (fun x x_1 => x ≥ x_1) f
inst✝ : Nonempty ι
s : Set β
hs : m ⁻¹' s ∈ iInf f
i : ι
hi : m ⁻¹' s ∈ f i
⊢ map m (f i) ≤ 𝓟 s
[PROOFSTEP]
simp only [le_principal_iff, mem_map]
[GOAL]
α : Type u
β : Type v
γ : Type w
δ : Type u_1
ι : Sort x
f : ι → Filter α
m : α → β
hf : Directed (fun x x_1 => x ≥ x_1) f
inst✝ : Nonempty ι
s : Set β
hs : m ⁻¹' s ∈ iInf f
i : ι
hi : m ⁻¹' s ∈ f i
⊢ m ⁻¹' s ∈ f i
[PROOFSTEP]
assumption
[GOAL]
α : Type u
β : Type v
γ : Type w
δ : Type u_1
ι✝ : Sort x
ι : Type w
f : ι → Filter α
m : α → β
p : ι → Prop
h : DirectedOn (f ⁻¹'o fun x x_1 => x ≥ x_1) {x | p x}
ne : ∃ i, p i
⊢ map m (⨅ (i : ι) (_ : p i), f i) = ⨅ (i : ι) (_ : p i), map m (f i)
[PROOFSTEP]
haveI := nonempty_subtype.2 ne
[GOAL]
α : Type u
β : Type v
γ : Type w
δ : Type u_1
ι✝ : Sort x
ι : Type w
f : ι → Filter α
m : α → β
p : ι → Prop
h : DirectedOn (f ⁻¹'o fun x x_1 => x ≥ x_1) {x | p x}
ne : ∃ i, p i
this : Nonempty { a // p a }
⊢ map m (⨅ (i : ι) (_ : p i), f i) = ⨅ (i : ι) (_ : p i), map m (f i)
[PROOFSTEP]
simp only [iInf_subtype']
[GOAL]
α : Type u
β : Type v
γ : Type w
δ : Type u_1
ι✝ : Sort x
ι : Type w
f : ι → Filter α
m : α → β
p : ι → Prop
h : DirectedOn (f ⁻¹'o fun x x_1 => x ≥ x_1) {x | p x}
ne : ∃ i, p i
this : Nonempty { a // p a }
⊢ map m (⨅ (x : { i // p i }), f ↑x) = ⨅ (x : { i // p i }), map m (f ↑x)
[PROOFSTEP]
exact map_iInf_eq h.directed_val
[GOAL]
α : Type u
β : Type v
γ : Type w
δ : Type u_1
ι : Sort x
f g : Filter α
m : α → β
h : Injective m
⊢ map m (f ⊓ g) = map m f ⊓ map m g
[PROOFSTEP]
refine' map_inf_le.antisymm _
[GOAL]
α : Type u
β : Type v
γ : Type w
δ : Type u_1
ι : Sort x
f g : Filter α
m : α → β
h : Injective m
⊢ map m f ⊓ map m g ≤ map m (f ⊓ g)
[PROOFSTEP]
rintro t ⟨s₁, hs₁, s₂, hs₂, ht : m ⁻¹' t = s₁ ∩ s₂⟩
[GOAL]
case intro.intro.intro.intro
α : Type u
β : Type v
γ : Type w
δ : Type u_1
ι : Sort x
f g : Filter α
m : α → β
h : Injective m
t : Set β
s₁ : Set α
hs₁ : s₁ ∈ f
s₂ : Set α
hs₂ : s₂ ∈ g
ht : m ⁻¹' t = s₁ ∩ s₂
⊢ t ∈ map m f ⊓ map m g
[PROOFSTEP]
refine' mem_inf_of_inter (image_mem_map hs₁) (image_mem_map hs₂) _
[GOAL]
case intro.intro.intro.intro
α : Type u
β : Type v
γ : Type w
δ : Type u_1
ι : Sort x
f g : Filter α
m : α → β
h : Injective m
t : Set β
s₁ : Set α
hs₁ : s₁ ∈ f
s₂ : Set α
hs₂ : s₂ ∈ g
ht : m ⁻¹' t = s₁ ∩ s₂
⊢ m '' s₁ ∩ m '' s₂ ⊆ t
[PROOFSTEP]
rw [← image_inter h, image_subset_iff, ht]
[GOAL]
α : Type u
β : Type v
γ : Type w
δ : Type u_1
ι : Sort x
f g : Filter α
m : α → β
t : Set α
htf : t ∈ f
htg : t ∈ g
h : InjOn m t
⊢ map m (f ⊓ g) = map m f ⊓ map m g
[PROOFSTEP]
lift f to Filter t using htf
[GOAL]
case intro
α : Type u
β : Type v
γ : Type w
δ : Type u_1
ι : Sort x
g : Filter α
m : α → β
t : Set α
htg : t ∈ g
h : InjOn m t
f : Filter ↑t
⊢ map m (map Subtype.val f ⊓ g) = map m (map Subtype.val f) ⊓ map m g
[PROOFSTEP]
lift g to Filter t using htg
[GOAL]
case intro.intro
α : Type u
β : Type v
γ : Type w
δ : Type u_1
ι : Sort x
m : α → β
t : Set α
h : InjOn m t
f g : Filter ↑t
⊢ map m (map Subtype.val f ⊓ map Subtype.val g) = map m (map Subtype.val f) ⊓ map m (map Subtype.val g)
[PROOFSTEP]
replace h : Injective (m ∘ ((↑) : t → α)) := h.injective
[GOAL]
case intro.intro
α : Type u
β : Type v
γ : Type w
δ : Type u_1
ι : Sort x
m : α → β
t : Set α
f g : Filter ↑t
h : Injective (m ∘ Subtype.val)
⊢ map m (map Subtype.val f ⊓ map Subtype.val g) = map m (map Subtype.val f) ⊓ map m (map Subtype.val g)
[PROOFSTEP]
simp only [map_map, ← map_inf Subtype.coe_injective, map_inf h]
[GOAL]
α : Type u
β : Type v
γ : Type w
δ : Type u_1
ι : Sort x
m : α → β
hm : Injective m
f₁ f₂ : Filter α
⊢ Disjoint (map m f₁) (map m f₂) ↔ Disjoint f₁ f₂
[PROOFSTEP]
simp only [disjoint_iff, ← map_inf hm, map_eq_bot_iff]
[GOAL]
α : Type u
β : Type v
γ : Type w
δ : Type u_1
ι : Sort x
e : α ≃ β
f : Filter β
⊢ map (↑e) (map (↑e.symm) f) = map (↑e) (comap (↑e) f)
[PROOFSTEP]
rw [map_map, e.self_comp_symm, map_id, map_comap_of_surjective e.surjective]
[GOAL]
α : Type u
β : Type v
γ : Type w
δ : Type u_1
ι : Sort x
f : α → β
F : Filter α
G : Filter β
⊢ map f (F ⊓ comap f G) = map f F ⊓ G
[PROOFSTEP]
apply le_antisymm
[GOAL]
case a
α : Type u
β : Type v
γ : Type w
δ : Type u_1
ι : Sort x
f : α → β
F : Filter α
G : Filter β
⊢ map f (F ⊓ comap f G) ≤ map f F ⊓ G
[PROOFSTEP]
calc
  map f (F ⊓ comap f G) ≤ map f F ⊓ (map f <| comap f G) := map_inf_le
  _ ≤ map f F ⊓ G := inf_le_inf_left (map f F) map_comap_le
[GOAL]
case a
α : Type u
β : Type v
γ : Type w
δ : Type u_1
ι : Sort x
f : α → β
F : Filter α
G : Filter β
⊢ map f F ⊓ G ≤ map f (F ⊓ comap f G)
[PROOFSTEP]
rintro U ⟨V, V_in, W, ⟨Z, Z_in, hZ⟩, h⟩
[GOAL]
case a.intro.intro.intro.intro.intro.intro
α : Type u
β : Type v
γ : Type w
δ : Type u_1
ι : Sort x
f : α → β
F : Filter α
G : Filter β
U : Set β
V : Set α
V_in : V ∈ F
W : Set α
h : f ⁻¹' U = V ∩ W
Z : Set β
Z_in : Z ∈ G
hZ : f ⁻¹' Z ⊆ W
⊢ U ∈ map f F ⊓ G
[PROOFSTEP]
apply mem_inf_of_inter (image_mem_map V_in) Z_in
[GOAL]
case a.intro.intro.intro.intro.intro.intro
α : Type u
β : Type v
γ : Type w
δ : Type u_1
ι : Sort x
f : α → β
F : Filter α
G : Filter β
U : Set β
V : Set α
V_in : V ∈ F
W : Set α
h : f ⁻¹' U = V ∩ W
Z : Set β
Z_in : Z ∈ G
hZ : f ⁻¹' Z ⊆ W
⊢ f '' V ∩ Z ⊆ U
[PROOFSTEP]
calc
  f '' V ∩ Z = f '' (V ∩ f ⁻¹' Z) := by rw [image_inter_preimage]
  _ ⊆ f '' (V ∩ W) := (image_subset _ (inter_subset_inter_right _ ‹_›))
  _ = f '' (f ⁻¹' U) := by rw [h]
  _ ⊆ U := image_preimage_subset f U
[GOAL]
α : Type u
β : Type v
γ : Type w
δ : Type u_1
ι : Sort x
f : α → β
F : Filter α
G : Filter β
U : Set β
V : Set α
V_in : V ∈ F
W : Set α
h : f ⁻¹' U = V ∩ W
Z : Set β
Z_in : Z ∈ G
hZ : f ⁻¹' Z ⊆ W
⊢ f '' V ∩ Z = f '' (V ∩ f ⁻¹' Z)
[PROOFSTEP]
rw [image_inter_preimage]
[GOAL]
α : Type u
β : Type v
γ : Type w
δ : Type u_1
ι : Sort x
f : α → β
F : Filter α
G : Filter β
U : Set β
V : Set α
V_in : V ∈ F
W : Set α
h : f ⁻¹' U = V ∩ W
Z : Set β
Z_in : Z ∈ G
hZ : f ⁻¹' Z ⊆ W
⊢ f '' (V ∩ W) = f '' (f ⁻¹' U)
[PROOFSTEP]
rw [h]
[GOAL]
α : Type u
β : Type v
γ : Type w
δ : Type u_1
ι : Sort x
f : α → β
F : Filter α
G : Filter β
⊢ map f (comap f G ⊓ F) = G ⊓ map f F
[PROOFSTEP]
simp only [Filter.push_pull, inf_comm]
[GOAL]
α : Type u
β : Type v
γ : Type w
δ : Type u_1
ι : Sort x
s : Set α
⊢ 𝓟 s = map Subtype.val ⊤
[PROOFSTEP]
simp
[GOAL]
α : Type u
β : Type v
γ : Type w
δ : Type u_1
ι : Sort x
F : Filter α
s : Set α
⊢ F ⊓ 𝓟 s = ⊥ ↔ comap Subtype.val F = ⊥
[PROOFSTEP]
rw [principal_eq_map_coe_top s, ← Filter.push_pull', inf_top_eq, map_eq_bot_iff]
[GOAL]
α : Type u
β : Type v
γ : Type w
δ : Type u_1
ι : Sort x
f : Filter α
a : α
⊢ f ≤ pure a ↔ {a} ∈ f
[PROOFSTEP]
rw [← principal_singleton, le_principal_iff]
[GOAL]
α : Type u
β : Type v
γ : Type w
δ : Type u_1
ι : Sort x
f : Filter (α → β)
g : Filter α
s : Set β
⊢ s ∈ seq f g ↔ ∃ u, u ∈ f ∧ ∃ t, t ∈ g ∧ Set.seq u t ⊆ s
[PROOFSTEP]
simp only [mem_seq_def, seq_subset, exists_prop, iff_self_iff]
[GOAL]
α : Type u
β : Type v
γ : Type w
δ : Type u_1
ι : Sort x
g : α → β
f : Filter α
⊢ seq (pure g) f = map g f
[PROOFSTEP]
refine' le_antisymm (le_map fun s hs => _) (le_seq fun s hs t ht => _)
[GOAL]
case refine'_1
α : Type u
β : Type v
γ : Type w
δ : Type u_1
ι : Sort x
g : α → β
f : Filter α
s : Set α
hs : s ∈ f
⊢ g '' s ∈ seq (pure g) f
[PROOFSTEP]
rw [← singleton_seq]
[GOAL]
case refine'_1
α : Type u
β : Type v
γ : Type w
δ : Type u_1
ι : Sort x
g : α → β
f : Filter α
s : Set α
hs : s ∈ f
⊢ Set.seq {g} s ∈ seq (pure g) f
[PROOFSTEP]
apply seq_mem_seq _ hs
[GOAL]
α : Type u
β : Type v
γ : Type w
δ : Type u_1
ι : Sort x
g : α → β
f : Filter α
s : Set α
hs : s ∈ f
⊢ {g} ∈ pure g
[PROOFSTEP]
exact singleton_mem_pure
[GOAL]
case refine'_2
α : Type u
β : Type v
γ : Type w
δ : Type u_1
ι : Sort x
g : α → β
f : Filter α
s : Set (α → β)
hs : s ∈ pure g
t : Set α
ht : t ∈ f
⊢ Set.seq s t ∈ map g f
[PROOFSTEP]
refine' sets_of_superset (map g f) (image_mem_map ht) _
[GOAL]
case refine'_2
α : Type u
β : Type v
γ : Type w
δ : Type u_1
ι : Sort x
g : α → β
f : Filter α
s : Set (α → β)
hs : s ∈ pure g
t : Set α
ht : t ∈ f
⊢ g '' t ⊆ Set.seq s t
[PROOFSTEP]
rintro b ⟨a, ha, rfl⟩
[GOAL]
case refine'_2.intro.intro
α : Type u
β : Type v
γ : Type w
δ : Type u_1
ι : Sort x
g : α → β
f : Filter α
s : Set (α → β)
hs : s ∈ pure g
t : Set α
ht : t ∈ f
a : α
ha : a ∈ t
⊢ g a ∈ Set.seq s t
[PROOFSTEP]
exact ⟨g, hs, a, ha, rfl⟩
[GOAL]
α : Type u
β : Type v
γ : Type w
δ : Type u_1
ι : Sort x
f : Filter (α → β)
a : α
⊢ seq f (pure a) = map (fun g => g a) f
[PROOFSTEP]
refine' le_antisymm (le_map fun s hs => _) (le_seq fun s hs t ht => _)
[GOAL]
case refine'_1
α : Type u
β : Type v
γ : Type w
δ : Type u_1
ι : Sort x
f : Filter (α → β)
a : α
s : Set (α → β)
hs : s ∈ f
⊢ (fun g => g a) '' s ∈ seq f (pure a)
[PROOFSTEP]
rw [← seq_singleton]
[GOAL]
case refine'_1
α : Type u
β : Type v
γ : Type w
δ : Type u_1
ι : Sort x
f : Filter (α → β)
a : α
s : Set (α → β)
hs : s ∈ f
⊢ Set.seq s {a} ∈ seq f (pure a)
[PROOFSTEP]
exact seq_mem_seq hs singleton_mem_pure
[GOAL]
case refine'_2
α : Type u
β : Type v
γ : Type w
δ : Type u_1
ι : Sort x
f : Filter (α → β)
a : α
s : Set (α → β)
hs : s ∈ f
t : Set α
ht : t ∈ pure a
⊢ Set.seq s t ∈ map (fun g => g a) f
[PROOFSTEP]
refine' sets_of_superset (map (fun g : α → β => g a) f) (image_mem_map hs) _
[GOAL]
case refine'_2
α : Type u
β : Type v
γ : Type w
δ : Type u_1
ι : Sort x
f : Filter (α → β)
a : α
s : Set (α → β)
hs : s ∈ f
t : Set α
ht : t ∈ pure a
⊢ (fun g => g a) '' s ⊆ Set.seq s t
[PROOFSTEP]
rintro b ⟨g, hg, rfl⟩
[GOAL]
case refine'_2.intro.intro
α : Type u
β : Type v
γ : Type w
δ : Type u_1
ι : Sort x
f : Filter (α → β)
a : α
s : Set (α → β)
hs : s ∈ f
t : Set α
ht : t ∈ pure a
g : α → β
hg : g ∈ s
⊢ (fun g => g a) g ∈ Set.seq s t
[PROOFSTEP]
exact ⟨g, hg, a, ht, rfl⟩
[GOAL]
α : Type u
β : Type v
γ : Type w
δ : Type u_1
ι : Sort x
x : Filter α
g : Filter (α → β)
h : Filter (β → γ)
⊢ seq h (seq g x) = seq (seq (map (fun x x_1 => x ∘ x_1) h) g) x
[PROOFSTEP]
refine' le_antisymm (le_seq fun s hs t ht => _) (le_seq fun s hs t ht => _)
[GOAL]
case refine'_1
α : Type u
β : Type v
γ : Type w
δ : Type u_1
ι : Sort x
x : Filter α
g : Filter (α → β)
h : Filter (β → γ)
s : Set (α → γ)
hs : s ∈ seq (map (fun x x_1 => x ∘ x_1) h) g
t : Set α
ht : t ∈ x
⊢ Set.seq s t ∈ seq h (seq g x)
[PROOFSTEP]
rcases mem_seq_iff.1 hs with ⟨u, hu, v, hv, hs⟩
[GOAL]
case refine'_1.intro.intro.intro.intro
α : Type u
β : Type v
γ : Type w
δ : Type u_1
ι : Sort x
x : Filter α
g : Filter (α → β)
h : Filter (β → γ)
s : Set (α → γ)
hs✝ : s ∈ seq (map (fun x x_1 => x ∘ x_1) h) g
t : Set α
ht : t ∈ x
u : Set ((α → β) → α → γ)
hu : u ∈ map (fun x x_1 => x ∘ x_1) h
v : Set (α → β)
hv : v ∈ g
hs : Set.seq u v ⊆ s
⊢ Set.seq s t ∈ seq h (seq g x)
[PROOFSTEP]
rcases mem_map_iff_exists_image.1 hu with ⟨w, hw, hu⟩
[GOAL]
case refine'_1.intro.intro.intro.intro.intro.intro
α : Type u
β : Type v
γ : Type w
δ : Type u_1
ι : Sort x
x : Filter α
g : Filter (α → β)
h : Filter (β → γ)
s : Set (α → γ)
hs✝ : s ∈ seq (map (fun x x_1 => x ∘ x_1) h) g
t : Set α
ht : t ∈ x
u : Set ((α → β) → α → γ)
hu✝ : u ∈ map (fun x x_1 => x ∘ x_1) h
v : Set (α → β)
hv : v ∈ g
hs : Set.seq u v ⊆ s
w : Set (β → γ)
hw : w ∈ h
hu : (fun x x_1 => x ∘ x_1) '' w ⊆ u
⊢ Set.seq s t ∈ seq h (seq g x)
[PROOFSTEP]
refine' mem_of_superset _ (Set.seq_mono ((Set.seq_mono hu Subset.rfl).trans hs) Subset.rfl)
[GOAL]
case refine'_1.intro.intro.intro.intro.intro.intro
α : Type u
β : Type v
γ : Type w
δ : Type u_1
ι : Sort x
x : Filter α
g : Filter (α → β)
h : Filter (β → γ)
s : Set (α → γ)
hs✝ : s ∈ seq (map (fun x x_1 => x ∘ x_1) h) g
t : Set α
ht : t ∈ x
u : Set ((α → β) → α → γ)
hu✝ : u ∈ map (fun x x_1 => x ∘ x_1) h
v : Set (α → β)
hv : v ∈ g
hs : Set.seq u v ⊆ s
w : Set (β → γ)
hw : w ∈ h
hu : (fun x x_1 => x ∘ x_1) '' w ⊆ u
⊢ Set.seq (Set.seq ((fun x x_1 => x ∘ x_1) '' w) v) t ∈ seq h (seq g x)
[PROOFSTEP]
rw [← Set.seq_seq]
[GOAL]
case refine'_1.intro.intro.intro.intro.intro.intro
α : Type u
β : Type v
γ : Type w
δ : Type u_1
ι : Sort x
x : Filter α
g : Filter (α → β)
h : Filter (β → γ)
s : Set (α → γ)
hs✝ : s ∈ seq (map (fun x x_1 => x ∘ x_1) h) g
t : Set α
ht : t ∈ x
u : Set ((α → β) → α → γ)
hu✝ : u ∈ map (fun x x_1 => x ∘ x_1) h
v : Set (α → β)
hv : v ∈ g
hs : Set.seq u v ⊆ s
w : Set (β → γ)
hw : w ∈ h
hu : (fun x x_1 => x ∘ x_1) '' w ⊆ u
⊢ Set.seq w (Set.seq v t) ∈ seq h (seq g x)
[PROOFSTEP]
exact seq_mem_seq hw (seq_mem_seq hv ht)
[GOAL]
case refine'_2
α : Type u
β : Type v
γ : Type w
δ : Type u_1
ι : Sort x
x : Filter α
g : Filter (α → β)
h : Filter (β → γ)
s : Set (β → γ)
hs : s ∈ h
t : Set β
ht : t ∈ seq g x
⊢ Set.seq s t ∈ seq (seq (map (fun x x_1 => x ∘ x_1) h) g) x
[PROOFSTEP]
rcases mem_seq_iff.1 ht with ⟨u, hu, v, hv, ht⟩
[GOAL]
case refine'_2.intro.intro.intro.intro
α : Type u
β : Type v
γ : Type w
δ : Type u_1
ι : Sort x
x : Filter α
g : Filter (α → β)
h : Filter (β → γ)
s : Set (β → γ)
hs : s ∈ h
t : Set β
ht✝ : t ∈ seq g x
u : Set (α → β)
hu : u ∈ g
v : Set α
hv : v ∈ x
ht : Set.seq u v ⊆ t
⊢ Set.seq s t ∈ seq (seq (map (fun x x_1 => x ∘ x_1) h) g) x
[PROOFSTEP]
refine' mem_of_superset _ (Set.seq_mono Subset.rfl ht)
[GOAL]
case refine'_2.intro.intro.intro.intro
α : Type u
β : Type v
γ : Type w
δ : Type u_1
ι : Sort x
x : Filter α
g : Filter (α → β)
h : Filter (β → γ)
s : Set (β → γ)
hs : s ∈ h
t : Set β
ht✝ : t ∈ seq g x
u : Set (α → β)
hu : u ∈ g
v : Set α
hv : v ∈ x
ht : Set.seq u v ⊆ t
⊢ Set.seq s (Set.seq u v) ∈ seq (seq (map (fun x x_1 => x ∘ x_1) h) g) x
[PROOFSTEP]
rw [Set.seq_seq]
[GOAL]
case refine'_2.intro.intro.intro.intro
α : Type u
β : Type v
γ : Type w
δ : Type u_1
ι : Sort x
x : Filter α
g : Filter (α → β)
h : Filter (β → γ)
s : Set (β → γ)
hs : s ∈ h
t : Set β
ht✝ : t ∈ seq g x
u : Set (α → β)
hu : u ∈ g
v : Set α
hv : v ∈ x
ht : Set.seq u v ⊆ t
⊢ Set.seq (Set.seq ((fun x x_1 => x ∘ x_1) '' s) u) v ∈ seq (seq (map (fun x x_1 => x ∘ x_1) h) g) x
[PROOFSTEP]
exact seq_mem_seq (seq_mem_seq (image_mem_map hs) hu) hv
[GOAL]
α : Type u
β : Type v
γ : Type w
δ : Type u_1
ι : Sort x
f : Filter α
g : Filter β
⊢ seq (map Prod.mk f) g = seq (map (fun b a => (a, b)) g) f
[PROOFSTEP]
refine' le_antisymm (le_seq fun s hs t ht => _) (le_seq fun s hs t ht => _)
[GOAL]
case refine'_1
α : Type u
β : Type v
γ : Type w
δ : Type u_1
ι : Sort x
f : Filter α
g : Filter β
s : Set (α → α × β)
hs : s ∈ map (fun b a => (a, b)) g
t : Set α
ht : t ∈ f
⊢ Set.seq s t ∈ seq (map Prod.mk f) g
[PROOFSTEP]
rcases mem_map_iff_exists_image.1 hs with ⟨u, hu, hs⟩
[GOAL]
case refine'_1.intro.intro
α : Type u
β : Type v
γ : Type w
δ : Type u_1
ι : Sort x
f : Filter α
g : Filter β
s : Set (α → α × β)
hs✝ : s ∈ map (fun b a => (a, b)) g
t : Set α
ht : t ∈ f
u : Set β
hu : u ∈ g
hs : (fun b a => (a, b)) '' u ⊆ s
⊢ Set.seq s t ∈ seq (map Prod.mk f) g
[PROOFSTEP]
refine' mem_of_superset _ (Set.seq_mono hs Subset.rfl)
[GOAL]
case refine'_1.intro.intro
α : Type u
β : Type v
γ : Type w
δ : Type u_1
ι : Sort x
f : Filter α
g : Filter β
s : Set (α → α × β)
hs✝ : s ∈ map (fun b a => (a, b)) g
t : Set α
ht : t ∈ f
u : Set β
hu : u ∈ g
hs : (fun b a => (a, b)) '' u ⊆ s
⊢ Set.seq ((fun b a => (a, b)) '' u) t ∈ seq (map Prod.mk f) g
[PROOFSTEP]
rw [← Set.prod_image_seq_comm]
[GOAL]
case refine'_1.intro.intro
α : Type u
β : Type v
γ : Type w
δ : Type u_1
ι : Sort x
f : Filter α
g : Filter β
s : Set (α → α × β)
hs✝ : s ∈ map (fun b a => (a, b)) g
t : Set α
ht : t ∈ f
u : Set β
hu : u ∈ g
hs : (fun b a => (a, b)) '' u ⊆ s
⊢ Set.seq (Prod.mk '' t) u ∈ seq (map Prod.mk f) g
[PROOFSTEP]
exact seq_mem_seq (image_mem_map ht) hu
[GOAL]
case refine'_2
α : Type u
β : Type v
γ : Type w
δ : Type u_1
ι : Sort x
f : Filter α
g : Filter β
s : Set (β → α × β)
hs : s ∈ map Prod.mk f
t : Set β
ht : t ∈ g
⊢ Set.seq s t ∈ seq (map (fun b a => (a, b)) g) f
[PROOFSTEP]
rcases mem_map_iff_exists_image.1 hs with ⟨u, hu, hs⟩
[GOAL]
case refine'_2.intro.intro
α : Type u
β : Type v
γ : Type w
δ : Type u_1
ι : Sort x
f : Filter α
g : Filter β
s : Set (β → α × β)
hs✝ : s ∈ map Prod.mk f
t : Set β
ht : t ∈ g
u : Set α
hu : u ∈ f
hs : Prod.mk '' u ⊆ s
⊢ Set.seq s t ∈ seq (map (fun b a => (a, b)) g) f
[PROOFSTEP]
refine' mem_of_superset _ (Set.seq_mono hs Subset.rfl)
[GOAL]
case refine'_2.intro.intro
α : Type u
β : Type v
γ : Type w
δ : Type u_1
ι : Sort x
f : Filter α
g : Filter β
s : Set (β → α × β)
hs✝ : s ∈ map Prod.mk f
t : Set β
ht : t ∈ g
u : Set α
hu : u ∈ f
hs : Prod.mk '' u ⊆ s
⊢ Set.seq (Prod.mk '' u) t ∈ seq (map (fun b a => (a, b)) g) f
[PROOFSTEP]
rw [Set.prod_image_seq_comm]
[GOAL]
case refine'_2.intro.intro
α : Type u
β : Type v
γ : Type w
δ : Type u_1
ι : Sort x
f : Filter α
g : Filter β
s : Set (β → α × β)
hs✝ : s ∈ map Prod.mk f
t : Set β
ht : t ∈ g
u : Set α
hu : u ∈ f
hs : Prod.mk '' u ⊆ s
⊢ Set.seq ((fun b a => (a, b)) '' t) u ∈ seq (map (fun b a => (a, b)) g) f
[PROOFSTEP]
exact seq_mem_seq (image_mem_map ht) hu
[GOAL]
α : Type u
β : Type v
γ : Type w
δ : Type u_1
ι : Sort x
f₁ f₂ : Filter α
g₁ g₂ : α → Filter β
hf : f₁ ≤ f₂
hg : g₁ ≤ᶠ[f₁] g₂
⊢ bind f₁ g₁ ≤ bind f₂ g₂
[PROOFSTEP]
refine' le_trans (fun s hs => _) (join_mono <| map_mono hf)
[GOAL]
α : Type u
β : Type v
γ : Type w
δ : Type u_1
ι : Sort x
f₁ f₂ : Filter α
g₁ g₂ : α → Filter β
hf : f₁ ≤ f₂
hg : g₁ ≤ᶠ[f₁] g₂
s : Set β
hs : s ∈ join (map g₂ f₁)
⊢ s ∈ bind f₁ g₁
[PROOFSTEP]
simp only [mem_join, mem_bind', mem_map] at hs ⊢
[GOAL]
α : Type u
β : Type v
γ : Type w
δ : Type u_1
ι : Sort x
f₁ f₂ : Filter α
g₁ g₂ : α → Filter β
hf : f₁ ≤ f₂
hg : g₁ ≤ᶠ[f₁] g₂
s : Set β
hs : g₂ ⁻¹' {t | s ∈ t} ∈ f₁
⊢ {a | s ∈ g₁ a} ∈ f₁
[PROOFSTEP]
filter_upwards [hg, hs] with _ hx hs using hx hs
[GOAL]
α : Type u
β : Type v
γ : Type w
δ : Type u_1
ι : Sort x
f : Filter α
g : α → Filter β
s✝ s : Set β
⊢ (s ∈ bind f fun x => g x ⊓ 𝓟 s✝) ↔ s ∈ bind f g ⊓ 𝓟 s✝
[PROOFSTEP]
simp only [mem_bind, mem_inf_principal]
[GOAL]
α : Type u
β : Type v
γ : Type w
δ : Type u_1
ι : Sort x
s : Set α
f : α → Filter β
⊢ join (map f (𝓟 s)) = ⨆ (x : α) (_ : x ∈ s), f x
[PROOFSTEP]
simp only [sSup_image, join_principal_eq_sSup, map_principal, eq_self_iff_true]
[GOAL]
α : Type u
β : Type v
γ : Type w
δ : Type u_1
ι : Sort x
α' β' γ' : Type u
f : β' → Filter α'
s : γ' → Set α'
fs : List β'
t : Set (List α')
⊢ t ∈ traverse f fs ↔ ∃ us, Forall₂ (fun b s => s ∈ f b) fs us ∧ sequence us ⊆ t
[PROOFSTEP]
constructor
[GOAL]
case mp
α : Type u
β : Type v
γ : Type w
δ : Type u_1
ι : Sort x
α' β' γ' : Type u
f : β' → Filter α'
s : γ' → Set α'
fs : List β'
t : Set (List α')
⊢ t ∈ traverse f fs → ∃ us, Forall₂ (fun b s => s ∈ f b) fs us ∧ sequence us ⊆ t
[PROOFSTEP]
induction fs generalizing t
[GOAL]
case mp.nil
α : Type u
β : Type v
γ : Type w
δ : Type u_1
ι : Sort x
α' β' γ' : Type u
f : β' → Filter α'
s : γ' → Set α'
t : Set (List α')
⊢ t ∈ traverse f [] → ∃ us, Forall₂ (fun b s => s ∈ f b) [] us ∧ sequence us ⊆ t
case mp.cons
α : Type u
β : Type v
γ : Type w
δ : Type u_1
ι : Sort x
α' β' γ' : Type u
f : β' → Filter α'
s : γ' → Set α'
head✝ : β'
tail✝ : List β'
tail_ih✝ : ∀ (t : Set (List α')), t ∈ traverse f tail✝ → ∃ us, Forall₂ (fun b s => s ∈ f b) tail✝ us ∧ sequence us ⊆ t
t : Set (List α')
⊢ t ∈ traverse f (head✝ :: tail✝) → ∃ us, Forall₂ (fun b s => s ∈ f b) (head✝ :: tail✝) us ∧ sequence us ⊆ t
[PROOFSTEP]
case nil =>
  simp only [sequence, mem_pure, imp_self, forall₂_nil_left_iff, exists_eq_left, Set.pure_def, singleton_subset_iff,
    traverse_nil]
[GOAL]
α : Type u
β : Type v
γ : Type w
δ : Type u_1
ι : Sort x
α' β' γ' : Type u
f : β' → Filter α'
s : γ' → Set α'
t : Set (List α')
⊢ t ∈ traverse f [] → ∃ us, Forall₂ (fun b s => s ∈ f b) [] us ∧ sequence us ⊆ t
[PROOFSTEP]
case nil =>
  simp only [sequence, mem_pure, imp_self, forall₂_nil_left_iff, exists_eq_left, Set.pure_def, singleton_subset_iff,
    traverse_nil]
[GOAL]
α : Type u
β : Type v
γ : Type w
δ : Type u_1
ι : Sort x
α' β' γ' : Type u
f : β' → Filter α'
s : γ' → Set α'
t : Set (List α')
⊢ t ∈ traverse f [] → ∃ us, Forall₂ (fun b s => s ∈ f b) [] us ∧ sequence us ⊆ t
[PROOFSTEP]
simp only [sequence, mem_pure, imp_self, forall₂_nil_left_iff, exists_eq_left, Set.pure_def, singleton_subset_iff,
  traverse_nil]
[GOAL]
case mp.cons
α : Type u
β : Type v
γ : Type w
δ : Type u_1
ι : Sort x
α' β' γ' : Type u
f : β' → Filter α'
s : γ' → Set α'
head✝ : β'
tail✝ : List β'
tail_ih✝ : ∀ (t : Set (List α')), t ∈ traverse f tail✝ → ∃ us, Forall₂ (fun b s => s ∈ f b) tail✝ us ∧ sequence us ⊆ t
t : Set (List α')
⊢ t ∈ traverse f (head✝ :: tail✝) → ∃ us, Forall₂ (fun b s => s ∈ f b) (head✝ :: tail✝) us ∧ sequence us ⊆ t
[PROOFSTEP]
case cons b fs ih =>
  intro ht
  rcases mem_seq_iff.1 ht with ⟨u, hu, v, hv, ht⟩
  rcases mem_map_iff_exists_image.1 hu with ⟨w, hw, hwu⟩
  rcases ih v hv with ⟨us, hus, hu⟩
  exact ⟨w :: us, Forall₂.cons hw hus, (Set.seq_mono hwu hu).trans ht⟩
[GOAL]
α : Type u
β : Type v
γ : Type w
δ : Type u_1
ι : Sort x
α' β' γ' : Type u
f : β' → Filter α'
s : γ' → Set α'
b : β'
fs : List β'
ih : ∀ (t : Set (List α')), t ∈ traverse f fs → ∃ us, Forall₂ (fun b s => s ∈ f b) fs us ∧ sequence us ⊆ t
t : Set (List α')
⊢ t ∈ traverse f (b :: fs) → ∃ us, Forall₂ (fun b s => s ∈ f b) (b :: fs) us ∧ sequence us ⊆ t
[PROOFSTEP]
case cons b fs ih =>
  intro ht
  rcases mem_seq_iff.1 ht with ⟨u, hu, v, hv, ht⟩
  rcases mem_map_iff_exists_image.1 hu with ⟨w, hw, hwu⟩
  rcases ih v hv with ⟨us, hus, hu⟩
  exact ⟨w :: us, Forall₂.cons hw hus, (Set.seq_mono hwu hu).trans ht⟩
[GOAL]
α : Type u
β : Type v
γ : Type w
δ : Type u_1
ι : Sort x
α' β' γ' : Type u
f : β' → Filter α'
s : γ' → Set α'
b : β'
fs : List β'
ih : ∀ (t : Set (List α')), t ∈ traverse f fs → ∃ us, Forall₂ (fun b s => s ∈ f b) fs us ∧ sequence us ⊆ t
t : Set (List α')
⊢ t ∈ traverse f (b :: fs) → ∃ us, Forall₂ (fun b s => s ∈ f b) (b :: fs) us ∧ sequence us ⊆ t
[PROOFSTEP]
intro ht
[GOAL]
α : Type u
β : Type v
γ : Type w
δ : Type u_1
ι : Sort x
α' β' γ' : Type u
f : β' → Filter α'
s : γ' → Set α'
b : β'
fs : List β'
ih : ∀ (t : Set (List α')), t ∈ traverse f fs → ∃ us, Forall₂ (fun b s => s ∈ f b) fs us ∧ sequence us ⊆ t
t : Set (List α')
ht : t ∈ traverse f (b :: fs)
⊢ ∃ us, Forall₂ (fun b s => s ∈ f b) (b :: fs) us ∧ sequence us ⊆ t
[PROOFSTEP]
rcases mem_seq_iff.1 ht with ⟨u, hu, v, hv, ht⟩
[GOAL]
case intro.intro.intro.intro
α : Type u
β : Type v
γ : Type w
δ : Type u_1
ι : Sort x
α' β' γ' : Type u
f : β' → Filter α'
s : γ' → Set α'
b : β'
fs : List β'
ih : ∀ (t : Set (List α')), t ∈ traverse f fs → ∃ us, Forall₂ (fun b s => s ∈ f b) fs us ∧ sequence us ⊆ t
t : Set (List α')
ht✝ : t ∈ traverse f (b :: fs)
u : Set (List α' → List α')
hu : u ∈ cons <$> f b
v : Set (List α')
hv : v ∈ (fun x => List.traverse f fs) ()
ht : Set.seq u v ⊆ t
⊢ ∃ us, Forall₂ (fun b s => s ∈ f b) (b :: fs) us ∧ sequence us ⊆ t
[PROOFSTEP]
rcases mem_map_iff_exists_image.1 hu with ⟨w, hw, hwu⟩
[GOAL]
case intro.intro.intro.intro.intro.intro
α : Type u
β : Type v
γ : Type w
δ : Type u_1
ι : Sort x
α' β' γ' : Type u
f : β' → Filter α'
s : γ' → Set α'
b : β'
fs : List β'
ih : ∀ (t : Set (List α')), t ∈ traverse f fs → ∃ us, Forall₂ (fun b s => s ∈ f b) fs us ∧ sequence us ⊆ t
t : Set (List α')
ht✝ : t ∈ traverse f (b :: fs)
u : Set (List α' → List α')
hu : u ∈ cons <$> f b
v : Set (List α')
hv : v ∈ (fun x => List.traverse f fs) ()
ht : Set.seq u v ⊆ t
w : Set α'
hw : w ∈ f b
hwu : cons '' w ⊆ u
⊢ ∃ us, Forall₂ (fun b s => s ∈ f b) (b :: fs) us ∧ sequence us ⊆ t
[PROOFSTEP]
rcases ih v hv with ⟨us, hus, hu⟩
[GOAL]
case intro.intro.intro.intro.intro.intro.intro.intro
α : Type u
β : Type v
γ : Type w
δ : Type u_1
ι : Sort x
α' β' γ' : Type u
f : β' → Filter α'
s : γ' → Set α'
b : β'
fs : List β'
ih : ∀ (t : Set (List α')), t ∈ traverse f fs → ∃ us, Forall₂ (fun b s => s ∈ f b) fs us ∧ sequence us ⊆ t
t : Set (List α')
ht✝ : t ∈ traverse f (b :: fs)
u : Set (List α' → List α')
hu✝ : u ∈ cons <$> f b
v : Set (List α')
hv : v ∈ (fun x => List.traverse f fs) ()
ht : Set.seq u v ⊆ t
w : Set α'
hw : w ∈ f b
hwu : cons '' w ⊆ u
us : List (Set α')
hus : Forall₂ (fun b s => s ∈ f b) fs us
hu : sequence us ⊆ v
⊢ ∃ us, Forall₂ (fun b s => s ∈ f b) (b :: fs) us ∧ sequence us ⊆ t
[PROOFSTEP]
exact ⟨w :: us, Forall₂.cons hw hus, (Set.seq_mono hwu hu).trans ht⟩
[GOAL]
case mpr
α : Type u
β : Type v
γ : Type w
δ : Type u_1
ι : Sort x
α' β' γ' : Type u
f : β' → Filter α'
s : γ' → Set α'
fs : List β'
t : Set (List α')
⊢ (∃ us, Forall₂ (fun b s => s ∈ f b) fs us ∧ sequence us ⊆ t) → t ∈ traverse f fs
[PROOFSTEP]
rintro ⟨us, hus, hs⟩
[GOAL]
case mpr.intro.intro
α : Type u
β : Type v
γ : Type w
δ : Type u_1
ι : Sort x
α' β' γ' : Type u
f : β' → Filter α'
s : γ' → Set α'
fs : List β'
t : Set (List α')
us : List (Set α')
hus : Forall₂ (fun b s => s ∈ f b) fs us
hs : sequence us ⊆ t
⊢ t ∈ traverse f fs
[PROOFSTEP]
exact mem_of_superset (mem_traverse _ _ hus) hs
[GOAL]
α : Type u
β : Type v
γ : Type w
δ : Type u_1
ι : Sort x
f : α → β
l : Filter β
⊢ Tendsto f ⊥ l
[PROOFSTEP]
simp [Tendsto]
[GOAL]
α : Type u
β : Type v
γ : Type w
δ : Type u_1
ι : Sort x
mab : α → β
mba : β → α
f : Filter α
g : Filter β
h₁ : mab ∘ mba =ᶠ[g] id
h₂ : Tendsto mba g f
⊢ g ≤ map mab f
[PROOFSTEP]
rw [← @map_id _ g, ← map_congr h₁, ← map_map]
[GOAL]
α : Type u
β : Type v
γ : Type w
δ : Type u_1
ι : Sort x
mab : α → β
mba : β → α
f : Filter α
g : Filter β
h₁ : mab ∘ mba =ᶠ[g] id
h₂ : Tendsto mba g f
⊢ map mab (map mba g) ≤ map mab f
[PROOFSTEP]
exact map_mono h₂
[GOAL]
α : Type u
β : Type v
γ : Type w
δ : Type u_1
ι : Sort x
inst✝ : IsEmpty α
f : α → β
la : Filter α
lb : Filter β
⊢ Tendsto f la lb
[PROOFSTEP]
simp only [filter_eq_bot_of_isEmpty la, tendsto_bot]
[GOAL]
α : Type u
β : Type v
γ : Type w
δ : Type u_1
ι : Sort x
f₁ f₂ : α → β
l₁ : Filter α
l₂ : Filter β
hl : f₁ =ᶠ[l₁] f₂
⊢ Tendsto f₁ l₁ l₂ ↔ Tendsto f₂ l₁ l₂
[PROOFSTEP]
rw [Tendsto, Tendsto, map_congr hl]
[GOAL]
α : Type u
β : Type v
γ : Type w
δ : Type u_1
ι : Sort x
f : β → γ
g : α → β
x : Filter α
y : Filter γ
⊢ Tendsto f (map g x) y ↔ Tendsto (f ∘ g) x y
[PROOFSTEP]
rw [Tendsto, Tendsto, map_map]
[GOAL]
α : Type u
β : Type v
γ : Type w
δ : Type u_1
ι : Sort x
f : α → β
g : β → γ
a : Filter α
c : Filter γ
h : Tendsto (g ∘ f) a c
⊢ map g (map f a) ≤ c
[PROOFSTEP]
rwa [map_map]
[GOAL]
α : Type u
β : Type v
γ : Type w
δ : Type u_1
ι : Sort x
m : α → β
f : Filter α
g : Filter β
i : γ → α
h : range i ∈ f
⊢ Tendsto (m ∘ i) (comap i f) g ↔ Tendsto m f g
[PROOFSTEP]
rw [Tendsto, ← map_compose]
[GOAL]
α : Type u
β : Type v
γ : Type w
δ : Type u_1
ι : Sort x
m : α → β
f : Filter α
g : Filter β
i : γ → α
h : range i ∈ f
⊢ (map m ∘ map i) (comap i f) ≤ g ↔ Tendsto m f g
[PROOFSTEP]
simp only [(· ∘ ·), map_comap_of_mem h, Tendsto]
[GOAL]
α : Type u
β : Type v
γ : Type w
δ : Type u_1
ι : Sort x
f : α → β
g : β → γ
a : Filter α
b : Filter β
c : Filter γ
hfg : Tendsto (g ∘ f) a c
hg : comap g c ≤ b
⊢ Tendsto f a b
[PROOFSTEP]
rw [tendsto_iff_comap] at hfg ⊢
[GOAL]
α : Type u
β : Type v
γ : Type w
δ : Type u_1
ι : Sort x
f : α → β
g : β → γ
a : Filter α
b : Filter β
c : Filter γ
hfg : a ≤ comap (g ∘ f) c
hg : comap g c ≤ b
⊢ a ≤ comap f b
[PROOFSTEP]
calc
  a ≤ comap (g ∘ f) c := hfg
  _ ≤ comap f b := by simpa [comap_comap] using comap_mono hg
[GOAL]
α : Type u
β : Type v
γ : Type w
δ : Type u_1
ι : Sort x
f : α → β
g : β → γ
a : Filter α
b : Filter β
c : Filter γ
hfg : a ≤ comap (g ∘ f) c
hg : comap g c ≤ b
⊢ comap (g ∘ f) c ≤ comap f b
[PROOFSTEP]
simpa [comap_comap] using comap_mono hg
[GOAL]
α : Type u
β : Type v
γ : Type w
δ : Type u_1
ι : Sort x
f : Filter α
g : Filter β
φ : α → β
ψ : β → α
eq : ψ ∘ φ = id
hφ : Tendsto φ f g
hψ : Tendsto ψ g f
⊢ comap φ g = f
[PROOFSTEP]
refine' ((comap_mono <| map_le_iff_le_comap.1 hψ).trans _).antisymm (map_le_iff_le_comap.1 hφ)
[GOAL]
α : Type u
β : Type v
γ : Type w
δ : Type u_1
ι : Sort x
f : Filter α
g : Filter β
φ : α → β
ψ : β → α
eq : ψ ∘ φ = id
hφ : Tendsto φ f g
hψ : Tendsto ψ g f
⊢ comap φ (comap ψ f) ≤ f
[PROOFSTEP]
rw [comap_comap, eq, comap_id]
[GOAL]
α : Type u
β : Type v
γ : Type w
δ : Type u_1
ι : Sort x
f : Filter α
g : Filter β
φ : α → β
ψ : β → α
eq : φ ∘ ψ = id
hφ : Tendsto φ f g
hψ : Tendsto ψ g f
⊢ map φ f = g
[PROOFSTEP]
refine' le_antisymm hφ (le_trans _ (map_mono hψ))
[GOAL]
α : Type u
β : Type v
γ : Type w
δ : Type u_1
ι : Sort x
f : Filter α
g : Filter β
φ : α → β
ψ : β → α
eq : φ ∘ ψ = id
hφ : Tendsto φ f g
hψ : Tendsto ψ g f
⊢ g ≤ map φ (map ψ g)
[PROOFSTEP]
rw [map_map, eq, map_id]
[GOAL]
α : Type u
β : Type v
γ : Type w
δ : Type u_1
ι : Sort x
f : α → β
x : Filter α
y₁ y₂ : Filter β
⊢ Tendsto f x (y₁ ⊓ y₂) ↔ Tendsto f x y₁ ∧ Tendsto f x y₂
[PROOFSTEP]
simp only [Tendsto, le_inf_iff, iff_self_iff]
[GOAL]
α : Type u
β : Type v
γ : Type w
δ : Type u_1
ι : Sort x
f : α → β
x : Filter α
y : ι → Filter β
⊢ Tendsto f x (⨅ (i : ι), y i) ↔ ∀ (i : ι), Tendsto f x (y i)
[PROOFSTEP]
simp only [Tendsto, iff_self_iff, le_iInf_iff]
[GOAL]
α : Type u
β : Type v
γ : Type w
δ : Type u_1
ι : Sort x
f : α → β
x₁ x₂ : Filter α
y : Filter β
⊢ Tendsto f (x₁ ⊔ x₂) y ↔ Tendsto f x₁ y ∧ Tendsto f x₂ y
[PROOFSTEP]
simp only [Tendsto, map_sup, sup_le_iff]
[GOAL]
α : Type u
β : Type v
γ : Type w
δ : Type u_1
ι : Sort x
f : α → β
x : ι → Filter α
y : Filter β
⊢ Tendsto f (⨆ (i : ι), x i) y ↔ ∀ (i : ι), Tendsto f (x i) y
[PROOFSTEP]
simp only [Tendsto, map_iSup, iSup_le_iff]
[GOAL]
α : Type u
β : Type v
γ : Type w
δ : Type u_1
ι : Sort x
f : α → β
l : Filter α
s : Set β
⊢ Tendsto f l (𝓟 s) ↔ ∀ᶠ (a : α) in l, f a ∈ s
[PROOFSTEP]
simp only [Tendsto, le_principal_iff, mem_map', Filter.Eventually]
[GOAL]
α : Type u
β : Type v
γ : Type w
δ : Type u_1
ι : Sort x
f : α → β
s : Set α
t : Set β
⊢ Tendsto f (𝓟 s) (𝓟 t) ↔ ∀ (a : α), a ∈ s → f a ∈ t
[PROOFSTEP]
simp only [tendsto_principal, eventually_principal]
[GOAL]
α : Type u
β : Type v
γ : Type w
δ : Type u_1
ι : Sort x
f : α → β
a : Filter α
b : β
⊢ Tendsto f a (pure b) ↔ ∀ᶠ (x : α) in a, f x = b
[PROOFSTEP]
simp only [Tendsto, le_pure_iff, mem_map', mem_singleton_iff, Filter.Eventually]
[GOAL]
α : Type u
β : Type v
γ : Type w
δ : Type u_1
ι : Sort x
f : α → β
s : Set β
l : Filter α
t : Set β
⊢ t ∈ map f (l ⊓ 𝓟 (f ⁻¹' s)) ↔ t ∈ map f l ⊓ 𝓟 s
[PROOFSTEP]
simp only [mem_map', mem_inf_principal, mem_setOf_eq, mem_preimage]
[GOAL]
α : Type u
β : Type v
γ : Type w
δ : Type u_1
ι : Sort x
l₁ : Filter α
l₂ : Filter β
f g : α → β
p : α → Prop
inst✝ : (x : α) → Decidable (p x)
h₀ : Tendsto f (l₁ ⊓ 𝓟 {x | p x}) l₂
h₁ : Tendsto g (l₁ ⊓ 𝓟 {x | ¬p x}) l₂
⊢ Tendsto (fun x => if p x then f x else g x) l₁ l₂
[PROOFSTEP]
simp only [tendsto_def, mem_inf_principal] at *
[GOAL]
α : Type u
β : Type v
γ : Type w
δ : Type u_1
ι : Sort x
l₁ : Filter α
l₂ : Filter β
f g : α → β
p : α → Prop
inst✝ : (x : α) → Decidable (p x)
h₀ : ∀ (s : Set β), s ∈ l₂ → {x | x ∈ {x | p x} → x ∈ f ⁻¹' s} ∈ l₁
h₁ : ∀ (s : Set β), s ∈ l₂ → {x | x ∈ {x | ¬p x} → x ∈ g ⁻¹' s} ∈ l₁
⊢ ∀ (s : Set β), s ∈ l₂ → (fun x => if p x then f x else g x) ⁻¹' s ∈ l₁
[PROOFSTEP]
intro s hs
[GOAL]
α : Type u
β : Type v
γ : Type w
δ : Type u_1
ι : Sort x
l₁ : Filter α
l₂ : Filter β
f g : α → β
p : α → Prop
inst✝ : (x : α) → Decidable (p x)
h₀ : ∀ (s : Set β), s ∈ l₂ → {x | x ∈ {x | p x} → x ∈ f ⁻¹' s} ∈ l₁
h₁ : ∀ (s : Set β), s ∈ l₂ → {x | x ∈ {x | ¬p x} → x ∈ g ⁻¹' s} ∈ l₁
s : Set β
hs : s ∈ l₂
⊢ (fun x => if p x then f x else g x) ⁻¹' s ∈ l₁
[PROOFSTEP]
filter_upwards [h₀ s hs, h₁ s hs] with x hp₀ hp₁
[GOAL]
case h
α : Type u
β : Type v
γ : Type w
δ : Type u_1
ι : Sort x
l₁ : Filter α
l₂ : Filter β
f g : α → β
p : α → Prop
inst✝ : (x : α) → Decidable (p x)
h₀ : ∀ (s : Set β), s ∈ l₂ → {x | x ∈ {x | p x} → x ∈ f ⁻¹' s} ∈ l₁
h₁ : ∀ (s : Set β), s ∈ l₂ → {x | x ∈ {x | ¬p x} → x ∈ g ⁻¹' s} ∈ l₁
s : Set β
hs : s ∈ l₂
x : α
hp₀ : p x → x ∈ f ⁻¹' s
hp₁ : ¬p x → x ∈ g ⁻¹' s
⊢ x ∈ (fun x => if p x then f x else g x) ⁻¹' s
[PROOFSTEP]
rw [mem_preimage]
[GOAL]
case h
α : Type u
β : Type v
γ : Type w
δ : Type u_1
ι : Sort x
l₁ : Filter α
l₂ : Filter β
f g : α → β
p : α → Prop
inst✝ : (x : α) → Decidable (p x)
h₀ : ∀ (s : Set β), s ∈ l₂ → {x | x ∈ {x | p x} → x ∈ f ⁻¹' s} ∈ l₁
h₁ : ∀ (s : Set β), s ∈ l₂ → {x | x ∈ {x | ¬p x} → x ∈ g ⁻¹' s} ∈ l₁
s : Set β
hs : s ∈ l₂
x : α
hp₀ : p x → x ∈ f ⁻¹' s
hp₁ : ¬p x → x ∈ g ⁻¹' s
⊢ (if p x then f x else g x) ∈ s
[PROOFSTEP]
split_ifs with h
[GOAL]
case pos
α : Type u
β : Type v
γ : Type w
δ : Type u_1
ι : Sort x
l₁ : Filter α
l₂ : Filter β
f g : α → β
p : α → Prop
inst✝ : (x : α) → Decidable (p x)
h₀ : ∀ (s : Set β), s ∈ l₂ → {x | x ∈ {x | p x} → x ∈ f ⁻¹' s} ∈ l₁
h₁ : ∀ (s : Set β), s ∈ l₂ → {x | x ∈ {x | ¬p x} → x ∈ g ⁻¹' s} ∈ l₁
s : Set β
hs : s ∈ l₂
x : α
hp₀ : p x → x ∈ f ⁻¹' s
hp₁ : ¬p x → x ∈ g ⁻¹' s
h : p x
⊢ f x ∈ s
case neg
α : Type u
β : Type v
γ : Type w
δ : Type u_1
ι : Sort x
l₁ : Filter α
l₂ : Filter β
f g : α → β
p : α → Prop
inst✝ : (x : α) → Decidable (p x)
h₀ : ∀ (s : Set β), s ∈ l₂ → {x | x ∈ {x | p x} → x ∈ f ⁻¹' s} ∈ l₁
h₁ : ∀ (s : Set β), s ∈ l₂ → {x | x ∈ {x | ¬p x} → x ∈ g ⁻¹' s} ∈ l₁
s : Set β
hs : s ∈ l₂
x : α
hp₀ : p x → x ∈ f ⁻¹' s
hp₁ : ¬p x → x ∈ g ⁻¹' s
h : ¬p x
⊢ g x ∈ s
[PROOFSTEP]
exacts [hp₀ h, hp₁ h]