fact stringlengths 6 3.84k | type stringclasses 11 values | library stringclasses 32 values | imports listlengths 1 14 | filename stringlengths 20 95 | symbolic_name stringlengths 1 90 | docstring stringlengths 7 20k ⌀ |
|---|---|---|---|---|---|---|
Definable₁.mk {f : ZFSet.{u} → ZFSet.{u}}
(out : PSet.{u} → PSet.{u}) (mk_out : ∀ x, ⟦out x⟧ = f ⟦x⟧) :
Definable₁ f where
out xs := out (xs 0)
mk_out xs := mk_out (xs 0) | abbrev | SetTheory | [
"Mathlib.Data.Fin.VecNotation",
"Mathlib.Data.SetLike.Basic",
"Mathlib.Logic.Small.Basic",
"Mathlib.SetTheory.ZFC.PSet"
] | Mathlib/SetTheory/ZFC/Basic.lean | Definable₁.mk | A simpler constructor for `ZFSet.Definable₁`. |
Definable₁.out (f : ZFSet.{u} → ZFSet.{u}) [Definable₁ f] :
PSet.{u} → PSet.{u} :=
fun x ↦ Definable.out (fun s ↦ f (s 0)) ![x] | abbrev | SetTheory | [
"Mathlib.Data.Fin.VecNotation",
"Mathlib.Data.SetLike.Basic",
"Mathlib.Logic.Small.Basic",
"Mathlib.SetTheory.ZFC.PSet"
] | Mathlib/SetTheory/ZFC/Basic.lean | Definable₁.out | Turns a unary definable function into a unary `PSet` function. |
Definable₁.mk_out {f : ZFSet.{u} → ZFSet.{u}} [Definable₁ f]
{x : PSet} :
.mk (out f x) = f (.mk x) :=
Definable.mk_out ![x] | lemma | SetTheory | [
"Mathlib.Data.Fin.VecNotation",
"Mathlib.Data.SetLike.Basic",
"Mathlib.Logic.Small.Basic",
"Mathlib.SetTheory.ZFC.PSet"
] | Mathlib/SetTheory/ZFC/Basic.lean | Definable₁.mk_out | null |
Definable₂ (f : ZFSet.{u} → ZFSet.{u} → ZFSet.{u}) := Definable 2 (fun s ↦ f (s 0) (s 1)) | abbrev | SetTheory | [
"Mathlib.Data.Fin.VecNotation",
"Mathlib.Data.SetLike.Basic",
"Mathlib.Logic.Small.Basic",
"Mathlib.SetTheory.ZFC.PSet"
] | Mathlib/SetTheory/ZFC/Basic.lean | Definable₂ | An abbrev of `ZFSet.Definable` for binary functions. |
Definable₂.mk {f : ZFSet.{u} → ZFSet.{u} → ZFSet.{u}}
(out : PSet.{u} → PSet.{u} → PSet.{u}) (mk_out : ∀ x y, ⟦out x y⟧ = f ⟦x⟧ ⟦y⟧) :
Definable₂ f where
out xs := out (xs 0) (xs 1)
mk_out xs := mk_out (xs 0) (xs 1) | abbrev | SetTheory | [
"Mathlib.Data.Fin.VecNotation",
"Mathlib.Data.SetLike.Basic",
"Mathlib.Logic.Small.Basic",
"Mathlib.SetTheory.ZFC.PSet"
] | Mathlib/SetTheory/ZFC/Basic.lean | Definable₂.mk | A simpler constructor for `ZFSet.Definable₂`. |
Definable₂.out (f : ZFSet.{u} → ZFSet.{u} → ZFSet.{u}) [Definable₂ f] :
PSet.{u} → PSet.{u} → PSet.{u} :=
fun x y ↦ Definable.out (fun s ↦ f (s 0) (s 1)) ![x, y] | abbrev | SetTheory | [
"Mathlib.Data.Fin.VecNotation",
"Mathlib.Data.SetLike.Basic",
"Mathlib.Logic.Small.Basic",
"Mathlib.SetTheory.ZFC.PSet"
] | Mathlib/SetTheory/ZFC/Basic.lean | Definable₂.out | Turns a binary definable function into a binary `PSet` function. |
Definable₂.mk_out {f : ZFSet.{u} → ZFSet.{u} → ZFSet.{u}} [Definable₂ f]
{x y : PSet} :
.mk (out f x y) = f (.mk x) (.mk y) :=
Definable.mk_out ![x, y] | lemma | SetTheory | [
"Mathlib.Data.Fin.VecNotation",
"Mathlib.Data.SetLike.Basic",
"Mathlib.Logic.Small.Basic",
"Mathlib.SetTheory.ZFC.PSet"
] | Mathlib/SetTheory/ZFC/Basic.lean | Definable₂.mk_out | null |
Definable.out_equiv {n} (f : (Fin n → ZFSet.{u}) → ZFSet.{u}) [Definable n f]
{xs ys : Fin n → PSet} (h : ∀ i, xs i ≈ ys i) :
out f xs ≈ out f ys := by
rw [← Quotient.eq_iff_equiv, mk_eq, mk_eq, mk_out, mk_out]
exact congrArg _ (funext fun i ↦ Quotient.sound (h i)) | lemma | SetTheory | [
"Mathlib.Data.Fin.VecNotation",
"Mathlib.Data.SetLike.Basic",
"Mathlib.Logic.Small.Basic",
"Mathlib.SetTheory.ZFC.PSet"
] | Mathlib/SetTheory/ZFC/Basic.lean | Definable.out_equiv | null |
Definable₁.out_equiv (f : ZFSet.{u} → ZFSet.{u}) [Definable₁ f]
{x y : PSet} (h : x ≈ y) :
out f x ≈ out f y :=
Definable.out_equiv _ (by simp [h]) | lemma | SetTheory | [
"Mathlib.Data.Fin.VecNotation",
"Mathlib.Data.SetLike.Basic",
"Mathlib.Logic.Small.Basic",
"Mathlib.SetTheory.ZFC.PSet"
] | Mathlib/SetTheory/ZFC/Basic.lean | Definable₁.out_equiv | null |
Definable₂.out_equiv (f : ZFSet.{u} → ZFSet.{u} → ZFSet.{u}) [Definable₂ f]
{x₁ y₁ x₂ y₂ : PSet} (h₁ : x₁ ≈ y₁) (h₂ : x₂ ≈ y₂) :
out f x₁ x₂ ≈ out f y₁ y₂ :=
Definable.out_equiv _ (by simp [Fin.forall_fin_succ, h₁, h₂]) | lemma | SetTheory | [
"Mathlib.Data.Fin.VecNotation",
"Mathlib.Data.SetLike.Basic",
"Mathlib.Logic.Small.Basic",
"Mathlib.SetTheory.ZFC.PSet"
] | Mathlib/SetTheory/ZFC/Basic.lean | Definable₂.out_equiv | null |
noncomputable allZFSetDefinable {n} (F : (Fin n → ZFSet.{u}) → ZFSet.{u}) : Definable n F where
out xs := (F (mk <| xs ·)).out | def | SetTheory | [
"Mathlib.Data.Fin.VecNotation",
"Mathlib.Data.SetLike.Basic",
"Mathlib.Logic.Small.Basic",
"Mathlib.SetTheory.ZFC.PSet"
] | Mathlib/SetTheory/ZFC/Basic.lean | allZFSetDefinable | All functions are classically definable. |
eq {x y : PSet} : mk x = mk y ↔ Equiv x y :=
Quotient.eq | theorem | SetTheory | [
"Mathlib.Data.Fin.VecNotation",
"Mathlib.Data.SetLike.Basic",
"Mathlib.Logic.Small.Basic",
"Mathlib.SetTheory.ZFC.PSet"
] | Mathlib/SetTheory/ZFC/Basic.lean | eq | null |
sound {x y : PSet} (h : PSet.Equiv x y) : mk x = mk y :=
Quotient.sound h | theorem | SetTheory | [
"Mathlib.Data.Fin.VecNotation",
"Mathlib.Data.SetLike.Basic",
"Mathlib.Logic.Small.Basic",
"Mathlib.SetTheory.ZFC.PSet"
] | Mathlib/SetTheory/ZFC/Basic.lean | sound | null |
exact {x y : PSet} : mk x = mk y → PSet.Equiv x y :=
Quotient.exact | theorem | SetTheory | [
"Mathlib.Data.Fin.VecNotation",
"Mathlib.Data.SetLike.Basic",
"Mathlib.Logic.Small.Basic",
"Mathlib.SetTheory.ZFC.PSet"
] | Mathlib/SetTheory/ZFC/Basic.lean | exact | null |
protected Mem : ZFSet → ZFSet → Prop :=
Quotient.lift₂ (· ∈ ·) fun _ _ _ _ hx hy =>
propext ((Mem.congr_left hx).trans (Mem.congr_right hy)) | def | SetTheory | [
"Mathlib.Data.Fin.VecNotation",
"Mathlib.Data.SetLike.Basic",
"Mathlib.Logic.Small.Basic",
"Mathlib.SetTheory.ZFC.PSet"
] | Mathlib/SetTheory/ZFC/Basic.lean | Mem | The membership relation for ZFC sets is inherited from the membership relation for pre-sets. |
@[simp]
mk_mem_iff {x y : PSet} : mk x ∈ mk y ↔ x ∈ y :=
Iff.rfl | theorem | SetTheory | [
"Mathlib.Data.Fin.VecNotation",
"Mathlib.Data.SetLike.Basic",
"Mathlib.Logic.Small.Basic",
"Mathlib.SetTheory.ZFC.PSet"
] | Mathlib/SetTheory/ZFC/Basic.lean | mk_mem_iff | null |
toSet (u : ZFSet.{u}) : Set ZFSet.{u} :=
{ x | x ∈ u }
@[simp] | def | SetTheory | [
"Mathlib.Data.Fin.VecNotation",
"Mathlib.Data.SetLike.Basic",
"Mathlib.Logic.Small.Basic",
"Mathlib.SetTheory.ZFC.PSet"
] | Mathlib/SetTheory/ZFC/Basic.lean | toSet | Convert a ZFC set into a `Set` of ZFC sets |
mem_toSet (a u : ZFSet.{u}) : a ∈ u.toSet ↔ a ∈ u :=
Iff.rfl | theorem | SetTheory | [
"Mathlib.Data.Fin.VecNotation",
"Mathlib.Data.SetLike.Basic",
"Mathlib.Logic.Small.Basic",
"Mathlib.SetTheory.ZFC.PSet"
] | Mathlib/SetTheory/ZFC/Basic.lean | mem_toSet | null |
small_toSet (x : ZFSet.{u}) : Small.{u} x.toSet :=
Quotient.inductionOn x fun a => by
let f : a.Type → (mk a).toSet := fun i => ⟨mk <| a.Func i, func_mem a i⟩
suffices Function.Surjective f by exact small_of_surjective this
rintro ⟨y, hb⟩
induction y using Quotient.inductionOn
obtain ⟨i, h⟩ := hb
exact ⟨i, Subtype.coe_injective (Quotient.sound h.symm)⟩ | instance | SetTheory | [
"Mathlib.Data.Fin.VecNotation",
"Mathlib.Data.SetLike.Basic",
"Mathlib.Logic.Small.Basic",
"Mathlib.SetTheory.ZFC.PSet"
] | Mathlib/SetTheory/ZFC/Basic.lean | small_toSet | null |
protected Nonempty (u : ZFSet) : Prop :=
u.toSet.Nonempty | def | SetTheory | [
"Mathlib.Data.Fin.VecNotation",
"Mathlib.Data.SetLike.Basic",
"Mathlib.Logic.Small.Basic",
"Mathlib.SetTheory.ZFC.PSet"
] | Mathlib/SetTheory/ZFC/Basic.lean | Nonempty | A nonempty set is one that contains some element. |
nonempty_def (u : ZFSet) : u.Nonempty ↔ ∃ x, x ∈ u :=
Iff.rfl | theorem | SetTheory | [
"Mathlib.Data.Fin.VecNotation",
"Mathlib.Data.SetLike.Basic",
"Mathlib.Logic.Small.Basic",
"Mathlib.SetTheory.ZFC.PSet"
] | Mathlib/SetTheory/ZFC/Basic.lean | nonempty_def | null |
nonempty_of_mem {x u : ZFSet} (h : x ∈ u) : u.Nonempty :=
⟨x, h⟩
@[simp] | theorem | SetTheory | [
"Mathlib.Data.Fin.VecNotation",
"Mathlib.Data.SetLike.Basic",
"Mathlib.Logic.Small.Basic",
"Mathlib.SetTheory.ZFC.PSet"
] | Mathlib/SetTheory/ZFC/Basic.lean | nonempty_of_mem | null |
nonempty_toSet_iff {u : ZFSet} : u.toSet.Nonempty ↔ u.Nonempty :=
Iff.rfl | theorem | SetTheory | [
"Mathlib.Data.Fin.VecNotation",
"Mathlib.Data.SetLike.Basic",
"Mathlib.Logic.Small.Basic",
"Mathlib.SetTheory.ZFC.PSet"
] | Mathlib/SetTheory/ZFC/Basic.lean | nonempty_toSet_iff | null |
protected Subset (x y : ZFSet.{u}) :=
∀ ⦃z⦄, z ∈ x → z ∈ y | def | SetTheory | [
"Mathlib.Data.Fin.VecNotation",
"Mathlib.Data.SetLike.Basic",
"Mathlib.Logic.Small.Basic",
"Mathlib.SetTheory.ZFC.PSet"
] | Mathlib/SetTheory/ZFC/Basic.lean | Subset | `x ⊆ y` as ZFC sets means that all members of `x` are members of `y`. |
hasSubset : HasSubset ZFSet :=
⟨ZFSet.Subset⟩ | instance | SetTheory | [
"Mathlib.Data.Fin.VecNotation",
"Mathlib.Data.SetLike.Basic",
"Mathlib.Logic.Small.Basic",
"Mathlib.SetTheory.ZFC.PSet"
] | Mathlib/SetTheory/ZFC/Basic.lean | hasSubset | null |
subset_def {x y : ZFSet.{u}} : x ⊆ y ↔ ∀ ⦃z⦄, z ∈ x → z ∈ y :=
Iff.rfl | theorem | SetTheory | [
"Mathlib.Data.Fin.VecNotation",
"Mathlib.Data.SetLike.Basic",
"Mathlib.Logic.Small.Basic",
"Mathlib.SetTheory.ZFC.PSet"
] | Mathlib/SetTheory/ZFC/Basic.lean | subset_def | null |
@[simp]
subset_iff : ∀ {x y : PSet}, mk x ⊆ mk y ↔ x ⊆ y
| ⟨_, A⟩, ⟨_, _⟩ =>
⟨fun h a => @h ⟦A a⟧ (Mem.mk A a), fun h z =>
Quotient.inductionOn z fun _ ⟨a, za⟩ =>
let ⟨b, ab⟩ := h a
⟨b, za.trans ab⟩⟩
@[simp] | theorem | SetTheory | [
"Mathlib.Data.Fin.VecNotation",
"Mathlib.Data.SetLike.Basic",
"Mathlib.Logic.Small.Basic",
"Mathlib.SetTheory.ZFC.PSet"
] | Mathlib/SetTheory/ZFC/Basic.lean | subset_iff | null |
toSet_subset_iff {x y : ZFSet} : x.toSet ⊆ y.toSet ↔ x ⊆ y := by
simp [subset_def, Set.subset_def]
@[ext] | theorem | SetTheory | [
"Mathlib.Data.Fin.VecNotation",
"Mathlib.Data.SetLike.Basic",
"Mathlib.Logic.Small.Basic",
"Mathlib.SetTheory.ZFC.PSet"
] | Mathlib/SetTheory/ZFC/Basic.lean | toSet_subset_iff | null |
ext {x y : ZFSet.{u}} : (∀ z : ZFSet.{u}, z ∈ x ↔ z ∈ y) → x = y :=
Quotient.inductionOn₂ x y fun _ _ h => Quotient.sound (Mem.ext fun w => h ⟦w⟧) | theorem | SetTheory | [
"Mathlib.Data.Fin.VecNotation",
"Mathlib.Data.SetLike.Basic",
"Mathlib.Logic.Small.Basic",
"Mathlib.SetTheory.ZFC.PSet"
] | Mathlib/SetTheory/ZFC/Basic.lean | ext | null |
toSet_injective : Function.Injective toSet := fun _ _ h => ext <| Set.ext_iff.1 h
@[simp] | theorem | SetTheory | [
"Mathlib.Data.Fin.VecNotation",
"Mathlib.Data.SetLike.Basic",
"Mathlib.Logic.Small.Basic",
"Mathlib.SetTheory.ZFC.PSet"
] | Mathlib/SetTheory/ZFC/Basic.lean | toSet_injective | null |
toSet_inj {x y : ZFSet} : x.toSet = y.toSet ↔ x = y :=
toSet_injective.eq_iff | theorem | SetTheory | [
"Mathlib.Data.Fin.VecNotation",
"Mathlib.Data.SetLike.Basic",
"Mathlib.Logic.Small.Basic",
"Mathlib.SetTheory.ZFC.PSet"
] | Mathlib/SetTheory/ZFC/Basic.lean | toSet_inj | null |
@[simp]
le_def (x y : ZFSet) : x ≤ y ↔ x ⊆ y :=
Iff.rfl
@[simp] | theorem | SetTheory | [
"Mathlib.Data.Fin.VecNotation",
"Mathlib.Data.SetLike.Basic",
"Mathlib.Logic.Small.Basic",
"Mathlib.SetTheory.ZFC.PSet"
] | Mathlib/SetTheory/ZFC/Basic.lean | le_def | null |
lt_def (x y : ZFSet) : x < y ↔ x ⊂ y :=
Iff.rfl | theorem | SetTheory | [
"Mathlib.Data.Fin.VecNotation",
"Mathlib.Data.SetLike.Basic",
"Mathlib.Logic.Small.Basic",
"Mathlib.SetTheory.ZFC.PSet"
] | Mathlib/SetTheory/ZFC/Basic.lean | lt_def | null |
protected empty : ZFSet :=
mk ∅ | def | SetTheory | [
"Mathlib.Data.Fin.VecNotation",
"Mathlib.Data.SetLike.Basic",
"Mathlib.Logic.Small.Basic",
"Mathlib.SetTheory.ZFC.PSet"
] | Mathlib/SetTheory/ZFC/Basic.lean | empty | The empty ZFC set |
@[simp]
notMem_empty (x) : x ∉ (∅ : ZFSet.{u}) :=
Quotient.inductionOn x PSet.notMem_empty
@[deprecated (since := "2025-05-23")] alias not_mem_empty := notMem_empty
@[simp] | theorem | SetTheory | [
"Mathlib.Data.Fin.VecNotation",
"Mathlib.Data.SetLike.Basic",
"Mathlib.Logic.Small.Basic",
"Mathlib.SetTheory.ZFC.PSet"
] | Mathlib/SetTheory/ZFC/Basic.lean | notMem_empty | null |
toSet_empty : toSet ∅ = ∅ := by simp [toSet]
@[simp] | theorem | SetTheory | [
"Mathlib.Data.Fin.VecNotation",
"Mathlib.Data.SetLike.Basic",
"Mathlib.Logic.Small.Basic",
"Mathlib.SetTheory.ZFC.PSet"
] | Mathlib/SetTheory/ZFC/Basic.lean | toSet_empty | null |
empty_subset (x : ZFSet.{u}) : (∅ : ZFSet) ⊆ x :=
Quotient.inductionOn x fun y => subset_iff.2 <| PSet.empty_subset y
@[simp] | theorem | SetTheory | [
"Mathlib.Data.Fin.VecNotation",
"Mathlib.Data.SetLike.Basic",
"Mathlib.Logic.Small.Basic",
"Mathlib.SetTheory.ZFC.PSet"
] | Mathlib/SetTheory/ZFC/Basic.lean | empty_subset | null |
not_nonempty_empty : ¬ZFSet.Nonempty ∅ := by simp [ZFSet.Nonempty]
@[simp] | theorem | SetTheory | [
"Mathlib.Data.Fin.VecNotation",
"Mathlib.Data.SetLike.Basic",
"Mathlib.Logic.Small.Basic",
"Mathlib.SetTheory.ZFC.PSet"
] | Mathlib/SetTheory/ZFC/Basic.lean | not_nonempty_empty | null |
nonempty_mk_iff {x : PSet} : (mk x).Nonempty ↔ x.Nonempty := by
refine ⟨?_, fun ⟨a, h⟩ => ⟨mk a, h⟩⟩
rintro ⟨a, h⟩
induction a using Quotient.inductionOn
exact ⟨_, h⟩ | theorem | SetTheory | [
"Mathlib.Data.Fin.VecNotation",
"Mathlib.Data.SetLike.Basic",
"Mathlib.Logic.Small.Basic",
"Mathlib.SetTheory.ZFC.PSet"
] | Mathlib/SetTheory/ZFC/Basic.lean | nonempty_mk_iff | null |
eq_empty (x : ZFSet.{u}) : x = ∅ ↔ ∀ y : ZFSet.{u}, y ∉ x := by
simp [ZFSet.ext_iff] | theorem | SetTheory | [
"Mathlib.Data.Fin.VecNotation",
"Mathlib.Data.SetLike.Basic",
"Mathlib.Logic.Small.Basic",
"Mathlib.SetTheory.ZFC.PSet"
] | Mathlib/SetTheory/ZFC/Basic.lean | eq_empty | null |
eq_empty_or_nonempty (u : ZFSet) : u = ∅ ∨ u.Nonempty := by
rw [eq_empty, ← not_exists]
apply em' | theorem | SetTheory | [
"Mathlib.Data.Fin.VecNotation",
"Mathlib.Data.SetLike.Basic",
"Mathlib.Logic.Small.Basic",
"Mathlib.SetTheory.ZFC.PSet"
] | Mathlib/SetTheory/ZFC/Basic.lean | eq_empty_or_nonempty | null |
protected Insert : ZFSet → ZFSet → ZFSet :=
Quotient.map₂ PSet.insert
fun _ _ uv ⟨_, _⟩ ⟨_, _⟩ ⟨αβ, βα⟩ =>
⟨fun o =>
match o with
| some a =>
let ⟨b, hb⟩ := αβ a
⟨some b, hb⟩
| none => ⟨none, uv⟩,
fun o =>
match o with
| some b =>
let ⟨a, ha⟩ := βα b
⟨some a, ha⟩
| none => ⟨none, uv⟩⟩ | def | SetTheory | [
"Mathlib.Data.Fin.VecNotation",
"Mathlib.Data.SetLike.Basic",
"Mathlib.Logic.Small.Basic",
"Mathlib.SetTheory.ZFC.PSet"
] | Mathlib/SetTheory/ZFC/Basic.lean | Insert | `Insert x y` is the set `{x} ∪ y` |
@[simp]
mem_insert_iff {x y z : ZFSet.{u}} : x ∈ insert y z ↔ x = y ∨ x ∈ z :=
Quotient.inductionOn₃ x y z fun _ _ _ => PSet.mem_insert_iff.trans (or_congr_left eq.symm) | theorem | SetTheory | [
"Mathlib.Data.Fin.VecNotation",
"Mathlib.Data.SetLike.Basic",
"Mathlib.Logic.Small.Basic",
"Mathlib.SetTheory.ZFC.PSet"
] | Mathlib/SetTheory/ZFC/Basic.lean | mem_insert_iff | null |
mem_insert (x y : ZFSet) : x ∈ insert x y :=
mem_insert_iff.2 <| Or.inl rfl | theorem | SetTheory | [
"Mathlib.Data.Fin.VecNotation",
"Mathlib.Data.SetLike.Basic",
"Mathlib.Logic.Small.Basic",
"Mathlib.SetTheory.ZFC.PSet"
] | Mathlib/SetTheory/ZFC/Basic.lean | mem_insert | null |
mem_insert_of_mem {y z : ZFSet} (x) (h : z ∈ y) : z ∈ insert x y :=
mem_insert_iff.2 <| Or.inr h
@[simp] | theorem | SetTheory | [
"Mathlib.Data.Fin.VecNotation",
"Mathlib.Data.SetLike.Basic",
"Mathlib.Logic.Small.Basic",
"Mathlib.SetTheory.ZFC.PSet"
] | Mathlib/SetTheory/ZFC/Basic.lean | mem_insert_of_mem | null |
toSet_insert (x y : ZFSet) : (insert x y).toSet = insert x y.toSet := by
ext
simp
@[simp] | theorem | SetTheory | [
"Mathlib.Data.Fin.VecNotation",
"Mathlib.Data.SetLike.Basic",
"Mathlib.Logic.Small.Basic",
"Mathlib.SetTheory.ZFC.PSet"
] | Mathlib/SetTheory/ZFC/Basic.lean | toSet_insert | null |
mem_singleton {x y : ZFSet.{u}} : x ∈ @singleton ZFSet.{u} ZFSet.{u} _ y ↔ x = y :=
Quotient.inductionOn₂ x y fun _ _ => PSet.mem_singleton.trans eq.symm
@[simp] | theorem | SetTheory | [
"Mathlib.Data.Fin.VecNotation",
"Mathlib.Data.SetLike.Basic",
"Mathlib.Logic.Small.Basic",
"Mathlib.SetTheory.ZFC.PSet"
] | Mathlib/SetTheory/ZFC/Basic.lean | mem_singleton | null |
toSet_singleton (x : ZFSet) : ({x} : ZFSet).toSet = {x} := by
ext
simp | theorem | SetTheory | [
"Mathlib.Data.Fin.VecNotation",
"Mathlib.Data.SetLike.Basic",
"Mathlib.Logic.Small.Basic",
"Mathlib.SetTheory.ZFC.PSet"
] | Mathlib/SetTheory/ZFC/Basic.lean | toSet_singleton | null |
insert_nonempty (u v : ZFSet) : (insert u v).Nonempty :=
⟨u, mem_insert u v⟩ | theorem | SetTheory | [
"Mathlib.Data.Fin.VecNotation",
"Mathlib.Data.SetLike.Basic",
"Mathlib.Logic.Small.Basic",
"Mathlib.SetTheory.ZFC.PSet"
] | Mathlib/SetTheory/ZFC/Basic.lean | insert_nonempty | null |
singleton_nonempty (u : ZFSet) : ZFSet.Nonempty {u} :=
insert_nonempty u ∅ | theorem | SetTheory | [
"Mathlib.Data.Fin.VecNotation",
"Mathlib.Data.SetLike.Basic",
"Mathlib.Logic.Small.Basic",
"Mathlib.SetTheory.ZFC.PSet"
] | Mathlib/SetTheory/ZFC/Basic.lean | singleton_nonempty | null |
mem_pair {x y z : ZFSet.{u}} : x ∈ ({y, z} : ZFSet) ↔ x = y ∨ x = z := by
simp
@[simp] | theorem | SetTheory | [
"Mathlib.Data.Fin.VecNotation",
"Mathlib.Data.SetLike.Basic",
"Mathlib.Logic.Small.Basic",
"Mathlib.SetTheory.ZFC.PSet"
] | Mathlib/SetTheory/ZFC/Basic.lean | mem_pair | null |
pair_eq_singleton (x : ZFSet) : {x, x} = ({x} : ZFSet) := by
ext
simp
@[simp] | theorem | SetTheory | [
"Mathlib.Data.Fin.VecNotation",
"Mathlib.Data.SetLike.Basic",
"Mathlib.Logic.Small.Basic",
"Mathlib.SetTheory.ZFC.PSet"
] | Mathlib/SetTheory/ZFC/Basic.lean | pair_eq_singleton | null |
pair_eq_singleton_iff {x y z : ZFSet} : ({x, y} : ZFSet) = {z} ↔ x = z ∧ y = z := by
refine ⟨fun h ↦ ?_, ?_⟩
· rw [← mem_singleton, ← mem_singleton]
simp [← h]
· rintro ⟨rfl, rfl⟩
exact pair_eq_singleton y
@[simp] | theorem | SetTheory | [
"Mathlib.Data.Fin.VecNotation",
"Mathlib.Data.SetLike.Basic",
"Mathlib.Logic.Small.Basic",
"Mathlib.SetTheory.ZFC.PSet"
] | Mathlib/SetTheory/ZFC/Basic.lean | pair_eq_singleton_iff | null |
singleton_eq_pair_iff {x y z : ZFSet} : ({x} : ZFSet) = {y, z} ↔ x = y ∧ x = z := by
rw [eq_comm, pair_eq_singleton_iff]
simp_rw [eq_comm] | theorem | SetTheory | [
"Mathlib.Data.Fin.VecNotation",
"Mathlib.Data.SetLike.Basic",
"Mathlib.Logic.Small.Basic",
"Mathlib.SetTheory.ZFC.PSet"
] | Mathlib/SetTheory/ZFC/Basic.lean | singleton_eq_pair_iff | null |
omega : ZFSet :=
mk PSet.omega
@[simp] | def | SetTheory | [
"Mathlib.Data.Fin.VecNotation",
"Mathlib.Data.SetLike.Basic",
"Mathlib.Logic.Small.Basic",
"Mathlib.SetTheory.ZFC.PSet"
] | Mathlib/SetTheory/ZFC/Basic.lean | omega | `omega` is the first infinite von Neumann ordinal |
omega_zero : ∅ ∈ omega :=
⟨⟨0⟩, Equiv.rfl⟩
@[simp] | theorem | SetTheory | [
"Mathlib.Data.Fin.VecNotation",
"Mathlib.Data.SetLike.Basic",
"Mathlib.Logic.Small.Basic",
"Mathlib.SetTheory.ZFC.PSet"
] | Mathlib/SetTheory/ZFC/Basic.lean | omega_zero | null |
omega_succ {n} : n ∈ omega.{u} → insert n n ∈ omega.{u} :=
Quotient.inductionOn n fun x ⟨⟨n⟩, h⟩ =>
⟨⟨n + 1⟩,
ZFSet.exact <|
show insert (mk x) (mk x) = insert (mk <| ofNat n) (mk <| ofNat n) by
rw [ZFSet.sound h]
rfl⟩ | theorem | SetTheory | [
"Mathlib.Data.Fin.VecNotation",
"Mathlib.Data.SetLike.Basic",
"Mathlib.Logic.Small.Basic",
"Mathlib.SetTheory.ZFC.PSet"
] | Mathlib/SetTheory/ZFC/Basic.lean | omega_succ | null |
protected sep (p : ZFSet → Prop) : ZFSet → ZFSet :=
Quotient.map (PSet.sep fun y => p (mk y))
fun ⟨α, A⟩ ⟨β, B⟩ ⟨αβ, βα⟩ =>
⟨fun ⟨a, pa⟩ =>
let ⟨b, hb⟩ := αβ a
⟨⟨b, by simpa only [mk_func, ← ZFSet.sound hb]⟩, hb⟩,
fun ⟨b, pb⟩ =>
let ⟨a, ha⟩ := βα b
⟨⟨a, by simpa only [mk_func, ZFSet.sound ha]⟩, ha⟩⟩ | def | SetTheory | [
"Mathlib.Data.Fin.VecNotation",
"Mathlib.Data.SetLike.Basic",
"Mathlib.Logic.Small.Basic",
"Mathlib.SetTheory.ZFC.PSet"
] | Mathlib/SetTheory/ZFC/Basic.lean | sep | `{x ∈ a | p x}` is the set of elements in `a` satisfying `p` |
@[simp]
mem_sep {p : ZFSet.{u} → Prop} {x y : ZFSet.{u}} :
y ∈ ZFSet.sep p x ↔ y ∈ x ∧ p y :=
Quotient.inductionOn₂ x y fun _ _ =>
PSet.mem_sep (p := p ∘ mk) fun _ _ h => (Quotient.sound h).subst
@[simp] | theorem | SetTheory | [
"Mathlib.Data.Fin.VecNotation",
"Mathlib.Data.SetLike.Basic",
"Mathlib.Logic.Small.Basic",
"Mathlib.SetTheory.ZFC.PSet"
] | Mathlib/SetTheory/ZFC/Basic.lean | mem_sep | null |
sep_empty (p : ZFSet → Prop) : (∅ : ZFSet).sep p = ∅ :=
(eq_empty _).mpr fun _ h ↦ notMem_empty _ (mem_sep.mp h).1
@[simp] | theorem | SetTheory | [
"Mathlib.Data.Fin.VecNotation",
"Mathlib.Data.SetLike.Basic",
"Mathlib.Logic.Small.Basic",
"Mathlib.SetTheory.ZFC.PSet"
] | Mathlib/SetTheory/ZFC/Basic.lean | sep_empty | null |
toSet_sep (a : ZFSet) (p : ZFSet → Prop) :
(ZFSet.sep p a).toSet = { x ∈ a.toSet | p x } := by
ext
simp | theorem | SetTheory | [
"Mathlib.Data.Fin.VecNotation",
"Mathlib.Data.SetLike.Basic",
"Mathlib.Logic.Small.Basic",
"Mathlib.SetTheory.ZFC.PSet"
] | Mathlib/SetTheory/ZFC/Basic.lean | toSet_sep | null |
powerset : ZFSet → ZFSet :=
Quotient.map PSet.powerset
fun ⟨_, A⟩ ⟨_, B⟩ ⟨αβ, βα⟩ =>
⟨fun p =>
⟨{ b | ∃ a, p a ∧ Equiv (A a) (B b) }, fun ⟨a, pa⟩ =>
let ⟨b, ab⟩ := αβ a
⟨⟨b, a, pa, ab⟩, ab⟩,
fun ⟨_, a, pa, ab⟩ => ⟨⟨a, pa⟩, ab⟩⟩,
fun q =>
⟨{ a | ∃ b, q b ∧ Equiv (A a) (B b) }, fun ⟨_, b, qb, ab⟩ => ⟨⟨b, qb⟩, ab⟩, fun ⟨b, qb⟩ =>
let ⟨a, ab⟩ := βα b
⟨⟨a, b, qb, ab⟩, ab⟩⟩⟩
@[simp] | def | SetTheory | [
"Mathlib.Data.Fin.VecNotation",
"Mathlib.Data.SetLike.Basic",
"Mathlib.Logic.Small.Basic",
"Mathlib.SetTheory.ZFC.PSet"
] | Mathlib/SetTheory/ZFC/Basic.lean | powerset | The powerset operation, the collection of subsets of a ZFC set |
mem_powerset {x y : ZFSet.{u}} : y ∈ powerset x ↔ y ⊆ x :=
Quotient.inductionOn₂ x y fun _ _ => PSet.mem_powerset.trans subset_iff.symm | theorem | SetTheory | [
"Mathlib.Data.Fin.VecNotation",
"Mathlib.Data.SetLike.Basic",
"Mathlib.Logic.Small.Basic",
"Mathlib.SetTheory.ZFC.PSet"
] | Mathlib/SetTheory/ZFC/Basic.lean | mem_powerset | null |
sUnion_lem {α β : Type u} (A : α → PSet) (B : β → PSet) (αβ : ∀ a, ∃ b, Equiv (A a) (B b)) :
∀ a, ∃ b, Equiv ((sUnion ⟨α, A⟩).Func a) ((sUnion ⟨β, B⟩).Func b)
| ⟨a, c⟩ => by
let ⟨b, hb⟩ := αβ a
induction ea : A a with | _ γ Γ
induction eb : B b with | _ δ Δ
rw [ea, eb] at hb
obtain ⟨γδ, δγ⟩ := hb
let c : (A a).Type := c
let ⟨d, hd⟩ := γδ (by rwa [ea] at c)
use ⟨b, Eq.ndrec d (Eq.symm eb)⟩
change PSet.Equiv ((A a).Func c) ((B b).Func (Eq.ndrec d eb.symm))
match A a, B b, ea, eb, c, d, hd with
| _, _, rfl, rfl, _, _, hd => exact hd | theorem | SetTheory | [
"Mathlib.Data.Fin.VecNotation",
"Mathlib.Data.SetLike.Basic",
"Mathlib.Logic.Small.Basic",
"Mathlib.SetTheory.ZFC.PSet"
] | Mathlib/SetTheory/ZFC/Basic.lean | sUnion_lem | null |
sUnion : ZFSet → ZFSet :=
Quotient.map PSet.sUnion
fun ⟨_, A⟩ ⟨_, B⟩ ⟨αβ, βα⟩ =>
⟨sUnion_lem A B αβ, fun a =>
Exists.elim
(sUnion_lem B A (fun b => Exists.elim (βα b) fun c hc => ⟨c, PSet.Equiv.symm hc⟩) a)
fun b hb => ⟨b, PSet.Equiv.symm hb⟩⟩
@[inherit_doc]
scoped prefix:110 "⋃₀ " => ZFSet.sUnion | def | SetTheory | [
"Mathlib.Data.Fin.VecNotation",
"Mathlib.Data.SetLike.Basic",
"Mathlib.Logic.Small.Basic",
"Mathlib.SetTheory.ZFC.PSet"
] | Mathlib/SetTheory/ZFC/Basic.lean | sUnion | The union operator, the collection of elements of elements of a ZFC set. Uses `⋃₀` notation,
scoped under the `ZFSet` namespace. |
sInter (x : ZFSet) : ZFSet := (⋃₀ x).sep (fun y => ∀ z ∈ x, y ∈ z)
@[inherit_doc]
scoped prefix:110 "⋂₀ " => ZFSet.sInter
@[simp] | def | SetTheory | [
"Mathlib.Data.Fin.VecNotation",
"Mathlib.Data.SetLike.Basic",
"Mathlib.Logic.Small.Basic",
"Mathlib.SetTheory.ZFC.PSet"
] | Mathlib/SetTheory/ZFC/Basic.lean | sInter | The intersection operator, the collection of elements in all of the elements of a ZFC set. We
define `⋂₀ ∅ = ∅`. Uses `⋂₀` notation, scoped under the `ZFSet` namespace. |
mem_sUnion {x y : ZFSet.{u}} : y ∈ ⋃₀ x ↔ ∃ z ∈ x, y ∈ z :=
Quotient.inductionOn₂ x y fun _ _ => PSet.mem_sUnion.trans
⟨fun ⟨z, h⟩ => ⟨⟦z⟧, h⟩, fun ⟨z, h⟩ => Quotient.inductionOn z (fun z h => ⟨z, h⟩) h⟩ | theorem | SetTheory | [
"Mathlib.Data.Fin.VecNotation",
"Mathlib.Data.SetLike.Basic",
"Mathlib.Logic.Small.Basic",
"Mathlib.SetTheory.ZFC.PSet"
] | Mathlib/SetTheory/ZFC/Basic.lean | mem_sUnion | null |
mem_sInter {x y : ZFSet} (h : x.Nonempty) : y ∈ ⋂₀ x ↔ ∀ z ∈ x, y ∈ z := by
unfold sInter
simp only [and_iff_right_iff_imp, mem_sep]
intro mem
apply mem_sUnion.mpr
replace ⟨s, h⟩ := h
exact ⟨_, h, mem _ h⟩
@[simp] | theorem | SetTheory | [
"Mathlib.Data.Fin.VecNotation",
"Mathlib.Data.SetLike.Basic",
"Mathlib.Logic.Small.Basic",
"Mathlib.SetTheory.ZFC.PSet"
] | Mathlib/SetTheory/ZFC/Basic.lean | mem_sInter | null |
sUnion_empty : ⋃₀ (∅ : ZFSet.{u}) = ∅ := by
ext
simp
@[simp] | theorem | SetTheory | [
"Mathlib.Data.Fin.VecNotation",
"Mathlib.Data.SetLike.Basic",
"Mathlib.Logic.Small.Basic",
"Mathlib.SetTheory.ZFC.PSet"
] | Mathlib/SetTheory/ZFC/Basic.lean | sUnion_empty | null |
sInter_empty : ⋂₀ (∅ : ZFSet) = ∅ := by simp [sInter] | theorem | SetTheory | [
"Mathlib.Data.Fin.VecNotation",
"Mathlib.Data.SetLike.Basic",
"Mathlib.Logic.Small.Basic",
"Mathlib.SetTheory.ZFC.PSet"
] | Mathlib/SetTheory/ZFC/Basic.lean | sInter_empty | null |
mem_of_mem_sInter {x y z : ZFSet} (hy : y ∈ ⋂₀ x) (hz : z ∈ x) : y ∈ z := by
rcases eq_empty_or_nonempty x with (rfl | hx)
· exact (notMem_empty z hz).elim
· exact (mem_sInter hx).1 hy z hz | theorem | SetTheory | [
"Mathlib.Data.Fin.VecNotation",
"Mathlib.Data.SetLike.Basic",
"Mathlib.Logic.Small.Basic",
"Mathlib.SetTheory.ZFC.PSet"
] | Mathlib/SetTheory/ZFC/Basic.lean | mem_of_mem_sInter | null |
mem_sUnion_of_mem {x y z : ZFSet} (hy : y ∈ z) (hz : z ∈ x) : y ∈ ⋃₀ x :=
mem_sUnion.2 ⟨z, hz, hy⟩ | theorem | SetTheory | [
"Mathlib.Data.Fin.VecNotation",
"Mathlib.Data.SetLike.Basic",
"Mathlib.Logic.Small.Basic",
"Mathlib.SetTheory.ZFC.PSet"
] | Mathlib/SetTheory/ZFC/Basic.lean | mem_sUnion_of_mem | null |
notMem_sInter_of_notMem {x y z : ZFSet} (hy : y ∉ z) (hz : z ∈ x) : y ∉ ⋂₀ x :=
fun hx => hy <| mem_of_mem_sInter hx hz
@[deprecated (since := "2025-05-23")] alias not_mem_sInter_of_not_mem := notMem_sInter_of_notMem
@[simp] | theorem | SetTheory | [
"Mathlib.Data.Fin.VecNotation",
"Mathlib.Data.SetLike.Basic",
"Mathlib.Logic.Small.Basic",
"Mathlib.SetTheory.ZFC.PSet"
] | Mathlib/SetTheory/ZFC/Basic.lean | notMem_sInter_of_notMem | null |
sUnion_singleton {x : ZFSet.{u}} : ⋃₀ ({x} : ZFSet) = x :=
ext fun y => by simp_rw [mem_sUnion, mem_singleton, exists_eq_left]
@[simp] | theorem | SetTheory | [
"Mathlib.Data.Fin.VecNotation",
"Mathlib.Data.SetLike.Basic",
"Mathlib.Logic.Small.Basic",
"Mathlib.SetTheory.ZFC.PSet"
] | Mathlib/SetTheory/ZFC/Basic.lean | sUnion_singleton | null |
sInter_singleton {x : ZFSet.{u}} : ⋂₀ ({x} : ZFSet) = x :=
ext fun y => by simp_rw [mem_sInter (singleton_nonempty x), mem_singleton, forall_eq]
@[simp] | theorem | SetTheory | [
"Mathlib.Data.Fin.VecNotation",
"Mathlib.Data.SetLike.Basic",
"Mathlib.Logic.Small.Basic",
"Mathlib.SetTheory.ZFC.PSet"
] | Mathlib/SetTheory/ZFC/Basic.lean | sInter_singleton | null |
toSet_sUnion (x : ZFSet.{u}) : (⋃₀ x).toSet = ⋃₀ (toSet '' x.toSet) := by
ext
simp | theorem | SetTheory | [
"Mathlib.Data.Fin.VecNotation",
"Mathlib.Data.SetLike.Basic",
"Mathlib.Logic.Small.Basic",
"Mathlib.SetTheory.ZFC.PSet"
] | Mathlib/SetTheory/ZFC/Basic.lean | toSet_sUnion | null |
toSet_sInter {x : ZFSet.{u}} (h : x.Nonempty) : (⋂₀ x).toSet = ⋂₀ (toSet '' x.toSet) := by
ext
simp [mem_sInter h] | theorem | SetTheory | [
"Mathlib.Data.Fin.VecNotation",
"Mathlib.Data.SetLike.Basic",
"Mathlib.Logic.Small.Basic",
"Mathlib.SetTheory.ZFC.PSet"
] | Mathlib/SetTheory/ZFC/Basic.lean | toSet_sInter | null |
singleton_injective : Function.Injective (@singleton ZFSet ZFSet _) := fun x y H => by
let this := congr_arg sUnion H
rwa [sUnion_singleton, sUnion_singleton] at this
@[simp] | theorem | SetTheory | [
"Mathlib.Data.Fin.VecNotation",
"Mathlib.Data.SetLike.Basic",
"Mathlib.Logic.Small.Basic",
"Mathlib.SetTheory.ZFC.PSet"
] | Mathlib/SetTheory/ZFC/Basic.lean | singleton_injective | null |
singleton_inj {x y : ZFSet} : ({x} : ZFSet) = {y} ↔ x = y :=
singleton_injective.eq_iff | theorem | SetTheory | [
"Mathlib.Data.Fin.VecNotation",
"Mathlib.Data.SetLike.Basic",
"Mathlib.Logic.Small.Basic",
"Mathlib.SetTheory.ZFC.PSet"
] | Mathlib/SetTheory/ZFC/Basic.lean | singleton_inj | null |
protected union (x y : ZFSet.{u}) : ZFSet.{u} :=
⋃₀ {x, y} | def | SetTheory | [
"Mathlib.Data.Fin.VecNotation",
"Mathlib.Data.SetLike.Basic",
"Mathlib.Logic.Small.Basic",
"Mathlib.SetTheory.ZFC.PSet"
] | Mathlib/SetTheory/ZFC/Basic.lean | union | The binary union operation |
protected inter (x y : ZFSet.{u}) : ZFSet.{u} :=
ZFSet.sep (fun z => z ∈ y) x -- { z ∈ x | z ∈ y } | def | SetTheory | [
"Mathlib.Data.Fin.VecNotation",
"Mathlib.Data.SetLike.Basic",
"Mathlib.Logic.Small.Basic",
"Mathlib.SetTheory.ZFC.PSet"
] | Mathlib/SetTheory/ZFC/Basic.lean | inter | The binary intersection operation |
protected diff (x y : ZFSet.{u}) : ZFSet.{u} :=
ZFSet.sep (fun z => z ∉ y) x -- { z ∈ x | z ∉ y } | def | SetTheory | [
"Mathlib.Data.Fin.VecNotation",
"Mathlib.Data.SetLike.Basic",
"Mathlib.Logic.Small.Basic",
"Mathlib.SetTheory.ZFC.PSet"
] | Mathlib/SetTheory/ZFC/Basic.lean | diff | The set difference operation |
@[simp]
toSet_union (x y : ZFSet.{u}) : (x ∪ y).toSet = x.toSet ∪ y.toSet := by
change (⋃₀ {x, y}).toSet = _
simp
@[simp] | theorem | SetTheory | [
"Mathlib.Data.Fin.VecNotation",
"Mathlib.Data.SetLike.Basic",
"Mathlib.Logic.Small.Basic",
"Mathlib.SetTheory.ZFC.PSet"
] | Mathlib/SetTheory/ZFC/Basic.lean | toSet_union | null |
toSet_inter (x y : ZFSet.{u}) : (x ∩ y).toSet = x.toSet ∩ y.toSet := by
change (ZFSet.sep (fun z => z ∈ y) x).toSet = _
ext
simp
@[simp] | theorem | SetTheory | [
"Mathlib.Data.Fin.VecNotation",
"Mathlib.Data.SetLike.Basic",
"Mathlib.Logic.Small.Basic",
"Mathlib.SetTheory.ZFC.PSet"
] | Mathlib/SetTheory/ZFC/Basic.lean | toSet_inter | null |
toSet_sdiff (x y : ZFSet.{u}) : (x \ y).toSet = x.toSet \ y.toSet := by
change (ZFSet.sep (fun z => z ∉ y) x).toSet = _
ext
simp
@[simp] | theorem | SetTheory | [
"Mathlib.Data.Fin.VecNotation",
"Mathlib.Data.SetLike.Basic",
"Mathlib.Logic.Small.Basic",
"Mathlib.SetTheory.ZFC.PSet"
] | Mathlib/SetTheory/ZFC/Basic.lean | toSet_sdiff | null |
mem_union {x y z : ZFSet.{u}} : z ∈ x ∪ y ↔ z ∈ x ∨ z ∈ y := by
rw [← mem_toSet]
simp
@[simp] | theorem | SetTheory | [
"Mathlib.Data.Fin.VecNotation",
"Mathlib.Data.SetLike.Basic",
"Mathlib.Logic.Small.Basic",
"Mathlib.SetTheory.ZFC.PSet"
] | Mathlib/SetTheory/ZFC/Basic.lean | mem_union | null |
mem_inter {x y z : ZFSet.{u}} : z ∈ x ∩ y ↔ z ∈ x ∧ z ∈ y :=
@mem_sep (fun z : ZFSet.{u} => z ∈ y) x z
@[simp] | theorem | SetTheory | [
"Mathlib.Data.Fin.VecNotation",
"Mathlib.Data.SetLike.Basic",
"Mathlib.Logic.Small.Basic",
"Mathlib.SetTheory.ZFC.PSet"
] | Mathlib/SetTheory/ZFC/Basic.lean | mem_inter | null |
mem_diff {x y z : ZFSet.{u}} : z ∈ x \ y ↔ z ∈ x ∧ z ∉ y :=
@mem_sep (fun z : ZFSet.{u} => z ∉ y) x z
@[simp] | theorem | SetTheory | [
"Mathlib.Data.Fin.VecNotation",
"Mathlib.Data.SetLike.Basic",
"Mathlib.Logic.Small.Basic",
"Mathlib.SetTheory.ZFC.PSet"
] | Mathlib/SetTheory/ZFC/Basic.lean | mem_diff | null |
sUnion_pair {x y : ZFSet.{u}} : ⋃₀ ({x, y} : ZFSet.{u}) = x ∪ y :=
rfl | theorem | SetTheory | [
"Mathlib.Data.Fin.VecNotation",
"Mathlib.Data.SetLike.Basic",
"Mathlib.Logic.Small.Basic",
"Mathlib.SetTheory.ZFC.PSet"
] | Mathlib/SetTheory/ZFC/Basic.lean | sUnion_pair | null |
mem_wf : @WellFounded ZFSet (· ∈ ·) :=
(wellFounded_lift₂_iff (H := fun a b c d hx hy =>
propext ((@Mem.congr_left a c hx).trans (@Mem.congr_right b d hy _)))).mpr PSet.mem_wf | theorem | SetTheory | [
"Mathlib.Data.Fin.VecNotation",
"Mathlib.Data.SetLike.Basic",
"Mathlib.Logic.Small.Basic",
"Mathlib.SetTheory.ZFC.PSet"
] | Mathlib/SetTheory/ZFC/Basic.lean | mem_wf | null |
@[elab_as_elim]
inductionOn {p : ZFSet → Prop} (x) (h : ∀ x, (∀ y ∈ x, p y) → p x) : p x :=
mem_wf.induction x h | theorem | SetTheory | [
"Mathlib.Data.Fin.VecNotation",
"Mathlib.Data.SetLike.Basic",
"Mathlib.Logic.Small.Basic",
"Mathlib.SetTheory.ZFC.PSet"
] | Mathlib/SetTheory/ZFC/Basic.lean | inductionOn | Induction on the `∈` relation. |
mem_asymm {x y : ZFSet} : x ∈ y → y ∉ x :=
asymm_of (· ∈ ·) | theorem | SetTheory | [
"Mathlib.Data.Fin.VecNotation",
"Mathlib.Data.SetLike.Basic",
"Mathlib.Logic.Small.Basic",
"Mathlib.SetTheory.ZFC.PSet"
] | Mathlib/SetTheory/ZFC/Basic.lean | mem_asymm | null |
mem_irrefl (x : ZFSet) : x ∉ x :=
irrefl_of (· ∈ ·) x | theorem | SetTheory | [
"Mathlib.Data.Fin.VecNotation",
"Mathlib.Data.SetLike.Basic",
"Mathlib.Logic.Small.Basic",
"Mathlib.SetTheory.ZFC.PSet"
] | Mathlib/SetTheory/ZFC/Basic.lean | mem_irrefl | null |
not_subset_of_mem {x y : ZFSet} (h : x ∈ y) : ¬ y ⊆ x :=
fun h' ↦ mem_irrefl _ (h' h) | theorem | SetTheory | [
"Mathlib.Data.Fin.VecNotation",
"Mathlib.Data.SetLike.Basic",
"Mathlib.Logic.Small.Basic",
"Mathlib.SetTheory.ZFC.PSet"
] | Mathlib/SetTheory/ZFC/Basic.lean | not_subset_of_mem | null |
notMem_of_subset {x y : ZFSet} (h : x ⊆ y) : y ∉ x :=
imp_not_comm.2 not_subset_of_mem h
@[deprecated (since := "2025-05-23")] alias not_mem_of_subset := notMem_of_subset | theorem | SetTheory | [
"Mathlib.Data.Fin.VecNotation",
"Mathlib.Data.SetLike.Basic",
"Mathlib.Logic.Small.Basic",
"Mathlib.SetTheory.ZFC.PSet"
] | Mathlib/SetTheory/ZFC/Basic.lean | notMem_of_subset | null |
regularity (x : ZFSet.{u}) (h : x ≠ ∅) : ∃ y ∈ x, x ∩ y = ∅ :=
by_contradiction fun ne =>
h <| (eq_empty x).2 fun y =>
@inductionOn (fun z => z ∉ x) y fun z IH zx =>
ne ⟨z, zx, (eq_empty _).2 fun w wxz =>
let ⟨wx, wz⟩ := mem_inter.1 wxz
IH w wz wx⟩ | theorem | SetTheory | [
"Mathlib.Data.Fin.VecNotation",
"Mathlib.Data.SetLike.Basic",
"Mathlib.Logic.Small.Basic",
"Mathlib.SetTheory.ZFC.PSet"
] | Mathlib/SetTheory/ZFC/Basic.lean | regularity | null |
image (f : ZFSet → ZFSet) [Definable₁ f] : ZFSet → ZFSet :=
let r := Definable₁.out f
Quotient.map (PSet.image r)
fun _ _ e =>
Mem.ext fun _ =>
(mem_image (fun _ _ ↦ Definable₁.out_equiv _)).trans <|
Iff.trans
⟨fun ⟨w, h1, h2⟩ => ⟨w, (Mem.congr_right e).1 h1, h2⟩, fun ⟨w, h1, h2⟩ =>
⟨w, (Mem.congr_right e).2 h1, h2⟩⟩ <|
(mem_image (fun _ _ ↦ Definable₁.out_equiv _)).symm | def | SetTheory | [
"Mathlib.Data.Fin.VecNotation",
"Mathlib.Data.SetLike.Basic",
"Mathlib.Logic.Small.Basic",
"Mathlib.SetTheory.ZFC.PSet"
] | Mathlib/SetTheory/ZFC/Basic.lean | image | The image of a (definable) ZFC set function |
image.mk (f : ZFSet.{u} → ZFSet.{u}) [Definable₁ f] (x) {y} : y ∈ x → f y ∈ image f x :=
Quotient.inductionOn₂ x y fun ⟨_, _⟩ _ ⟨a, ya⟩ => by
simp only [mk_eq, ← Definable₁.mk_out (f := f)]
exact ⟨a, Definable₁.out_equiv f ya⟩
@[simp] | theorem | SetTheory | [
"Mathlib.Data.Fin.VecNotation",
"Mathlib.Data.SetLike.Basic",
"Mathlib.Logic.Small.Basic",
"Mathlib.SetTheory.ZFC.PSet"
] | Mathlib/SetTheory/ZFC/Basic.lean | image.mk | null |
mem_image {f : ZFSet.{u} → ZFSet.{u}} [Definable₁ f] {x y : ZFSet.{u}} :
y ∈ image f x ↔ ∃ z ∈ x, f z = y :=
Quotient.inductionOn₂ x y fun ⟨_, A⟩ _ =>
⟨fun ⟨a, ya⟩ => ⟨⟦A a⟧, Mem.mk A a, ((Quotient.sound ya).trans Definable₁.mk_out).symm⟩,
fun ⟨_, hz, e⟩ => e ▸ image.mk _ _ hz⟩
@[simp] | theorem | SetTheory | [
"Mathlib.Data.Fin.VecNotation",
"Mathlib.Data.SetLike.Basic",
"Mathlib.Logic.Small.Basic",
"Mathlib.SetTheory.ZFC.PSet"
] | Mathlib/SetTheory/ZFC/Basic.lean | mem_image | null |
toSet_image (f : ZFSet → ZFSet) [Definable₁ f] (x : ZFSet) :
(image f x).toSet = f '' x.toSet := by
ext
simp | theorem | SetTheory | [
"Mathlib.Data.Fin.VecNotation",
"Mathlib.Data.SetLike.Basic",
"Mathlib.Logic.Small.Basic",
"Mathlib.SetTheory.ZFC.PSet"
] | Mathlib/SetTheory/ZFC/Basic.lean | toSet_image | null |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.