statement stringlengths 1 2.88k | proof stringlengths 0 13.9k | type stringclasses 10
values | symbolic_name stringlengths 1 131 | library stringclasses 417
values | filename stringlengths 17 80 | imports listlengths 0 16 | deps listlengths 0 64 | docstring stringlengths 0 10.2k | source_url stringclasses 1
value | commit stringclasses 1
value |
|---|---|---|---|---|---|---|---|---|---|---|
comap_eq_bot_iff_compl_range {f : filter β} {m : α → β} :
comap m f = ⊥ ↔ (range m)ᶜ ∈ f | not_iff_not.mp $ ne_bot_iff.symm.trans comap_ne_bot_iff_compl_range | lemma | filter.comap_eq_bot_iff_compl_range | order.filter | src/order/filter/basic.lean | [
"control.traversable.instances",
"data.set.finite",
"order.copy",
"tactic.monotonicity"
] | [
"filter"
] | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 | |
comap_surjective_eq_bot {f : filter β} {m : α → β} (hm : surjective m) :
comap m f = ⊥ ↔ f = ⊥ | by rw [comap_eq_bot_iff_compl_range, hm.range_eq, compl_univ, empty_mem_iff_bot] | lemma | filter.comap_surjective_eq_bot | order.filter | src/order/filter/basic.lean | [
"control.traversable.instances",
"data.set.finite",
"order.copy",
"tactic.monotonicity"
] | [
"filter"
] | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 | |
disjoint_comap_iff (h : surjective m) : disjoint (comap m g₁) (comap m g₂) ↔ disjoint g₁ g₂ | by rw [disjoint_iff, disjoint_iff, ← comap_inf, comap_surjective_eq_bot h] | lemma | filter.disjoint_comap_iff | order.filter | src/order/filter/basic.lean | [
"control.traversable.instances",
"data.set.finite",
"order.copy",
"tactic.monotonicity"
] | [
"disjoint",
"disjoint_iff"
] | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 | |
ne_bot.comap_of_range_mem {f : filter β} {m : α → β}
(hf : ne_bot f) (hm : range m ∈ f) : ne_bot (comap m f) | comap_ne_bot_iff_frequently.2 $ eventually.frequently hm | lemma | filter.ne_bot.comap_of_range_mem | order.filter | src/order/filter/basic.lean | [
"control.traversable.instances",
"data.set.finite",
"order.copy",
"tactic.monotonicity"
] | [
"filter"
] | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 | |
comap_fst_ne_bot_iff {f : filter α} :
(f.comap (prod.fst : α × β → α)).ne_bot ↔ f.ne_bot ∧ nonempty β | begin
casesI is_empty_or_nonempty β,
{ rw [filter_eq_bot_of_is_empty (f.comap _), ← not_iff_not]; [simp *, apply_instance] },
{ simp [comap_ne_bot_iff_frequently, h] }
end | lemma | filter.comap_fst_ne_bot_iff | order.filter | src/order/filter/basic.lean | [
"control.traversable.instances",
"data.set.finite",
"order.copy",
"tactic.monotonicity"
] | [
"filter",
"is_empty_or_nonempty",
"not_iff_not"
] | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 | |
comap_fst_ne_bot [nonempty β] {f : filter α} [ne_bot f] :
(f.comap (prod.fst : α × β → α)).ne_bot | comap_fst_ne_bot_iff.2 ⟨‹_›, ‹_›⟩ | lemma | filter.comap_fst_ne_bot | order.filter | src/order/filter/basic.lean | [
"control.traversable.instances",
"data.set.finite",
"order.copy",
"tactic.monotonicity"
] | [
"filter"
] | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 | |
comap_snd_ne_bot_iff {f : filter β} :
(f.comap (prod.snd : α × β → β)).ne_bot ↔ nonempty α ∧ f.ne_bot | begin
casesI is_empty_or_nonempty α with hα hα,
{ rw [filter_eq_bot_of_is_empty (f.comap _), ← not_iff_not];
[simp, apply_instance] },
{ simp [comap_ne_bot_iff_frequently, hα] }
end | lemma | filter.comap_snd_ne_bot_iff | order.filter | src/order/filter/basic.lean | [
"control.traversable.instances",
"data.set.finite",
"order.copy",
"tactic.monotonicity"
] | [
"filter",
"is_empty_or_nonempty",
"not_iff_not"
] | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 | |
comap_snd_ne_bot [nonempty α] {f : filter β} [ne_bot f] :
(f.comap (prod.snd : α × β → β)).ne_bot | comap_snd_ne_bot_iff.2 ⟨‹_›, ‹_›⟩ | lemma | filter.comap_snd_ne_bot | order.filter | src/order/filter/basic.lean | [
"control.traversable.instances",
"data.set.finite",
"order.copy",
"tactic.monotonicity"
] | [
"filter"
] | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 | |
comap_eval_ne_bot_iff' {ι : Type*} {α : ι → Type*} {i : ι} {f : filter (α i)} :
(comap (eval i) f).ne_bot ↔ (∀ j, nonempty (α j)) ∧ ne_bot f | begin
casesI is_empty_or_nonempty (Π j, α j) with H H,
{ rw [filter_eq_bot_of_is_empty (f.comap _), ← not_iff_not]; [skip, assumption],
simp [← classical.nonempty_pi] },
{ haveI : ∀ j, nonempty (α j), from classical.nonempty_pi.1 H,
simp [comap_ne_bot_iff_frequently, *] }
end | lemma | filter.comap_eval_ne_bot_iff' | order.filter | src/order/filter/basic.lean | [
"control.traversable.instances",
"data.set.finite",
"order.copy",
"tactic.monotonicity"
] | [
"classical.nonempty_pi",
"filter",
"is_empty_or_nonempty",
"not_iff_not"
] | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 | |
comap_eval_ne_bot_iff {ι : Type*} {α : ι → Type*} [∀ j, nonempty (α j)]
{i : ι} {f : filter (α i)} :
(comap (eval i) f).ne_bot ↔ ne_bot f | by simp [comap_eval_ne_bot_iff', *] | lemma | filter.comap_eval_ne_bot_iff | order.filter | src/order/filter/basic.lean | [
"control.traversable.instances",
"data.set.finite",
"order.copy",
"tactic.monotonicity"
] | [
"filter"
] | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 | |
comap_eval_ne_bot {ι : Type*} {α : ι → Type*} [∀ j, nonempty (α j)]
(i : ι) (f : filter (α i)) [ne_bot f] :
(comap (eval i) f).ne_bot | comap_eval_ne_bot_iff.2 ‹_› | lemma | filter.comap_eval_ne_bot | order.filter | src/order/filter/basic.lean | [
"control.traversable.instances",
"data.set.finite",
"order.copy",
"tactic.monotonicity"
] | [
"filter"
] | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 | |
comap_inf_principal_ne_bot_of_image_mem {f : filter β} {m : α → β}
(hf : ne_bot f) {s : set α} (hs : m '' s ∈ f) :
ne_bot (comap m f ⊓ 𝓟 s) | begin
refine ⟨compl_compl s ▸ mt mem_of_eq_bot _⟩,
rintro ⟨t, ht, hts⟩,
rcases hf.nonempty_of_mem (inter_mem hs ht) with ⟨_, ⟨x, hxs, rfl⟩, hxt⟩,
exact absurd hxs (hts hxt)
end | lemma | filter.comap_inf_principal_ne_bot_of_image_mem | order.filter | src/order/filter/basic.lean | [
"control.traversable.instances",
"data.set.finite",
"order.copy",
"tactic.monotonicity"
] | [
"filter"
] | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 | |
comap_coe_ne_bot_of_le_principal {s : set γ} {l : filter γ} [h : ne_bot l] (h' : l ≤ 𝓟 s) :
ne_bot (comap (coe : s → γ) l) | h.comap_of_range_mem $ (@subtype.range_coe γ s).symm ▸ h' (mem_principal_self s) | lemma | filter.comap_coe_ne_bot_of_le_principal | order.filter | src/order/filter/basic.lean | [
"control.traversable.instances",
"data.set.finite",
"order.copy",
"tactic.monotonicity"
] | [
"filter",
"subtype.range_coe"
] | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 | |
ne_bot.comap_of_surj {f : filter β} {m : α → β}
(hf : ne_bot f) (hm : surjective m) :
ne_bot (comap m f) | hf.comap_of_range_mem $ univ_mem' hm | lemma | filter.ne_bot.comap_of_surj | order.filter | src/order/filter/basic.lean | [
"control.traversable.instances",
"data.set.finite",
"order.copy",
"tactic.monotonicity"
] | [
"filter"
] | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 | |
ne_bot.comap_of_image_mem {f : filter β} {m : α → β} (hf : ne_bot f)
{s : set α} (hs : m '' s ∈ f) :
ne_bot (comap m f) | hf.comap_of_range_mem $ mem_of_superset hs (image_subset_range _ _) | lemma | filter.ne_bot.comap_of_image_mem | order.filter | src/order/filter/basic.lean | [
"control.traversable.instances",
"data.set.finite",
"order.copy",
"tactic.monotonicity"
] | [
"filter"
] | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 | |
map_eq_bot_iff : map m f = ⊥ ↔ f = ⊥ | ⟨by { rw [←empty_mem_iff_bot, ←empty_mem_iff_bot], exact id },
λ h, by simp only [h, map_bot]⟩ | lemma | filter.map_eq_bot_iff | order.filter | src/order/filter/basic.lean | [
"control.traversable.instances",
"data.set.finite",
"order.copy",
"tactic.monotonicity"
] | [
"map_eq_bot_iff"
] | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 | |
map_ne_bot_iff (f : α → β) {F : filter α} : ne_bot (map f F) ↔ ne_bot F | by simp only [ne_bot_iff, ne, map_eq_bot_iff] | lemma | filter.map_ne_bot_iff | order.filter | src/order/filter/basic.lean | [
"control.traversable.instances",
"data.set.finite",
"order.copy",
"tactic.monotonicity"
] | [
"filter",
"map_eq_bot_iff"
] | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 | |
ne_bot.map (hf : ne_bot f) (m : α → β) : ne_bot (map m f) | (map_ne_bot_iff m).2 hf | lemma | filter.ne_bot.map | order.filter | src/order/filter/basic.lean | [
"control.traversable.instances",
"data.set.finite",
"order.copy",
"tactic.monotonicity"
] | [] | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 | |
ne_bot.of_map : ne_bot (f.map m) → ne_bot f | (map_ne_bot_iff m).1 | lemma | filter.ne_bot.of_map | order.filter | src/order/filter/basic.lean | [
"control.traversable.instances",
"data.set.finite",
"order.copy",
"tactic.monotonicity"
] | [] | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 | |
map_ne_bot [hf : ne_bot f] : ne_bot (f.map m) | hf.map m | instance | filter.map_ne_bot | order.filter | src/order/filter/basic.lean | [
"control.traversable.instances",
"data.set.finite",
"order.copy",
"tactic.monotonicity"
] | [] | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 | |
sInter_comap_sets (f : α → β) (F : filter β) :
⋂₀ (comap f F).sets = ⋂ U ∈ F, f ⁻¹' U | begin
ext x,
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_Inter, filter.mem_sets, mem_comap, this, and_imp,
exists_prop, mem_preimage, exists_imp_distrib],
split,
{ intros h U U_in,
simpa only [subse... | lemma | filter.sInter_comap_sets | order.filter | src/order/filter/basic.lean | [
"control.traversable.instances",
"data.set.finite",
"order.copy",
"tactic.monotonicity"
] | [
"and_imp",
"exists_imp_distrib",
"exists_prop",
"filter",
"filter.mem_sets",
"forall_prop_of_true"
] | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 | |
map_infi_le {f : ι → filter α} {m : α → β} :
map m (infi f) ≤ (⨅ i, map m (f i)) | le_infi $ λ i, map_mono $ infi_le _ _ | lemma | filter.map_infi_le | order.filter | src/order/filter/basic.lean | [
"control.traversable.instances",
"data.set.finite",
"order.copy",
"tactic.monotonicity"
] | [
"filter",
"infi",
"infi_le",
"le_infi"
] | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 | |
map_infi_eq {f : ι → filter α} {m : α → β} (hf : directed (≥) f) [nonempty ι] :
map m (infi f) = (⨅ i, map m (f i)) | map_infi_le.antisymm
(λ s (hs : preimage m s ∈ infi f),
let ⟨i, hi⟩ := (mem_infi_of_directed hf _).1 hs in
have (⨅ i, map m (f i)) ≤ 𝓟 s, from
infi_le_of_le i $ by { simp only [le_principal_iff, mem_map], assumption },
filter.le_principal_iff.1 this) | lemma | filter.map_infi_eq | order.filter | src/order/filter/basic.lean | [
"control.traversable.instances",
"data.set.finite",
"order.copy",
"tactic.monotonicity"
] | [
"directed",
"filter",
"infi",
"infi_le_of_le",
"mem_map"
] | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 | |
map_binfi_eq {ι : Type w} {f : ι → filter α} {m : α → β} {p : ι → Prop}
(h : directed_on (f ⁻¹'o (≥)) {x | p x}) (ne : ∃ i, p i) :
map m (⨅ i (h : p i), f i) = (⨅ i (h : p i), map m (f i)) | begin
haveI := nonempty_subtype.2 ne,
simp only [infi_subtype'],
exact map_infi_eq h.directed_coe
end | lemma | filter.map_binfi_eq | order.filter | src/order/filter/basic.lean | [
"control.traversable.instances",
"data.set.finite",
"order.copy",
"tactic.monotonicity"
] | [
"directed_on",
"filter",
"infi_subtype'"
] | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 | |
map_inf_le {f g : filter α} {m : α → β} : map m (f ⊓ g) ≤ map m f ⊓ map m g | (@map_mono _ _ m).map_inf_le f g | lemma | filter.map_inf_le | order.filter | src/order/filter/basic.lean | [
"control.traversable.instances",
"data.set.finite",
"order.copy",
"tactic.monotonicity"
] | [
"filter"
] | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 | |
map_inf {f g : filter α} {m : α → β} (h : injective m) :
map m (f ⊓ g) = map m f ⊓ map m g | begin
refine map_inf_le.antisymm _,
rintro t ⟨s₁, hs₁, s₂, hs₂, ht : m ⁻¹' t = s₁ ∩ s₂⟩,
refine mem_inf_of_inter (image_mem_map hs₁) (image_mem_map hs₂) _,
rw [←image_inter h, image_subset_iff, ht]
end | lemma | filter.map_inf | order.filter | src/order/filter/basic.lean | [
"control.traversable.instances",
"data.set.finite",
"order.copy",
"tactic.monotonicity"
] | [
"filter"
] | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 | |
map_inf' {f g : filter α} {m : α → β} {t : set α} (htf : t ∈ f) (htg : t ∈ g)
(h : inj_on m t) : map m (f ⊓ g) = map m f ⊓ map m g | begin
lift f to filter t using htf, lift g to filter t using htg,
replace h : injective (m ∘ coe) := h.injective,
simp only [map_map, ← map_inf subtype.coe_injective, map_inf h],
end | lemma | filter.map_inf' | order.filter | src/order/filter/basic.lean | [
"control.traversable.instances",
"data.set.finite",
"order.copy",
"tactic.monotonicity"
] | [
"filter",
"lift",
"subtype.coe_injective"
] | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 | |
disjoint_map {m : α → β} (hm : injective m) {f₁ f₂ : filter α} :
disjoint (map m f₁) (map m f₂) ↔ disjoint f₁ f₂ | by simp only [disjoint_iff, ← map_inf hm, map_eq_bot_iff] | lemma | filter.disjoint_map | order.filter | src/order/filter/basic.lean | [
"control.traversable.instances",
"data.set.finite",
"order.copy",
"tactic.monotonicity"
] | [
"disjoint",
"disjoint_iff",
"filter",
"map_eq_bot_iff"
] | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 | |
map_equiv_symm (e : α ≃ β) (f : filter β) :
map e.symm f = comap e f | map_injective e.injective $ by rw [map_map, e.self_comp_symm, map_id,
map_comap_of_surjective e.surjective] | lemma | filter.map_equiv_symm | order.filter | src/order/filter/basic.lean | [
"control.traversable.instances",
"data.set.finite",
"order.copy",
"tactic.monotonicity"
] | [
"filter",
"map_id"
] | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 | |
map_eq_comap_of_inverse {f : filter α} {m : α → β} {n : β → α}
(h₁ : m ∘ n = id) (h₂ : n ∘ m = id) : map m f = comap n f | map_equiv_symm ⟨n, m, congr_fun h₁, congr_fun h₂⟩ f | lemma | filter.map_eq_comap_of_inverse | order.filter | src/order/filter/basic.lean | [
"control.traversable.instances",
"data.set.finite",
"order.copy",
"tactic.monotonicity"
] | [
"filter"
] | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 | |
comap_equiv_symm (e : α ≃ β) (f : filter α) :
comap e.symm f = map e f | (map_eq_comap_of_inverse e.self_comp_symm e.symm_comp_self).symm | lemma | filter.comap_equiv_symm | order.filter | src/order/filter/basic.lean | [
"control.traversable.instances",
"data.set.finite",
"order.copy",
"tactic.monotonicity"
] | [
"filter"
] | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 | |
map_swap_eq_comap_swap {f : filter (α × β)} : prod.swap <$> f = comap prod.swap f | map_eq_comap_of_inverse prod.swap_swap_eq prod.swap_swap_eq | lemma | filter.map_swap_eq_comap_swap | order.filter | src/order/filter/basic.lean | [
"control.traversable.instances",
"data.set.finite",
"order.copy",
"tactic.monotonicity"
] | [
"filter",
"prod.swap",
"prod.swap_swap_eq"
] | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 | |
map_swap4_eq_comap {f : filter ((α × β) × (γ × δ))} :
map (λ p : (α × β) × (γ × δ), ((p.1.1, p.2.1), (p.1.2, p.2.2))) f =
comap (λ p : (α × γ) × (β × δ), ((p.1.1, p.2.1), (p.1.2, p.2.2))) f | map_eq_comap_of_inverse (funext $ λ ⟨⟨_, _⟩, ⟨_, _⟩⟩, rfl) (funext $ λ ⟨⟨_, _⟩, ⟨_, _⟩⟩, rfl) | lemma | filter.map_swap4_eq_comap | order.filter | src/order/filter/basic.lean | [
"control.traversable.instances",
"data.set.finite",
"order.copy",
"tactic.monotonicity"
] | [
"filter"
] | A useful lemma when dealing with uniformities. | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 |
le_map {f : filter α} {m : α → β} {g : filter β} (h : ∀ s ∈ f, m '' s ∈ g) :
g ≤ f.map m | λ s hs, mem_of_superset (h _ hs) $ image_preimage_subset _ _ | lemma | filter.le_map | order.filter | src/order/filter/basic.lean | [
"control.traversable.instances",
"data.set.finite",
"order.copy",
"tactic.monotonicity"
] | [
"filter"
] | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 | |
le_map_iff {f : filter α} {m : α → β} {g : filter β} : g ≤ f.map m ↔ ∀ s ∈ f, m '' s ∈ g | ⟨λ h s hs, h (image_mem_map hs), le_map⟩ | lemma | filter.le_map_iff | order.filter | src/order/filter/basic.lean | [
"control.traversable.instances",
"data.set.finite",
"order.copy",
"tactic.monotonicity"
] | [
"filter"
] | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 | |
push_pull (f : α → β) (F : filter α) (G : filter β) :
map f (F ⊓ comap f G) = map f F ⊓ G | begin
apply le_antisymm,
{ 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 },
{ rintro U ⟨V, V_in, W, ⟨Z, Z_in, hZ⟩, h⟩,
apply mem_inf_of_inter (image_mem_map V_in) Z_in,
calc
f '' V ∩ Z = f '' (V ∩ f ⁻¹' Z) : b... | lemma | filter.push_pull | order.filter | src/order/filter/basic.lean | [
"control.traversable.instances",
"data.set.finite",
"order.copy",
"tactic.monotonicity"
] | [
"filter",
"inf_le_inf_left"
] | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 | |
push_pull' (f : α → β) (F : filter α) (G : filter β) :
map f (comap f G ⊓ F) = G ⊓ map f F | by simp only [filter.push_pull, inf_comm] | lemma | filter.push_pull' | order.filter | src/order/filter/basic.lean | [
"control.traversable.instances",
"data.set.finite",
"order.copy",
"tactic.monotonicity"
] | [
"filter",
"filter.push_pull",
"inf_comm"
] | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 | |
principal_eq_map_coe_top (s : set α) : 𝓟 s = map (coe : s → α) ⊤ | by simp | lemma | filter.principal_eq_map_coe_top | order.filter | src/order/filter/basic.lean | [
"control.traversable.instances",
"data.set.finite",
"order.copy",
"tactic.monotonicity"
] | [] | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 | |
inf_principal_eq_bot_iff_comap {F : filter α} {s : set α} :
F ⊓ 𝓟 s = ⊥ ↔ comap (coe : s → α) F = ⊥ | by rw [principal_eq_map_coe_top s, ← filter.push_pull',inf_top_eq, map_eq_bot_iff] | lemma | filter.inf_principal_eq_bot_iff_comap | order.filter | src/order/filter/basic.lean | [
"control.traversable.instances",
"data.set.finite",
"order.copy",
"tactic.monotonicity"
] | [
"filter",
"filter.push_pull'",
"inf_top_eq",
"map_eq_bot_iff"
] | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 | |
singleton_mem_pure {a : α} : {a} ∈ (pure a : filter α) | mem_singleton a | lemma | filter.singleton_mem_pure | order.filter | src/order/filter/basic.lean | [
"control.traversable.instances",
"data.set.finite",
"order.copy",
"tactic.monotonicity"
] | [
"filter"
] | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 | |
pure_injective : injective (pure : α → filter α) | λ a b hab, (filter.ext_iff.1 hab {x | a = x}).1 rfl | lemma | filter.pure_injective | order.filter | src/order/filter/basic.lean | [
"control.traversable.instances",
"data.set.finite",
"order.copy",
"tactic.monotonicity"
] | [
"filter"
] | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 | |
pure_ne_bot {α : Type u} {a : α} : ne_bot (pure a) | ⟨mt empty_mem_iff_bot.2 $ not_mem_empty a⟩ | instance | filter.pure_ne_bot | order.filter | src/order/filter/basic.lean | [
"control.traversable.instances",
"data.set.finite",
"order.copy",
"tactic.monotonicity"
] | [] | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 | |
le_pure_iff {f : filter α} {a : α} : f ≤ pure a ↔ {a} ∈ f | by rw [← principal_singleton, le_principal_iff] | lemma | filter.le_pure_iff | order.filter | src/order/filter/basic.lean | [
"control.traversable.instances",
"data.set.finite",
"order.copy",
"tactic.monotonicity"
] | [
"filter"
] | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 | |
mem_seq_def {f : filter (α → β)} {g : filter α} {s : set β} :
s ∈ f.seq g ↔ (∃ u ∈ f, ∃ t ∈ g, ∀ x ∈ u, ∀ y ∈ t, (x : α → β) y ∈ s) | iff.rfl | lemma | filter.mem_seq_def | order.filter | src/order/filter/basic.lean | [
"control.traversable.instances",
"data.set.finite",
"order.copy",
"tactic.monotonicity"
] | [
"filter"
] | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 | |
mem_seq_iff {f : filter (α → β)} {g : filter α} {s : set β} :
s ∈ f.seq g ↔ (∃ u ∈ f, ∃ t ∈ g, set.seq u t ⊆ s) | by simp only [mem_seq_def, seq_subset, exists_prop, iff_self] | lemma | filter.mem_seq_iff | order.filter | src/order/filter/basic.lean | [
"control.traversable.instances",
"data.set.finite",
"order.copy",
"tactic.monotonicity"
] | [
"exists_prop",
"filter",
"set.seq"
] | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 | |
mem_map_seq_iff {f : filter α} {g : filter β} {m : α → β → γ} {s : set γ} :
s ∈ (f.map m).seq g ↔ (∃ t u, t ∈ g ∧ u ∈ f ∧ ∀ x ∈ u, ∀ y ∈ t, m x y ∈ s) | iff.intro
(λ ⟨t, ht, s, hs, hts⟩, ⟨s, m ⁻¹' t, hs, ht, λ a, hts _⟩)
(λ ⟨t, s, ht, hs, hts⟩, ⟨m '' s, image_mem_map hs, t, ht, λ f ⟨a, has, eq⟩, eq ▸ hts _ has⟩) | lemma | filter.mem_map_seq_iff | order.filter | src/order/filter/basic.lean | [
"control.traversable.instances",
"data.set.finite",
"order.copy",
"tactic.monotonicity"
] | [
"filter"
] | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 | |
seq_mem_seq {f : filter (α → β)} {g : filter α} {s : set (α → β)} {t : set α}
(hs : s ∈ f) (ht : t ∈ g) : s.seq t ∈ f.seq g | ⟨s, hs, t, ht, λ f hf a ha, ⟨f, hf, a, ha, rfl⟩⟩ | lemma | filter.seq_mem_seq | order.filter | src/order/filter/basic.lean | [
"control.traversable.instances",
"data.set.finite",
"order.copy",
"tactic.monotonicity"
] | [
"filter"
] | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 | |
le_seq {f : filter (α → β)} {g : filter α} {h : filter β}
(hh : ∀ t ∈ f, ∀ u ∈ g, set.seq t u ∈ h) : h ≤ seq f g | λ s ⟨t, ht, u, hu, hs⟩, mem_of_superset (hh _ ht _ hu) $
λ b ⟨m, hm, a, ha, eq⟩, eq ▸ hs _ hm _ ha | lemma | filter.le_seq | order.filter | src/order/filter/basic.lean | [
"control.traversable.instances",
"data.set.finite",
"order.copy",
"tactic.monotonicity"
] | [
"filter",
"set.seq"
] | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 | |
seq_mono {f₁ f₂ : filter (α → β)} {g₁ g₂ : filter α}
(hf : f₁ ≤ f₂) (hg : g₁ ≤ g₂) : f₁.seq g₁ ≤ f₂.seq g₂ | le_seq $ λ s hs t ht, seq_mem_seq (hf hs) (hg ht) | lemma | filter.seq_mono | order.filter | src/order/filter/basic.lean | [
"control.traversable.instances",
"data.set.finite",
"order.copy",
"tactic.monotonicity"
] | [
"filter"
] | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 | |
pure_seq_eq_map (g : α → β) (f : filter α) : seq (pure g) f = f.map g | begin
refine le_antisymm (le_map $ λ s hs, _) (le_seq $ λ s hs t ht, _),
{ rw ← singleton_seq, apply seq_mem_seq _ hs,
exact singleton_mem_pure },
{ refine sets_of_superset (map g f) (image_mem_map ht) _,
rintro b ⟨a, ha, rfl⟩, exact ⟨g, hs, a, ha, rfl⟩ }
end | lemma | filter.pure_seq_eq_map | order.filter | src/order/filter/basic.lean | [
"control.traversable.instances",
"data.set.finite",
"order.copy",
"tactic.monotonicity"
] | [
"filter"
] | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 | |
seq_pure (f : filter (α → β)) (a : α) : seq f (pure a) = map (λ g : α → β, g a) f | begin
refine le_antisymm (le_map $ λ s hs, _) (le_seq $ λ s hs t ht, _),
{ rw ← seq_singleton,
exact seq_mem_seq hs singleton_mem_pure },
{ refine sets_of_superset (map (λg:α→β, g a) f) (image_mem_map hs) _,
rintro b ⟨g, hg, rfl⟩, exact ⟨g, hg, a, ht, rfl⟩ }
end | lemma | filter.seq_pure | order.filter | src/order/filter/basic.lean | [
"control.traversable.instances",
"data.set.finite",
"order.copy",
"tactic.monotonicity"
] | [
"filter"
] | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 | |
seq_assoc (x : filter α) (g : filter (α → β)) (h : filter (β → γ)) :
seq h (seq g x) = seq (seq (map (∘) h) g) x | begin
refine le_antisymm (le_seq $ λ s hs t ht, _) (le_seq $ λ s hs t ht, _),
{ rcases mem_seq_iff.1 hs with ⟨u, hu, v, hv, hs⟩,
rcases mem_map_iff_exists_image.1 hu with ⟨w, hw, hu⟩,
refine mem_of_superset _
(set.seq_mono ((set.seq_mono hu subset.rfl).trans hs) subset.rfl),
rw ← set.seq_seq,
... | lemma | filter.seq_assoc | order.filter | src/order/filter/basic.lean | [
"control.traversable.instances",
"data.set.finite",
"order.copy",
"tactic.monotonicity"
] | [
"filter",
"set.seq_mono",
"set.seq_seq"
] | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 | |
prod_map_seq_comm (f : filter α) (g : filter β) :
(map prod.mk f).seq g = seq (map (λ b a, (a, b)) g) f | begin
refine le_antisymm (le_seq $ λ s hs t ht, _) (le_seq $ λ s hs t ht, _),
{ rcases mem_map_iff_exists_image.1 hs with ⟨u, hu, hs⟩,
refine mem_of_superset _ (set.seq_mono hs subset.rfl),
rw ← set.prod_image_seq_comm,
exact seq_mem_seq (image_mem_map ht) hu },
{ rcases mem_map_iff_exists_image.1 hs ... | lemma | filter.prod_map_seq_comm | order.filter | src/order/filter/basic.lean | [
"control.traversable.instances",
"data.set.finite",
"order.copy",
"tactic.monotonicity"
] | [
"filter",
"set.prod_image_seq_comm",
"set.seq_mono"
] | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 | |
{l} seq_eq_filter_seq {α β : Type l} (f : filter (α → β)) (g : filter α) :
f <*> g = seq f g | rfl | lemma | filter.seq_eq_filter_seq | order.filter | src/order/filter/basic.lean | [
"control.traversable.instances",
"data.set.finite",
"order.copy",
"tactic.monotonicity"
] | [
"filter"
] | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 | |
eventually_bind {f : filter α} {m : α → filter β} {p : β → Prop} :
(∀ᶠ y in bind f m, p y) ↔ ∀ᶠ x in f, ∀ᶠ y in m x, p y | iff.rfl | lemma | filter.eventually_bind | order.filter | src/order/filter/basic.lean | [
"control.traversable.instances",
"data.set.finite",
"order.copy",
"tactic.monotonicity"
] | [
"filter"
] | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 | |
eventually_eq_bind {f : filter α} {m : α → filter β} {g₁ g₂ : β → γ} :
(g₁ =ᶠ[bind f m] g₂) ↔ ∀ᶠ x in f, g₁ =ᶠ[m x] g₂ | iff.rfl | lemma | filter.eventually_eq_bind | order.filter | src/order/filter/basic.lean | [
"control.traversable.instances",
"data.set.finite",
"order.copy",
"tactic.monotonicity"
] | [
"filter"
] | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 | |
eventually_le_bind [has_le γ] {f : filter α} {m : α → filter β} {g₁ g₂ : β → γ} :
(g₁ ≤ᶠ[bind f m] g₂) ↔ ∀ᶠ x in f, g₁ ≤ᶠ[m x] g₂ | iff.rfl | lemma | filter.eventually_le_bind | order.filter | src/order/filter/basic.lean | [
"control.traversable.instances",
"data.set.finite",
"order.copy",
"tactic.monotonicity"
] | [
"filter"
] | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 | |
mem_bind' {s : set β} {f : filter α} {m : α → filter β} :
s ∈ bind f m ↔ {a | s ∈ m a} ∈ f | iff.rfl | lemma | filter.mem_bind' | order.filter | src/order/filter/basic.lean | [
"control.traversable.instances",
"data.set.finite",
"order.copy",
"tactic.monotonicity"
] | [
"filter"
] | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 | |
mem_bind {s : set β} {f : filter α} {m : α → filter β} :
s ∈ bind f m ↔ ∃ t ∈ f, ∀ x ∈ t, s ∈ m x | calc s ∈ bind f m ↔ {a | s ∈ m a} ∈ f : iff.rfl
... ↔ (∃ t ∈ f, t ⊆ {a | s ∈ m a}) : exists_mem_subset_iff.symm
... ↔ (∃ t ∈ f, ∀ x ∈ t, s ∈ m x) : iff.rfl | lemma | filter.mem_bind | order.filter | src/order/filter/basic.lean | [
"control.traversable.instances",
"data.set.finite",
"order.copy",
"tactic.monotonicity"
] | [
"filter",
"mem_bind"
] | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 | |
bind_le {f : filter α} {g : α → filter β} {l : filter β} (h : ∀ᶠ x in f, g x ≤ l) :
f.bind g ≤ l | join_le $ eventually_map.2 h | lemma | filter.bind_le | order.filter | src/order/filter/basic.lean | [
"control.traversable.instances",
"data.set.finite",
"order.copy",
"tactic.monotonicity"
] | [
"filter"
] | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 | |
bind_mono {f₁ f₂ : filter α} {g₁ g₂ : α → filter β} (hf : f₁ ≤ f₂)
(hg : g₁ ≤ᶠ[f₁] g₂) :
bind f₁ g₁ ≤ bind f₂ g₂ | begin
refine le_trans (λ s hs, _) (join_mono $ map_mono hf),
simp only [mem_join, mem_bind', mem_map] at hs ⊢,
filter_upwards [hg, hs] with _ hx hs using hx hs,
end | lemma | filter.bind_mono | order.filter | src/order/filter/basic.lean | [
"control.traversable.instances",
"data.set.finite",
"order.copy",
"tactic.monotonicity"
] | [
"filter",
"mem_map"
] | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 | |
bind_inf_principal {f : filter α} {g : α → filter β} {s : set β} :
f.bind (λ x, g x ⊓ 𝓟 s) = (f.bind g) ⊓ 𝓟 s | filter.ext $ λ s, by simp only [mem_bind, mem_inf_principal] | lemma | filter.bind_inf_principal | order.filter | src/order/filter/basic.lean | [
"control.traversable.instances",
"data.set.finite",
"order.copy",
"tactic.monotonicity"
] | [
"filter",
"filter.ext",
"mem_bind"
] | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 | |
sup_bind {f g : filter α} {h : α → filter β} :
bind (f ⊔ g) h = bind f h ⊔ bind g h | by simp only [bind, sup_join, map_sup, eq_self_iff_true] | lemma | filter.sup_bind | order.filter | src/order/filter/basic.lean | [
"control.traversable.instances",
"data.set.finite",
"order.copy",
"tactic.monotonicity"
] | [
"filter"
] | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 | |
principal_bind {s : set α} {f : α → filter β} :
(bind (𝓟 s) f) = (⨆ x ∈ s, f x) | show join (map f (𝓟 s)) = (⨆ x ∈ s, f x),
by simp only [Sup_image, join_principal_eq_Sup, map_principal, eq_self_iff_true] | lemma | filter.principal_bind | order.filter | src/order/filter/basic.lean | [
"control.traversable.instances",
"data.set.finite",
"order.copy",
"tactic.monotonicity"
] | [
"Sup_image",
"filter"
] | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 | |
sequence_mono :
∀ (as bs : list (filter α)), forall₂ (≤) as bs → sequence as ≤ sequence bs | | [] [] forall₂.nil := le_rfl
| (a :: as) (b :: bs) (forall₂.cons h hs) := seq_mono (map_mono h) (sequence_mono as bs hs) | lemma | filter.sequence_mono | order.filter | src/order/filter/basic.lean | [
"control.traversable.instances",
"data.set.finite",
"order.copy",
"tactic.monotonicity"
] | [
"filter",
"le_rfl",
"sequence"
] | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 | |
mem_traverse :
∀ (fs : list β') (us : list γ'),
forall₂ (λ b c, s c ∈ f b) fs us → traverse s us ∈ traverse f fs | | [] [] forall₂.nil := mem_pure.2 $ mem_singleton _
| (f :: fs) (u :: us) (forall₂.cons h hs) := seq_mem_seq (image_mem_map h) (mem_traverse fs us hs) | lemma | filter.mem_traverse | order.filter | src/order/filter/basic.lean | [
"control.traversable.instances",
"data.set.finite",
"order.copy",
"tactic.monotonicity"
] | [] | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 | |
mem_traverse_iff (fs : list β') (t : set (list α')) :
t ∈ traverse f fs ↔
(∃ us : list (set α'), forall₂ (λ b (s : set α'), s ∈ f b) fs us ∧ sequence us ⊆ t) | begin
split,
{ induction fs generalizing t,
case nil { simp only [sequence, mem_pure, imp_self, forall₂_nil_left_iff,
exists_eq_left, set.pure_def, singleton_subset_iff, traverse_nil] },
case cons : b fs ih t
{ intro ht,
rcases mem_seq_iff.1 ht with ⟨u, hu, v, hv, ht⟩,
rcases mem_map_i... | lemma | filter.mem_traverse_iff | order.filter | src/order/filter/basic.lean | [
"control.traversable.instances",
"data.set.finite",
"order.copy",
"tactic.monotonicity"
] | [
"exists_eq_left",
"ih",
"imp_self",
"sequence",
"set.pure_def",
"set.seq_mono"
] | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 | |
tendsto (f : α → β) (l₁ : filter α) (l₂ : filter β) | l₁.map f ≤ l₂ | def | filter.tendsto | order.filter | src/order/filter/basic.lean | [
"control.traversable.instances",
"data.set.finite",
"order.copy",
"tactic.monotonicity"
] | [
"filter"
] | `tendsto` is the generic "limit of a function" predicate.
`tendsto f l₁ l₂` asserts that for every `l₂` neighborhood `a`,
the `f`-preimage of `a` is an `l₁` neighborhood. | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 |
tendsto_def {f : α → β} {l₁ : filter α} {l₂ : filter β} :
tendsto f l₁ l₂ ↔ ∀ s ∈ l₂, f ⁻¹' s ∈ l₁ | iff.rfl | lemma | filter.tendsto_def | order.filter | src/order/filter/basic.lean | [
"control.traversable.instances",
"data.set.finite",
"order.copy",
"tactic.monotonicity"
] | [
"filter"
] | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 | |
tendsto_iff_eventually {f : α → β} {l₁ : filter α} {l₂ : filter β} :
tendsto f l₁ l₂ ↔ ∀ ⦃p : β → Prop⦄, (∀ᶠ y in l₂, p y) → ∀ᶠ x in l₁, p (f x) | iff.rfl | lemma | filter.tendsto_iff_eventually | order.filter | src/order/filter/basic.lean | [
"control.traversable.instances",
"data.set.finite",
"order.copy",
"tactic.monotonicity"
] | [
"filter"
] | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 | |
tendsto.eventually {f : α → β} {l₁ : filter α} {l₂ : filter β} {p : β → Prop}
(hf : tendsto f l₁ l₂) (h : ∀ᶠ y in l₂, p y) :
∀ᶠ x in l₁, p (f x) | hf h | lemma | filter.tendsto.eventually | order.filter | src/order/filter/basic.lean | [
"control.traversable.instances",
"data.set.finite",
"order.copy",
"tactic.monotonicity"
] | [
"filter"
] | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 | |
tendsto.frequently {f : α → β} {l₁ : filter α} {l₂ : filter β} {p : β → Prop}
(hf : tendsto f l₁ l₂) (h : ∃ᶠ x in l₁, p (f x)) :
∃ᶠ y in l₂, p y | mt hf.eventually h | lemma | filter.tendsto.frequently | order.filter | src/order/filter/basic.lean | [
"control.traversable.instances",
"data.set.finite",
"order.copy",
"tactic.monotonicity"
] | [
"filter"
] | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 | |
tendsto.frequently_map {l₁ : filter α} {l₂ : filter β} {p : α → Prop} {q : β → Prop}
(f : α → β) (c : filter.tendsto f l₁ l₂) (w : ∀ x, p x → q (f x)) (h : ∃ᶠ x in l₁, p x) :
∃ᶠ y in l₂, q y | c.frequently (h.mono w) | lemma | filter.tendsto.frequently_map | order.filter | src/order/filter/basic.lean | [
"control.traversable.instances",
"data.set.finite",
"order.copy",
"tactic.monotonicity"
] | [
"filter",
"filter.tendsto"
] | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 | |
tendsto_bot {f : α → β} {l : filter β} : tendsto f ⊥ l | by simp [tendsto] | lemma | filter.tendsto_bot | order.filter | src/order/filter/basic.lean | [
"control.traversable.instances",
"data.set.finite",
"order.copy",
"tactic.monotonicity"
] | [
"filter"
] | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 | |
tendsto_top {f : α → β} {l : filter α} : tendsto f l ⊤ | le_top | lemma | filter.tendsto_top | order.filter | src/order/filter/basic.lean | [
"control.traversable.instances",
"data.set.finite",
"order.copy",
"tactic.monotonicity"
] | [
"filter",
"le_top"
] | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 | |
le_map_of_right_inverse {mab : α → β} {mba : β → α} {f : filter α} {g : filter β}
(h₁ : mab ∘ mba =ᶠ[g] id) (h₂ : tendsto mba g f) :
g ≤ map mab f | by { rw [← @map_id _ g, ← map_congr h₁, ← map_map], exact map_mono h₂ } | lemma | filter.le_map_of_right_inverse | order.filter | src/order/filter/basic.lean | [
"control.traversable.instances",
"data.set.finite",
"order.copy",
"tactic.monotonicity"
] | [
"filter",
"map_congr",
"map_id"
] | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 | |
tendsto_of_is_empty [is_empty α] {f : α → β} {la : filter α} {lb : filter β} :
tendsto f la lb | by simp only [filter_eq_bot_of_is_empty la, tendsto_bot] | lemma | filter.tendsto_of_is_empty | order.filter | src/order/filter/basic.lean | [
"control.traversable.instances",
"data.set.finite",
"order.copy",
"tactic.monotonicity"
] | [
"filter",
"is_empty"
] | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 | |
eventually_eq_of_left_inv_of_right_inv {f : α → β} {g₁ g₂ : β → α} {fa : filter α}
{fb : filter β} (hleft : ∀ᶠ x in fa, g₁ (f x) = x) (hright : ∀ᶠ y in fb, f (g₂ y) = y)
(htendsto : tendsto g₂ fb fa) :
g₁ =ᶠ[fb] g₂ | (htendsto.eventually hleft).mp $ hright.mono $ λ y hr hl, (congr_arg g₁ hr.symm).trans hl | lemma | filter.eventually_eq_of_left_inv_of_right_inv | order.filter | src/order/filter/basic.lean | [
"control.traversable.instances",
"data.set.finite",
"order.copy",
"tactic.monotonicity"
] | [
"filter"
] | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 | |
tendsto_iff_comap {f : α → β} {l₁ : filter α} {l₂ : filter β} :
tendsto f l₁ l₂ ↔ l₁ ≤ l₂.comap f | map_le_iff_le_comap | lemma | filter.tendsto_iff_comap | order.filter | src/order/filter/basic.lean | [
"control.traversable.instances",
"data.set.finite",
"order.copy",
"tactic.monotonicity"
] | [
"filter"
] | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 | |
tendsto.disjoint {f : α → β} {la₁ la₂ : filter α} {lb₁ lb₂ : filter β}
(h₁ : tendsto f la₁ lb₁) (hd : disjoint lb₁ lb₂) (h₂ : tendsto f la₂ lb₂) :
disjoint la₁ la₂ | (disjoint_comap hd).mono h₁.le_comap h₂.le_comap | lemma | filter.tendsto.disjoint | order.filter | src/order/filter/basic.lean | [
"control.traversable.instances",
"data.set.finite",
"order.copy",
"tactic.monotonicity"
] | [
"disjoint",
"filter"
] | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 | |
tendsto_congr' {f₁ f₂ : α → β} {l₁ : filter α} {l₂ : filter β} (hl : f₁ =ᶠ[l₁] f₂) :
tendsto f₁ l₁ l₂ ↔ tendsto f₂ l₁ l₂ | by rw [tendsto, tendsto, map_congr hl] | lemma | filter.tendsto_congr' | order.filter | src/order/filter/basic.lean | [
"control.traversable.instances",
"data.set.finite",
"order.copy",
"tactic.monotonicity"
] | [
"filter",
"map_congr"
] | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 | |
tendsto.congr' {f₁ f₂ : α → β} {l₁ : filter α} {l₂ : filter β}
(hl : f₁ =ᶠ[l₁] f₂) (h : tendsto f₁ l₁ l₂) : tendsto f₂ l₁ l₂ | (tendsto_congr' hl).1 h | lemma | filter.tendsto.congr' | order.filter | src/order/filter/basic.lean | [
"control.traversable.instances",
"data.set.finite",
"order.copy",
"tactic.monotonicity"
] | [
"filter"
] | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 | |
tendsto_congr {f₁ f₂ : α → β} {l₁ : filter α} {l₂ : filter β}
(h : ∀ x, f₁ x = f₂ x) : tendsto f₁ l₁ l₂ ↔ tendsto f₂ l₁ l₂ | tendsto_congr' (univ_mem' h) | theorem | filter.tendsto_congr | order.filter | src/order/filter/basic.lean | [
"control.traversable.instances",
"data.set.finite",
"order.copy",
"tactic.monotonicity"
] | [
"filter"
] | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 | |
tendsto.congr {f₁ f₂ : α → β} {l₁ : filter α} {l₂ : filter β}
(h : ∀ x, f₁ x = f₂ x) : tendsto f₁ l₁ l₂ → tendsto f₂ l₁ l₂ | (tendsto_congr h).1 | theorem | filter.tendsto.congr | order.filter | src/order/filter/basic.lean | [
"control.traversable.instances",
"data.set.finite",
"order.copy",
"tactic.monotonicity"
] | [
"filter"
] | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 | |
tendsto_id' {x y : filter α} : tendsto id x y ↔ x ≤ y | iff.rfl | lemma | filter.tendsto_id' | order.filter | src/order/filter/basic.lean | [
"control.traversable.instances",
"data.set.finite",
"order.copy",
"tactic.monotonicity"
] | [
"filter"
] | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 | |
tendsto_id {x : filter α} : tendsto id x x | le_refl x | lemma | filter.tendsto_id | order.filter | src/order/filter/basic.lean | [
"control.traversable.instances",
"data.set.finite",
"order.copy",
"tactic.monotonicity"
] | [
"filter"
] | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 | |
tendsto.comp {f : α → β} {g : β → γ} {x : filter α} {y : filter β} {z : filter γ}
(hg : tendsto g y z) (hf : tendsto f x y) : tendsto (g ∘ f) x z | λ s hs, hf (hg hs) | lemma | filter.tendsto.comp | order.filter | src/order/filter/basic.lean | [
"control.traversable.instances",
"data.set.finite",
"order.copy",
"tactic.monotonicity"
] | [
"filter"
] | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 | |
tendsto.mono_left {f : α → β} {x y : filter α} {z : filter β}
(hx : tendsto f x z) (h : y ≤ x) : tendsto f y z | (map_mono h).trans hx | lemma | filter.tendsto.mono_left | order.filter | src/order/filter/basic.lean | [
"control.traversable.instances",
"data.set.finite",
"order.copy",
"tactic.monotonicity"
] | [
"filter"
] | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 | |
tendsto.mono_right {f : α → β} {x : filter α} {y z : filter β}
(hy : tendsto f x y) (hz : y ≤ z) : tendsto f x z | le_trans hy hz | lemma | filter.tendsto.mono_right | order.filter | src/order/filter/basic.lean | [
"control.traversable.instances",
"data.set.finite",
"order.copy",
"tactic.monotonicity"
] | [
"filter"
] | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 | |
tendsto.ne_bot {f : α → β} {x : filter α} {y : filter β} (h : tendsto f x y) [hx : ne_bot x] :
ne_bot y | (hx.map _).mono h | lemma | filter.tendsto.ne_bot | order.filter | src/order/filter/basic.lean | [
"control.traversable.instances",
"data.set.finite",
"order.copy",
"tactic.monotonicity"
] | [
"filter"
] | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 | |
tendsto_map {f : α → β} {x : filter α} : tendsto f x (map f x) | le_refl (map f x) | lemma | filter.tendsto_map | order.filter | src/order/filter/basic.lean | [
"control.traversable.instances",
"data.set.finite",
"order.copy",
"tactic.monotonicity"
] | [
"filter"
] | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 | |
tendsto_map' {f : β → γ} {g : α → β} {x : filter α} {y : filter γ}
(h : tendsto (f ∘ g) x y) : tendsto f (map g x) y | by rwa [tendsto, map_map] | lemma | filter.tendsto_map' | order.filter | src/order/filter/basic.lean | [
"control.traversable.instances",
"data.set.finite",
"order.copy",
"tactic.monotonicity"
] | [
"filter"
] | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 | |
tendsto_map'_iff {f : β → γ} {g : α → β} {x : filter α} {y : filter γ} :
tendsto f (map g x) y ↔ tendsto (f ∘ g) x y | by { rw [tendsto, map_map], refl } | lemma | filter.tendsto_map'_iff | order.filter | src/order/filter/basic.lean | [
"control.traversable.instances",
"data.set.finite",
"order.copy",
"tactic.monotonicity"
] | [
"filter"
] | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 | |
tendsto_comap {f : α → β} {x : filter β} : tendsto f (comap f x) x | map_comap_le | lemma | filter.tendsto_comap | order.filter | src/order/filter/basic.lean | [
"control.traversable.instances",
"data.set.finite",
"order.copy",
"tactic.monotonicity"
] | [
"filter"
] | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 | |
tendsto_comap_iff {f : α → β} {g : β → γ} {a : filter α} {c : filter γ} :
tendsto f a (c.comap g) ↔ tendsto (g ∘ f) a c | ⟨λ h, tendsto_comap.comp h, λ h, map_le_iff_le_comap.mp $ by rwa [map_map]⟩ | lemma | filter.tendsto_comap_iff | order.filter | src/order/filter/basic.lean | [
"control.traversable.instances",
"data.set.finite",
"order.copy",
"tactic.monotonicity"
] | [
"filter"
] | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 | |
tendsto_comap'_iff {m : α → β} {f : filter α} {g : filter β} {i : γ → α}
(h : range i ∈ f) : tendsto (m ∘ i) (comap i f) g ↔ tendsto m f g | by { rw [tendsto, ← map_compose], simp only [(∘), map_comap_of_mem h, tendsto] } | lemma | filter.tendsto_comap'_iff | order.filter | src/order/filter/basic.lean | [
"control.traversable.instances",
"data.set.finite",
"order.copy",
"tactic.monotonicity"
] | [
"filter"
] | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 | |
tendsto.of_tendsto_comp {f : α → β} {g : β → γ} {a : filter α} {b : filter β} {c : filter γ}
(hfg : tendsto (g ∘ f) a c) (hg : comap g c ≤ b) :
tendsto f a b | begin
rw tendsto_iff_comap at hfg ⊢,
calc a ≤ comap (g ∘ f) c : hfg
... ≤ comap f b : by simpa [comap_comap] using comap_mono hg
end | lemma | filter.tendsto.of_tendsto_comp | order.filter | src/order/filter/basic.lean | [
"control.traversable.instances",
"data.set.finite",
"order.copy",
"tactic.monotonicity"
] | [
"filter"
] | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 | |
comap_eq_of_inverse {f : filter α} {g : filter β} {φ : α → β} (ψ : β → α)
(eq : ψ ∘ φ = id) (hφ : tendsto φ f g) (hψ : tendsto ψ g f) : comap φ g = f | begin
refine ((comap_mono $ map_le_iff_le_comap.1 hψ).trans _).antisymm (map_le_iff_le_comap.1 hφ),
rw [comap_comap, eq, comap_id],
exact le_rfl
end | lemma | filter.comap_eq_of_inverse | order.filter | src/order/filter/basic.lean | [
"control.traversable.instances",
"data.set.finite",
"order.copy",
"tactic.monotonicity"
] | [
"filter",
"le_rfl"
] | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 | |
map_eq_of_inverse {f : filter α} {g : filter β} {φ : α → β} (ψ : β → α)
(eq : φ ∘ ψ = id) (hφ : tendsto φ f g) (hψ : tendsto ψ g f) : map φ f = g | begin
refine le_antisymm hφ (le_trans _ (map_mono hψ)),
rw [map_map, eq, map_id],
exact le_rfl
end | lemma | filter.map_eq_of_inverse | order.filter | src/order/filter/basic.lean | [
"control.traversable.instances",
"data.set.finite",
"order.copy",
"tactic.monotonicity"
] | [
"filter",
"le_rfl",
"map_id"
] | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 | |
tendsto_inf {f : α → β} {x : filter α} {y₁ y₂ : filter β} :
tendsto f x (y₁ ⊓ y₂) ↔ tendsto f x y₁ ∧ tendsto f x y₂ | by simp only [tendsto, le_inf_iff, iff_self] | lemma | filter.tendsto_inf | order.filter | src/order/filter/basic.lean | [
"control.traversable.instances",
"data.set.finite",
"order.copy",
"tactic.monotonicity"
] | [
"filter",
"le_inf_iff"
] | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.