File: Mathlib/SetTheory/ZFC/Basic.lean

full_name: PSet
code: /-- The type of pre-sets in universe `u`. A pre-set
  is a family of pre-sets indexed by a type in `Type u`.
  The ZFC universe is defined as a quotient of this
  to ensure extensionality. -/
inductive PSet : Type (u + 1)
  | mk (α : Type u) (A : α → PSet) : PSet
goal: Type (u + 1)

full_name: PSet.mk
code: /-- The type of pre-sets in universe `u`. A pre-set
  is a family of pre-sets indexed by a type in `Type u`.
  The ZFC universe is defined as a quotient of this
  to ensure extensionality. -/
inductive PSet : Type (u + 1)
  | mk (α : Type u) (A : α → PSet) : PSet
goal: PSet

full_name: PSet.Type
code: /-- The underlying type of a pre-set -/
def «Type» : PSet → Type u
  
goal: PSet → Type u

full_name: PSet.Func
code: /-- The underlying pre-set family of a pre-set -/
def Func : ∀ x : PSet, x.Type → PSet
  
goal: x.Type → PSet

full_name: PSet.mk_type
code: @[simp]
theorem mk_type (α A) : «Type» ⟨α, A⟩ = α 
goal: (PSet.mk α A).Type = α

full_name: PSet.mk_func
code: @[simp]
theorem mk_func (α A) : Func ⟨α, A⟩ = A 
goal: (PSet.mk α A).Func = A

full_name: PSet.eta
code: @[simp]
theorem eta : ∀ x : PSet, mk x.Type x.Func = x
  
goal: PSet.mk x.Type x.Func = x

full_name: PSet.Equiv
code: /-- Two pre-sets are extensionally equivalent if every element of the first family is extensionally
equivalent to some element of the second family and vice-versa. -/
def Equiv : PSet → PSet → Prop
  
goal: PSet → PSet → Prop

full_name: PSet.equiv_iff
code: theorem equiv_iff :
    ∀ {x y : PSet},
      Equiv x y ↔ (∀ i, ∃ j, Equiv (x.Func i) (y.Func j)) ∧ ∀ j, ∃ i, Equiv (x.Func i) (y.Func j)
  
goal: x.Equiv y ↔ (∀ (i : x.Type), ∃ j, (x.Func i).Equiv (y.Func j)) ∧ ∀ (j : y.Type), ∃ i, (x.Func i).Equiv (y.Func j)

full_name: PSet.Equiv.exists_left
code: theorem Equiv.exists_left {x y : PSet} (h : Equiv x y) : ∀ i, ∃ j, Equiv (x.Func i) (y.Func j) 
goal: ∃ j, (x.Func i).Equiv (y.Func j)

full_name: PSet.Equiv.exists_right
code: theorem Equiv.exists_right {x y : PSet} (h : Equiv x y) : ∀ j, ∃ i, Equiv (x.Func i) (y.Func j) 
goal: ∃ i, (x.Func i).Equiv (y.Func j)

full_name: PSet.Equiv.refl
code: @[refl]
protected theorem Equiv.refl : ∀ x, Equiv x x
  
goal: x.Equiv x

full_name: PSet.Equiv.rfl
code: protected theorem Equiv.rfl {x} : Equiv x x 
goal: x.Equiv x

full_name: PSet.Equiv.euc
code: protected theorem Equiv.euc : ∀ {x y z}, Equiv x y → Equiv z y → Equiv x z
  
goal: x.Equiv y → z.Equiv y → x.Equiv z

full_name: PSet.Equiv.symm
code: @[symm]
protected theorem Equiv.symm {x y} : Equiv x y → Equiv y x 
goal: x.Equiv y → y.Equiv x

full_name: PSet.Equiv.comm
code: protected theorem Equiv.comm {x y} : Equiv x y ↔ Equiv y x 
goal: x.Equiv y ↔ y.Equiv x

full_name: PSet.Equiv.trans
code: @[trans]
protected theorem Equiv.trans {x y z} (h1 : Equiv x y) (h2 : Equiv y z) : Equiv x z 
goal: x.Equiv z

full_name: PSet.equiv_of_isEmpty
code: protected theorem equiv_of_isEmpty (x y : PSet) [IsEmpty x.Type] [IsEmpty y.Type] : Equiv x y 
goal: x.Equiv y

full_name: PSet.setoid
code: instance setoid : Setoid PSet 
goal: Setoid PSet

full_name: PSet.Subset
code: /-- A pre-set is a subset of another pre-set if every element of the first family is extensionally
equivalent to some element of the second family. -/
protected def Subset (x y : PSet) : Prop 
goal: Prop

full_name: PSet.instHasSubset
code: instance : HasSubset PSet 
goal: HasSubset PSet

full_name: PSet.instIsReflSubset
code: instance : IsRefl PSet (· ⊆ ·) 
goal: IsRefl PSet fun x x_1 => x ⊆ x_1

full_name: PSet.instIsTransSubset
code: instance : IsTrans PSet (· ⊆ ·) 
goal: IsTrans PSet fun x x_1 => x ⊆ x_1

full_name: PSet.Equiv.ext
code: theorem Equiv.ext : ∀ x y : PSet, Equiv x y ↔ x ⊆ y ∧ y ⊆ x
  
goal: x.Equiv y ↔ x ⊆ y ∧ y ⊆ x

full_name: PSet.Subset.congr_left
code: theorem Subset.congr_left : ∀ {x y z : PSet}, Equiv x y → (x ⊆ z ↔ y ⊆ z)
  
goal: x.Equiv y → (x ⊆ z ↔ y ⊆ z)

full_name: PSet.Subset.congr_right
code: theorem Subset.congr_right : ∀ {x y z : PSet}, Equiv x y → (z ⊆ x ↔ z ⊆ y)
  
goal: x.Equiv y → (z ⊆ x ↔ z ⊆ y)

full_name: PSet.Mem
code: /-- `x ∈ y` as pre-sets if `x` is extensionally equivalent to a member of the family `y`. -/
protected def Mem (x y : PSet.{u}) : Prop 
goal: Prop

full_name: PSet.instMembership
code: instance : Membership PSet PSet 
goal: Membership PSet PSet

full_name: PSet.Mem.mk
code: theorem Mem.mk {α : Type u} (A : α → PSet) (a : α) : A a ∈ mk α A 
goal: A a ∈ PSet.mk α A

full_name: PSet.func_mem
code: theorem func_mem (x : PSet) (i : x.Type) : x.Func i ∈ x 
goal: x.Func i ∈ x

full_name: PSet.Mem.ext
code: theorem Mem.ext : ∀ {x y : PSet.{u}}, (∀ w : PSet.{u}, w ∈ x ↔ w ∈ y) → Equiv x y
  
goal: (∀ (w : PSet), w ∈ x ↔ w ∈ y) → x.Equiv y

full_name: PSet.Mem.congr_right
code: theorem Mem.congr_right : ∀ {x y : PSet.{u}}, Equiv x y → ∀ {w : PSet.{u}}, w ∈ x ↔ w ∈ y
  
goal: x.Equiv y → ∀ {w : PSet}, w ∈ x ↔ w ∈ y

full_name: PSet.equiv_iff_mem
code: theorem equiv_iff_mem {x y : PSet.{u}} : Equiv x y ↔ ∀ {w : PSet.{u}}, w ∈ x ↔ w ∈ y 
goal: x.Equiv y ↔ ∀ {w : PSet}, w ∈ x ↔ w ∈ y

full_name: PSet.Mem.congr_left
code: theorem Mem.congr_left : ∀ {x y : PSet.{u}}, Equiv x y → ∀ {w : PSet.{u}}, x ∈ w ↔ y ∈ w
  
goal: x.Equiv y → ∀ {w : PSet}, x ∈ w ↔ y ∈ w

full_name: _private.Mathlib.SetTheory.ZFC.Basic.0.PSet.mem_wf_aux
code: private theorem mem_wf_aux : ∀ {x y : PSet.{u}}, Equiv x y → Acc (· ∈ ·) y
  
goal: x.Equiv y → Acc (fun x x_1 => x ∈ x_1) y

full_name: PSet.mem_wf
code: theorem mem_wf : @WellFounded PSet (· ∈ ·) 
goal: WellFounded fun x x_1 => x ∈ x_1

full_name: PSet.instWellFoundedRelation
code: instance : WellFoundedRelation PSet 
goal: WellFoundedRelation PSet

full_name: PSet.instIsAsymmMem
code: instance : IsAsymm PSet (· ∈ ·) 
goal: IsAsymm PSet fun x x_1 => x ∈ x_1

full_name: PSet.instIsIrreflMem
code: instance : IsIrrefl PSet (· ∈ ·) 
goal: IsIrrefl PSet fun x x_1 => x ∈ x_1

full_name: PSet.mem_asymm
code: theorem mem_asymm {x y : PSet} : x ∈ y → y ∉ x 
goal: x ∈ y → y ∉ x

full_name: PSet.mem_irrefl
code: theorem mem_irrefl (x : PSet) : x ∉ x 
goal: x ∉ x

full_name: PSet.toSet
code: /-- Convert a pre-set to a `Set` of pre-sets. -/
def toSet (u : PSet.{u}) : Set PSet.{u} 
goal: Set PSet

full_name: PSet.mem_toSet
code: @[simp]
theorem mem_toSet (a u : PSet.{u}) : a ∈ u.toSet ↔ a ∈ u 
goal: a ∈ u.toSet ↔ a ∈ u

full_name: PSet.Nonempty
code: /-- A nonempty set is one that contains some element. -/
protected def Nonempty (u : PSet) : Prop 
goal: Prop

full_name: PSet.nonempty_def
code: theorem nonempty_def (u : PSet) : u.Nonempty ↔ ∃ x, x ∈ u 
goal: u.Nonempty ↔ ∃ x, x ∈ u

full_name: PSet.nonempty_of_mem
code: theorem nonempty_of_mem {x u : PSet} (h : x ∈ u) : u.Nonempty 
goal: u.Nonempty

full_name: PSet.nonempty_toSet_iff
code: @[simp]
theorem nonempty_toSet_iff {u : PSet} : u.toSet.Nonempty ↔ u.Nonempty 
goal: u.toSet.Nonempty ↔ u.Nonempty

full_name: PSet.nonempty_type_iff_nonempty
code: theorem nonempty_type_iff_nonempty {x : PSet} : Nonempty x.Type ↔ PSet.Nonempty x 
goal: Nonempty x.Type ↔ x.Nonempty

full_name: PSet.nonempty_of_nonempty_type
code: theorem nonempty_of_nonempty_type (x : PSet) [h : Nonempty x.Type] : PSet.Nonempty x 
goal: x.Nonempty

full_name: PSet.Equiv.eq
code: /-- Two pre-sets are equivalent iff they have the same members. -/
theorem Equiv.eq {x y : PSet} : Equiv x y ↔ toSet x = toSet y 
goal: x.Equiv y ↔ x.toSet = y.toSet

full_name: PSet.instCoeSet
code: instance : Coe PSet (Set PSet) 
goal: Coe PSet (Set PSet)

full_name: PSet.empty
code: /-- The empty pre-set -/
protected def empty : PSet 
goal: PSet

full_name: PSet.instEmptyCollection
code: instance : EmptyCollection PSet 
goal: EmptyCollection PSet

full_name: PSet.instInhabited
code: instance : Inhabited PSet 
goal: Inhabited PSet

full_name: PSet.instIsEmptyTypeEmptyCollection
code: instance : IsEmpty («Type» ∅) 
goal: IsEmpty ∅.Type

full_name: PSet.not_mem_empty
code: @[simp]
theorem not_mem_empty (x : PSet.{u}) : x ∉ (∅ : PSet.{u}) 
goal: x ∉ ∅

full_name: PSet.toSet_empty
code: @[simp]
theorem toSet_empty : toSet ∅ = ∅ 
goal: ∅.toSet = ∅

full_name: PSet.empty_subset
code: @[simp]
theorem empty_subset (x : PSet.{u}) : (∅ : PSet) ⊆ x 
goal: ∅ ⊆ x

full_name: PSet.not_nonempty_empty
code: @[simp]
theorem not_nonempty_empty : ¬PSet.Nonempty ∅ 
goal: ¬∅.Nonempty

full_name: PSet.equiv_empty
code: protected theorem equiv_empty (x : PSet) [IsEmpty x.Type] : Equiv x ∅ 
goal: x.Equiv ∅

full_name: PSet.insert
code: /-- Insert an element into a pre-set -/
protected def insert (x y : PSet) : PSet 
goal: PSet

full_name: PSet.instInsert
code: instance : Insert PSet PSet 
goal: Insert PSet PSet

full_name: PSet.instSingleton
code: instance : Singleton PSet PSet 
goal: Singleton PSet PSet

full_name: PSet.instLawfulSingleton
code: instance : LawfulSingleton PSet PSet 
goal: LawfulSingleton PSet PSet

full_name: PSet.instInhabitedTypeInsert
code: instance (x y : PSet) : Inhabited (insert x y).Type 
goal: Inhabited (insert x y).Type

full_name: PSet.ofNat
code: /-- The n-th von Neumann ordinal -/
def ofNat : ℕ → PSet
  
goal: ℕ → PSet

full_name: PSet.omega
code: /-- The von Neumann ordinal ω -/
def omega : PSet 
goal: PSet

full_name: PSet.sep
code: /-- The pre-set separation operation `{x ∈ a | p x}` -/
protected def sep (p : PSet → Prop) (x : PSet) : PSet 
goal: PSet

full_name: PSet.instSep
code: instance : Sep PSet PSet 
goal: Sep PSet PSet

full_name: PSet.powerset
code: /-- The pre-set powerset operator -/
def powerset (x : PSet) : PSet 
goal: PSet

full_name: PSet.mem_powerset
code: @[simp]
theorem mem_powerset : ∀ {x y : PSet}, y ∈ powerset x ↔ y ⊆ x
  
goal: y ∈ x.powerset ↔ y ⊆ x

full_name: PSet.sUnion
code: /-- The pre-set union operator -/
def sUnion (a : PSet) : PSet 
goal: PSet

full_name: PSet._aux_Mathlib_SetTheory_ZFC_Basic___unexpand_PSet_sUnion_1
code: @[inherit_doc]
prefix:110 "⋃₀ " => sUnion
goal: Lean.PrettyPrinter.Unexpander

full_name: PSet.«_aux_Mathlib_SetTheory_ZFC_Basic___macroRules_PSet_term⋃₀__1»
code: @[inherit_doc]
prefix:110 "⋃₀ " => sUnion
goal: Lean.Macro

full_name: PSet.mem_sUnion
code: @[simp]
theorem mem_sUnion : ∀ {x y : PSet.{u}}, y ∈ ⋃₀ x ↔ ∃ z ∈ x, y ∈ z
  
goal: y ∈ ⋃₀ x ↔ ∃ z ∈ x, y ∈ z

full_name: PSet.toSet_sUnion
code: @[simp]
theorem toSet_sUnion (x : PSet.{u}) : (⋃₀ x).toSet = ⋃₀ (toSet '' x.toSet) 
goal: (⋃₀ x).toSet = ⋃₀ (PSet.toSet '' x.toSet)

full_name: PSet.image
code: /-- The image of a function from pre-sets to pre-sets. -/
def image (f : PSet.{u} → PSet.{u}) (x : PSet.{u}) : PSet 
goal: PSet

full_name: PSet.mem_image
code: theorem mem_image {f : PSet.{u} → PSet.{u}} (H : ∀ x y, Equiv x y → Equiv (f x) (f y)) :
    ∀ {x y : PSet.{u}}, y ∈ image f x ↔ ∃ z ∈ x, Equiv y (f z)
  
goal: y ∈ PSet.image f x ↔ ∃ z ∈ x, y.Equiv (f z)

full_name: PSet.Lift
code: /-- Universe lift operation -/
protected def Lift : PSet.{u} → PSet.{max u v}
  
goal: PSet → PSet

full_name: PSet.embed
code: /-- Embedding of one universe in another -/
@[nolint checkUnivs]
def embed : PSet.{max (u + 1) v} 
goal: PSet

full_name: PSet.lift_mem_embed
code: theorem lift_mem_embed : ∀ x : PSet.{u}, PSet.Lift.{u, max (u + 1) v} x ∈ embed.{u, v} 
goal: x.Lift ∈ PSet.embed

full_name: PSet.Arity.Equiv
code: /-- Function equivalence is defined so that `f ~ g` iff `∀ x y, x ~ y → f x ~ g y`. This extends to
equivalence of `n`-ary functions. -/
def Arity.Equiv : ∀ {n}, OfArity PSet.{u} PSet.{u} n → OfArity PSet.{u} PSet.{u} n → Prop
  
goal: Function.OfArity PSet PSet n → Function.OfArity PSet PSet n → Prop

full_name: PSet.Arity.equiv_const
code: theorem Arity.equiv_const {a : PSet.{u}} :
    ∀ n, Arity.Equiv (OfArity.const PSet.{u} a n) (OfArity.const PSet.{u} a n)
  
goal: PSet.Arity.Equiv (Function.OfArity.const PSet a n) (Function.OfArity.const PSet a n)

full_name: PSet.Resp
code: /-- `resp n` is the collection of n-ary functions on `PSet` that respect
  equivalence, i.e. when the inputs are equivalent the output is as well. -/
def Resp (n) 
goal: Type (u + 1)

full_name: PSet.Resp.inhabited
code: instance Resp.inhabited {n} : Inhabited (Resp n) 
goal: Inhabited (PSet.Resp n)

full_name: PSet.Resp.f
code: /-- The `n`-ary image of a `(n + 1)`-ary function respecting equivalence as a function respecting
equivalence. -/
def Resp.f {n} (f : Resp (n + 1)) (x : PSet) : Resp n 
goal: PSet.Resp n

full_name: PSet.Resp.Equiv
code: /-- Function equivalence for functions respecting equivalence. See `PSet.Arity.Equiv`. -/
def Resp.Equiv {n} (a b : Resp n) : Prop 
goal: Prop

full_name: PSet.Resp.Equiv.refl
code: @[refl]
protected theorem Resp.Equiv.refl {n} (a : Resp n) : Resp.Equiv a a 
goal: a.Equiv a

full_name: PSet.Resp.Equiv.euc
code: protected theorem Resp.Equiv.euc :
    ∀ {n} {a b c : Resp n}, Resp.Equiv a b → Resp.Equiv c b → Resp.Equiv a c
  
goal: a.Equiv b → c.Equiv b → a.Equiv c

full_name: PSet.Resp.Equiv.symm
code: @[symm]
protected theorem Resp.Equiv.symm {n} {a b : Resp n} : Resp.Equiv a b → Resp.Equiv b a 
goal: a.Equiv b → b.Equiv a

full_name: PSet.Resp.Equiv.trans
code: @[trans]
protected theorem Resp.Equiv.trans {n} {x y z : Resp n} (h1 : Resp.Equiv x y)
    (h2 : Resp.Equiv y z) : Resp.Equiv x z 
goal: x.Equiv z

full_name: PSet.Resp.setoid
code: instance Resp.setoid {n} : Setoid (Resp n) 
goal: Setoid (PSet.Resp n)

full_name: ZFSet
code: /-- The ZFC universe of sets consists of the type of pre-sets,
  quotiented by extensional equivalence. -/
def ZFSet : Type (u + 1) 
goal: Type (u + 1)

full_name: PSet.Resp.evalAux
code: /-- Helper function for `PSet.eval`. -/
def evalAux :
    ∀ {n},
      { f : Resp n → OfArity ZFSet.{u} ZFSet.{u} n // ∀ a b : Resp n, Resp.Equiv a b → f a = f b }
  
goal: { f // ∀ (a b : PSet.Resp n), a.Equiv b → f a = f b }

full_name: PSet.Resp.eval
code: /-- An equivalence-respecting function yields an n-ary ZFC set function. -/
def eval (n) : Resp n → OfArity ZFSet.{u} ZFSet.{u} n 
goal: PSet.Resp n → Function.OfArity ZFSet ZFSet n

full_name: PSet.Resp.eval_val
code: theorem eval_val {n f x} :
    (@eval (n + 1) f : ZFSet → OfArity ZFSet ZFSet n) ⟦x⟧ = eval n (Resp.f f x) 
goal: PSet.Resp.eval (n + 1) f ⟦x⟧ = PSet.Resp.eval n (f.f x)

full_name: PSet.Definable
code: /-- A set function is "definable" if it is the image of some n-ary pre-set
  function. This isn't exactly definability, but is useful as a sufficient
  condition for functions that have a computable image. -/
class inductive Definable (n) : OfArity ZFSet.{u} ZFSet.{u} n → Type (u + 1)
  | mk (f) : Definable n (Resp.eval n f)
goal: Function.OfArity ZFSet ZFSet n → Type (u + 1)

full_name: PSet.Definable.mk
code: /-- A set function is "definable" if it is the image of some n-ary pre-set
  function. This isn't exactly definability, but is useful as a sufficient
  condition for functions that have a computable image. -/
class inductive Definable (n) : OfArity ZFSet.{u} ZFSet.{u} n → Type (u + 1)
  | mk (f) : Definable n (Resp.eval n f)
goal: PSet.Definable n (PSet.Resp.eval n f)

full_name: PSet.Definable.EqMk
code: /-- The evaluation of a function respecting equivalence is definable, by that same function. -/
def Definable.EqMk {n} (f) :
    ∀ {s : OfArity ZFSet.{u} ZFSet.{u} n} (_ : Resp.eval _ f = s), Definable n s
  
goal: PSet.Resp.eval n f = s → PSet.Definable n s

full_name: PSet.Definable.Resp
code: /-- Turns a definable function into a function that respects equivalence. -/
def Definable.Resp {n} : ∀ (s : OfArity ZFSet.{u} ZFSet.{u} n) [Definable n s], Resp n
  
goal: PSet.Resp n

full_name: PSet.Definable.eq
code: theorem Definable.eq {n} :
    ∀ (s : OfArity ZFSet.{u} ZFSet.{u} n) [H : Definable n s], (@Definable.Resp n s H).eval _ = s
  
goal: PSet.Resp.eval n (PSet.Definable.Resp s) = s

full_name: Classical.allDefinable
code: /-- All functions are classically definable. -/
noncomputable def allDefinable : ∀ {n} (F : OfArity ZFSet ZFSet n), Definable n F
  
goal: PSet.Definable n F

full_name: ZFSet.mk
code: /-- Turns a pre-set into a ZFC set. -/
def mk : PSet → ZFSet 
goal: PSet → ZFSet

full_name: ZFSet.mk_eq
code: @[simp]
theorem mk_eq (x : PSet) : @Eq ZFSet ⟦x⟧ (mk x) 
goal: ⟦x⟧ = ZFSet.mk x

full_name: ZFSet.mk_out
code: @[simp]
theorem mk_out : ∀ x : ZFSet, mk x.out = x 
goal: ZFSet.mk (Quotient.out x) = x

full_name: ZFSet.eq
code: theorem eq {x y : PSet} : mk x = mk y ↔ Equiv x y 
goal: ZFSet.mk x = ZFSet.mk y ↔ x.Equiv y

full_name: ZFSet.sound
code: theorem sound {x y : PSet} (h : PSet.Equiv x y) : mk x = mk y 
goal: ZFSet.mk x = ZFSet.mk y

full_name: ZFSet.exact
code: theorem exact {x y : PSet} : mk x = mk y → PSet.Equiv x y 
goal: ZFSet.mk x = ZFSet.mk y → x.Equiv y

full_name: ZFSet.eval_mk
code: @[simp]
theorem eval_mk {n f x} :
    (@Resp.eval (n + 1) f : ZFSet → OfArity ZFSet ZFSet n) (mk x) = Resp.eval n (Resp.f f x) 
goal: PSet.Resp.eval (n + 1) f (ZFSet.mk x) = PSet.Resp.eval n (f.f x)

full_name: ZFSet.Mem
code: /-- The membership relation for ZFC sets is inherited from the membership relation for pre-sets. -/
protected def Mem : ZFSet → ZFSet → Prop 
goal: ZFSet → ZFSet → Prop

full_name: ZFSet.instMembership
code: instance : Membership ZFSet ZFSet 
goal: Membership ZFSet ZFSet

full_name: ZFSet.mk_mem_iff
code: @[simp]
theorem mk_mem_iff {x y : PSet} : mk x ∈ mk y ↔ x ∈ y 
goal: ZFSet.mk x ∈ ZFSet.mk y ↔ x ∈ y

full_name: ZFSet.toSet
code: /-- Convert a ZFC set into a `Set` of ZFC sets -/
def toSet (u : ZFSet.{u}) : Set ZFSet.{u} 
goal: Set ZFSet

full_name: ZFSet.mem_toSet
code: @[simp]
theorem mem_toSet (a u : ZFSet.{u}) : a ∈ u.toSet ↔ a ∈ u 
goal: a ∈ u.toSet ↔ a ∈ u

full_name: ZFSet.small_toSet
code: instance small_toSet (x : ZFSet.{u}) : Small.{u} x.toSet 
goal: Small.{u, u + 1} ↑x.toSet

full_name: ZFSet.Nonempty
code: /-- A nonempty set is one that contains some element. -/
protected def Nonempty (u : ZFSet) : Prop 
goal: Prop

full_name: ZFSet.nonempty_def
code: theorem nonempty_def (u : ZFSet) : u.Nonempty ↔ ∃ x, x ∈ u 
goal: u.Nonempty ↔ ∃ x, x ∈ u

full_name: ZFSet.nonempty_of_mem
code: theorem nonempty_of_mem {x u : ZFSet} (h : x ∈ u) : u.Nonempty 
goal: u.Nonempty

full_name: ZFSet.nonempty_toSet_iff
code: @[simp]
theorem nonempty_toSet_iff {u : ZFSet} : u.toSet.Nonempty ↔ u.Nonempty 
goal: u.toSet.Nonempty ↔ u.Nonempty

full_name: ZFSet.Subset
code: /-- `x ⊆ y` as ZFC sets means that all members of `x` are members of `y`. -/
protected def Subset (x y : ZFSet.{u}) 
goal: Prop

full_name: ZFSet.hasSubset
code: instance hasSubset : HasSubset ZFSet 
goal: HasSubset ZFSet

full_name: ZFSet.subset_def
code: theorem subset_def {x y : ZFSet.{u}} : x ⊆ y ↔ ∀ ⦃z⦄, z ∈ x → z ∈ y 
goal: x ⊆ y ↔ ∀ ⦃z : ZFSet⦄, z ∈ x → z ∈ y

full_name: ZFSet.instIsReflSubset
code: instance : IsRefl ZFSet (· ⊆ ·) 
goal: IsRefl ZFSet fun x x_1 => x ⊆ x_1

full_name: ZFSet.instIsTransSubset
code: instance : IsTrans ZFSet (· ⊆ ·) 
goal: IsTrans ZFSet fun x x_1 => x ⊆ x_1

full_name: ZFSet.subset_iff
code: @[simp]
theorem subset_iff : ∀ {x y : PSet}, mk x ⊆ mk y ↔ x ⊆ y
  
goal: ZFSet.mk x ⊆ ZFSet.mk y ↔ x ⊆ y

full_name: ZFSet.toSet_subset_iff
code: @[simp]
theorem toSet_subset_iff {x y : ZFSet} : x.toSet ⊆ y.toSet ↔ x ⊆ y 
goal: x.toSet ⊆ y.toSet ↔ x ⊆ y

full_name: ZFSet.ext
code: @[ext]
theorem ext {x y : ZFSet.{u}} : (∀ z : ZFSet.{u}, z ∈ x ↔ z ∈ y) → x = y 
goal: (∀ (z : ZFSet), z ∈ x ↔ z ∈ y) → x = y

full_name: ZFSet.ext_iff
code: theorem ext_iff {x y : ZFSet.{u}} : x = y ↔ ∀ z : ZFSet.{u}, z ∈ x ↔ z ∈ y 
goal: x = y ↔ ∀ (z : ZFSet), z ∈ x ↔ z ∈ y

full_name: ZFSet.toSet_injective
code: theorem toSet_injective : Function.Injective toSet 
goal: Function.Injective ZFSet.toSet

full_name: ZFSet.toSet_inj
code: @[simp]
theorem toSet_inj {x y : ZFSet} : x.toSet = y.toSet ↔ x = y 
goal: x.toSet = y.toSet ↔ x = y

full_name: ZFSet.instIsAntisymmSubset
code: instance : IsAntisymm ZFSet (· ⊆ ·) 
goal: IsAntisymm ZFSet fun x x_1 => x ⊆ x_1

full_name: ZFSet.empty
code: /-- The empty ZFC set -/
protected def empty : ZFSet 
goal: ZFSet

full_name: ZFSet.instEmptyCollection
code: instance : EmptyCollection ZFSet 
goal: EmptyCollection ZFSet

full_name: ZFSet.instInhabited
code: instance : Inhabited ZFSet 
goal: Inhabited ZFSet

full_name: ZFSet.not_mem_empty
code: @[simp]
theorem not_mem_empty (x) : x ∉ (∅ : ZFSet.{u}) 
goal: x ∉ ∅

full_name: ZFSet.toSet_empty
code: @[simp]
theorem toSet_empty : toSet ∅ = ∅ 
goal: ∅.toSet = ∅

full_name: ZFSet.empty_subset
code: @[simp]
theorem empty_subset (x : ZFSet.{u}) : (∅ : ZFSet) ⊆ x 
goal: ∅ ⊆ x

full_name: ZFSet.not_nonempty_empty
code: @[simp]
theorem not_nonempty_empty : ¬ZFSet.Nonempty ∅ 
goal: ¬∅.Nonempty

full_name: ZFSet.nonempty_mk_iff
code: @[simp]
theorem nonempty_mk_iff {x : PSet} : (mk x).Nonempty ↔ x.Nonempty 
goal: (ZFSet.mk x).Nonempty ↔ x.Nonempty

full_name: ZFSet.eq_empty
code: theorem eq_empty (x : ZFSet.{u}) : x = ∅ ↔ ∀ y : ZFSet.{u}, y ∉ x 
goal: x = ∅ ↔ ∀ (y : ZFSet), y ∉ x

full_name: ZFSet.eq_empty_or_nonempty
code: theorem eq_empty_or_nonempty (u : ZFSet) : u = ∅ ∨ u.Nonempty 
goal: u = ∅ ∨ u.Nonempty

full_name: ZFSet.Insert
code: /-- `Insert x y` is the set `{x} ∪ y` -/
protected def Insert : ZFSet → ZFSet → ZFSet 
goal: ZFSet → ZFSet → ZFSet

full_name: ZFSet.instInsert
code: instance : Insert ZFSet ZFSet 
goal: Insert ZFSet ZFSet

full_name: ZFSet.instSingleton
code: instance : Singleton ZFSet ZFSet 
goal: Singleton ZFSet ZFSet

full_name: ZFSet.instLawfulSingleton
code: instance : LawfulSingleton ZFSet ZFSet 
goal: LawfulSingleton ZFSet ZFSet

full_name: ZFSet.mem_insert_iff
code: @[simp]
theorem mem_insert_iff {x y z : ZFSet.{u}} : x ∈ insert y z ↔ x = y ∨ x ∈ z 
goal: x ∈ insert y z ↔ x = y ∨ x ∈ z

full_name: ZFSet.mem_insert
code: theorem mem_insert (x y : ZFSet) : x ∈ insert x y 
goal: x ∈ insert x y

full_name: ZFSet.mem_insert_of_mem
code: theorem mem_insert_of_mem {y z : ZFSet} (x) (h : z ∈ y) : z ∈ insert x y 
goal: z ∈ insert x y

full_name: ZFSet.toSet_insert
code: @[simp]
theorem toSet_insert (x y : ZFSet) : (insert x y).toSet = insert x y.toSet 
goal: (insert x y).toSet = insert x y.toSet

full_name: ZFSet.mem_singleton
code: @[simp]
theorem mem_singleton {x y : ZFSet.{u}} : x ∈ @singleton ZFSet.{u} ZFSet.{u} _ y ↔ x = y 
goal: x ∈ {y} ↔ x = y

full_name: ZFSet.toSet_singleton
code: @[simp]
theorem toSet_singleton (x : ZFSet) : ({x} : ZFSet).toSet = {x} 
goal: {x}.toSet = {x}

full_name: ZFSet.insert_nonempty
code: theorem insert_nonempty (u v : ZFSet) : (insert u v).Nonempty 
goal: (insert u v).Nonempty

full_name: ZFSet.singleton_nonempty
code: theorem singleton_nonempty (u : ZFSet) : ZFSet.Nonempty {u} 
goal: {u}.Nonempty

full_name: ZFSet.mem_pair
code: theorem mem_pair {x y z : ZFSet.{u}} : x ∈ ({y, z} : ZFSet) ↔ x = y ∨ x = z 
goal: x ∈ {y, z} ↔ x = y ∨ x = z

full_name: ZFSet.omega
code: /-- `omega` is the first infinite von Neumann ordinal -/
def omega : ZFSet 
goal: ZFSet

full_name: ZFSet.omega_zero
code: @[simp]
theorem omega_zero : ∅ ∈ omega 
goal: ∅ ∈ ZFSet.omega

full_name: ZFSet.omega_succ
code: @[simp]
theorem omega_succ {n} : n ∈ omega.{u} → insert n n ∈ omega.{u} 
goal: n ∈ ZFSet.omega → insert n n ∈ ZFSet.omega

full_name: ZFSet.sep
code: /-- `{x ∈ a | p x}` is the set of elements in `a` satisfying `p` -/
protected def sep (p : ZFSet → Prop) : ZFSet → ZFSet 
goal: ZFSet → ZFSet

full_name: ZFSet.instSep
code: instance : Sep ZFSet ZFSet 
goal: Sep ZFSet ZFSet

full_name: ZFSet.mem_sep
code: @[simp]
theorem mem_sep {p : ZFSet.{u} → Prop} {x y : ZFSet.{u}} :
    y ∈ ZFSet.sep p x ↔ y ∈ x ∧ p y 
goal: y ∈ ZFSet.sep p x ↔ y ∈ x ∧ p y

full_name: ZFSet.toSet_sep
code: @[simp]
theorem toSet_sep (a : ZFSet) (p : ZFSet → Prop) :
    (ZFSet.sep p a).toSet = { x ∈ a.toSet | p x } 
goal: (ZFSet.sep p a).toSet = {x | x ∈ a.toSet ∧ p x}

full_name: ZFSet.powerset
code: /-- The powerset operation, the collection of subsets of a ZFC set -/
def powerset : ZFSet → ZFSet 
goal: ZFSet → ZFSet

full_name: ZFSet.mem_powerset
code: @[simp]
theorem mem_powerset {x y : ZFSet.{u}} : y ∈ powerset x ↔ y ⊆ x 
goal: y ∈ x.powerset ↔ y ⊆ x

full_name: ZFSet.sUnion_lem
code: theorem 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)
  
goal: ∃ b, ((⋃₀ PSet.mk α A).Func a).Equiv ((⋃₀ PSet.mk β B).Func b)

full_name: ZFSet.sUnion
code: /-- The union operator, the collection of elements of elements of a ZFC set -/
def sUnion : ZFSet → ZFSet 
goal: ZFSet → ZFSet

full_name: ZFSet._aux_Mathlib_SetTheory_ZFC_Basic___unexpand_ZFSet_sUnion_1
code: @[inherit_doc]
prefix:110 "⋃₀ " => ZFSet.sUnion
goal: Lean.PrettyPrinter.Unexpander

full_name: ZFSet.«_aux_Mathlib_SetTheory_ZFC_Basic___macroRules_ZFSet_term⋃₀__1»
code: @[inherit_doc]
prefix:110 "⋃₀ " => ZFSet.sUnion
goal: Lean.Macro

full_name: ZFSet.sInter
code: /-- The intersection operator, the collection of elements in all of the elements of a ZFC set. We
special-case `⋂₀ ∅ = ∅`. -/
noncomputable def sInter (x : ZFSet) : ZFSet 
goal: ZFSet

full_name: ZFSet._aux_Mathlib_SetTheory_ZFC_Basic___unexpand_ZFSet_sInter_1
code: @[inherit_doc]
prefix:110 "⋂₀ " => ZFSet.sInter
goal: Lean.PrettyPrinter.Unexpander

full_name: ZFSet.«_aux_Mathlib_SetTheory_ZFC_Basic___macroRules_ZFSet_term⋂₀__1»
code: @[inherit_doc]
prefix:110 "⋂₀ " => ZFSet.sInter
goal: Lean.Macro

full_name: ZFSet.mem_sUnion
code: @[simp]
theorem mem_sUnion {x y : ZFSet.{u}} : y ∈ ⋃₀ x ↔ ∃ z ∈ x, y ∈ z 
goal: y ∈ ⋃₀ x ↔ ∃ z ∈ x, y ∈ z

full_name: ZFSet.mem_sInter
code: theorem mem_sInter {x y : ZFSet} (h : x.Nonempty) : y ∈ ⋂₀ x ↔ ∀ z ∈ x, y ∈ z 
goal: y ∈ ⋂₀ x ↔ ∀ z ∈ x, y ∈ z

full_name: ZFSet.sUnion_empty
code: @[simp]
theorem sUnion_empty : ⋃₀ (∅ : ZFSet.{u}) = ∅ 
goal: ⋃₀ ∅ = ∅

full_name: ZFSet.sInter_empty
code: @[simp]
theorem sInter_empty : ⋂₀ (∅ : ZFSet) = ∅ 
goal: ⋂₀ ∅ = ∅

full_name: ZFSet.mem_of_mem_sInter
code: theorem mem_of_mem_sInter {x y z : ZFSet} (hy : y ∈ ⋂₀ x) (hz : z ∈ x) : y ∈ z 
goal: y ∈ z

full_name: ZFSet.mem_sUnion_of_mem
code: theorem mem_sUnion_of_mem {x y z : ZFSet} (hy : y ∈ z) (hz : z ∈ x) : y ∈ ⋃₀ x 
goal: y ∈ ⋃₀ x

full_name: ZFSet.not_mem_sInter_of_not_mem
code: theorem not_mem_sInter_of_not_mem {x y z : ZFSet} (hy : ¬y ∈ z) (hz : z ∈ x) : ¬y ∈ ⋂₀ x 
goal: y ∉ ⋂₀ x

full_name: ZFSet.sUnion_singleton
code: @[simp]
theorem sUnion_singleton {x : ZFSet.{u}} : ⋃₀ ({x} : ZFSet) = x 
goal: ⋃₀ {x} = x

full_name: ZFSet.sInter_singleton
code: @[simp]
theorem sInter_singleton {x : ZFSet.{u}} : ⋂₀ ({x} : ZFSet) = x 
goal: ⋂₀ {x} = x

full_name: ZFSet.toSet_sUnion
code: @[simp]
theorem toSet_sUnion (x : ZFSet.{u}) : (⋃₀ x).toSet = ⋃₀ (toSet '' x.toSet) 
goal: (⋃₀ x).toSet = ⋃₀ (ZFSet.toSet '' x.toSet)

full_name: ZFSet.toSet_sInter
code: theorem toSet_sInter {x : ZFSet.{u}} (h : x.Nonempty) : (⋂₀ x).toSet = ⋂₀ (toSet '' x.toSet) 
goal: (⋂₀ x).toSet = ⋂₀ (ZFSet.toSet '' x.toSet)

full_name: ZFSet.singleton_injective
code: theorem singleton_injective : Function.Injective (@singleton ZFSet ZFSet _) 
goal: Function.Injective singleton

full_name: ZFSet.singleton_inj
code: @[simp]
theorem singleton_inj {x y : ZFSet} : ({x} : ZFSet) = {y} ↔ x = y 
goal: {x} = {y} ↔ x = y

full_name: ZFSet.union
code: /-- The binary union operation -/
protected def union (x y : ZFSet.{u}) : ZFSet.{u} 
goal: ZFSet

full_name: ZFSet.inter
code: /-- The binary intersection operation -/
protected def inter (x y : ZFSet.{u}) : ZFSet.{u} 
goal: ZFSet

full_name: ZFSet.diff
code: /-- The set difference operation -/
protected def diff (x y : ZFSet.{u}) : ZFSet.{u} 
goal: ZFSet

full_name: ZFSet.instUnion
code: instance : Union ZFSet 
goal: Union ZFSet

full_name: ZFSet.instInter
code: instance : Inter ZFSet 
goal: Inter ZFSet

full_name: ZFSet.instSDiff
code: instance : SDiff ZFSet 
goal: SDiff ZFSet

full_name: ZFSet.toSet_union
code: @[simp]
theorem toSet_union (x y : ZFSet.{u}) : (x ∪ y).toSet = x.toSet ∪ y.toSet 
goal: (x ∪ y).toSet = x.toSet ∪ y.toSet

full_name: ZFSet.toSet_inter
code: @[simp]
theorem toSet_inter (x y : ZFSet.{u}) : (x ∩ y).toSet = x.toSet ∩ y.toSet 
goal: (x ∩ y).toSet = x.toSet ∩ y.toSet

full_name: ZFSet.toSet_sdiff
code: @[simp]
theorem toSet_sdiff (x y : ZFSet.{u}) : (x \ y).toSet = x.toSet \ y.toSet 
goal: (x \ y).toSet = x.toSet \ y.toSet

full_name: ZFSet.mem_union
code: @[simp]
theorem mem_union {x y z : ZFSet.{u}} : z ∈ x ∪ y ↔ z ∈ x ∨ z ∈ y 
goal: z ∈ x ∪ y ↔ z ∈ x ∨ z ∈ y

full_name: ZFSet.mem_inter
code: @[simp]
theorem mem_inter {x y z : ZFSet.{u}} : z ∈ x ∩ y ↔ z ∈ x ∧ z ∈ y 
goal: z ∈ x ∩ y ↔ z ∈ x ∧ z ∈ y

full_name: ZFSet.mem_diff
code: @[simp]
theorem mem_diff {x y z : ZFSet.{u}} : z ∈ x \ y ↔ z ∈ x ∧ z ∉ y 
goal: z ∈ x \ y ↔ z ∈ x ∧ z ∉ y

full_name: ZFSet.sUnion_pair
code: @[simp]
theorem sUnion_pair {x y : ZFSet.{u}} : ⋃₀ ({x, y} : ZFSet.{u}) = x ∪ y 
goal: ⋃₀ {x, y} = x ∪ y

full_name: ZFSet.mem_wf
code: theorem mem_wf : @WellFounded ZFSet (· ∈ ·) 
goal: WellFounded fun x x_1 => x ∈ x_1

full_name: ZFSet.inductionOn
code: /-- Induction on the `∈` relation. -/
@[elab_as_elim]
theorem inductionOn {p : ZFSet → Prop} (x) (h : ∀ x, (∀ y ∈ x, p y) → p x) : p x 
goal: p x

full_name: ZFSet.instWellFoundedRelation
code: instance : WellFoundedRelation ZFSet 
goal: WellFoundedRelation ZFSet

full_name: ZFSet.instIsAsymmMem
code: instance : IsAsymm ZFSet (· ∈ ·) 
goal: IsAsymm ZFSet fun x x_1 => x ∈ x_1

full_name: ZFSet.instIsIrreflMem
code: instance : IsIrrefl ZFSet (· ∈ ·) 
goal: IsIrrefl ZFSet fun x x_1 => x ∈ x_1

full_name: ZFSet.mem_asymm
code: theorem mem_asymm {x y : ZFSet} : x ∈ y → y ∉ x 
goal: x ∈ y → y ∉ x

full_name: ZFSet.mem_irrefl
code: theorem mem_irrefl (x : ZFSet) : x ∉ x 
goal: x ∉ x

full_name: ZFSet.regularity
code: theorem regularity (x : ZFSet.{u}) (h : x ≠ ∅) : ∃ y ∈ x, x ∩ y = ∅ 
goal: ∃ y ∈ x, x ∩ y = ∅

full_name: ZFSet.image
code: /-- The image of a (definable) ZFC set function -/
def image (f : ZFSet → ZFSet) [Definable 1 f] : ZFSet → ZFSet 
goal: ZFSet → ZFSet

full_name: ZFSet.image.mk
code: theorem image.mk :
    ∀ (f : ZFSet.{u} → ZFSet.{u}) [H : Definable 1 f] (x) {y} (_ : y ∈ x), f y ∈ @image f H x
  
goal: y ∈ x → f y ∈ ZFSet.image f x

full_name: ZFSet.mem_image
code: @[simp]
theorem mem_image :
    ∀ {f : ZFSet.{u} → ZFSet.{u}} [H : Definable 1 f] {x y : ZFSet.{u}},
      y ∈ @image f H x ↔ ∃ z ∈ x, f z = y
  
goal: y ∈ ZFSet.image f x ↔ ∃ z ∈ x, f z = y

full_name: ZFSet.toSet_image
code: @[simp]
theorem toSet_image (f : ZFSet → ZFSet) [H : Definable 1 f] (x : ZFSet) :
    (image f x).toSet = f '' x.toSet 
goal: (ZFSet.image f x).toSet = f '' x.toSet

full_name: ZFSet.range
code: /-- The range of an indexed family of sets. The universes allow for a more general index type
  without manual use of `ULift`. -/
noncomputable def range {α : Type u} (f : α → ZFSet.{max u v}) : ZFSet.{max u v} 
goal: ZFSet

full_name: ZFSet.mem_range
code: @[simp]
theorem mem_range {α : Type u} {f : α → ZFSet.{max u v}} {x : ZFSet.{max u v}} :
    x ∈ range.{u, v} f ↔ x ∈ Set.range f 
goal: x ∈ ZFSet.range f ↔ x ∈ Set.range f

full_name: ZFSet.toSet_range
code: @[simp]
theorem toSet_range {α : Type u} (f : α → ZFSet.{max u v}) :
    (range.{u, v} f).toSet = Set.range f 
goal: (ZFSet.range f).toSet = Set.range f

full_name: ZFSet.pair
code: /-- Kuratowski ordered pair -/
def pair (x y : ZFSet.{u}) : ZFSet.{u} 
goal: ZFSet

full_name: ZFSet.toSet_pair
code: @[simp]
theorem toSet_pair (x y : ZFSet.{u}) : (pair x y).toSet = {{x}, {x, y}} 
goal: (x.pair y).toSet = {{x}, {x, y}}

full_name: ZFSet.pairSep
code: /-- A subset of pairs `{(a, b) ∈ x × y | p a b}` -/
def pairSep (p : ZFSet.{u} → ZFSet.{u} → Prop) (x y : ZFSet.{u}) : ZFSet.{u} 
goal: ZFSet

full_name: ZFSet.mem_pairSep
code: @[simp]
theorem mem_pairSep {p} {x y z : ZFSet.{u}} :
    z ∈ pairSep p x y ↔ ∃ a ∈ x, ∃ b ∈ y, z = pair a b ∧ p a b 
goal: z ∈ ZFSet.pairSep p x y ↔ ∃ a ∈ x, ∃ b ∈ y, z = a.pair b ∧ p a b

full_name: ZFSet.pair_injective
code: theorem pair_injective : Function.Injective2 pair 
goal: Function.Injective2 ZFSet.pair

full_name: ZFSet.pair_inj
code: @[simp]
theorem pair_inj {x y x' y' : ZFSet} : pair x y = pair x' y' ↔ x = x' ∧ y = y' 
goal: x.pair y = x'.pair y' ↔ x = x' ∧ y = y'

full_name: ZFSet.prod
code: /-- The cartesian product, `{(a, b) | a ∈ x, b ∈ y}` -/
def prod : ZFSet.{u} → ZFSet.{u} → ZFSet.{u} 
goal: ZFSet → ZFSet → ZFSet

full_name: ZFSet.mem_prod
code: @[simp]
theorem mem_prod {x y z : ZFSet.{u}} : z ∈ prod x y ↔ ∃ a ∈ x, ∃ b ∈ y, z = pair a b 
goal: z ∈ x.prod y ↔ ∃ a ∈ x, ∃ b ∈ y, z = a.pair b

full_name: ZFSet.pair_mem_prod
code: theorem pair_mem_prod {x y a b : ZFSet.{u}} : pair a b ∈ prod x y ↔ a ∈ x ∧ b ∈ y 
goal: a.pair b ∈ x.prod y ↔ a ∈ x ∧ b ∈ y

full_name: ZFSet.IsFunc
code: /-- `isFunc x y f` is the assertion that `f` is a subset of `x × y` which relates to each element
of `x` a unique element of `y`, so that we can consider `f` as a ZFC function `x → y`. -/
def IsFunc (x y f : ZFSet.{u}) : Prop 
goal: Prop

full_name: ZFSet.funs
code: /-- `funs x y` is `y ^ x`, the set of all set functions `x → y` -/
def funs (x y : ZFSet.{u}) : ZFSet.{u} 
goal: ZFSet

full_name: ZFSet.mem_funs
code: @[simp]
theorem mem_funs {x y f : ZFSet.{u}} : f ∈ funs x y ↔ IsFunc x y f 
goal: f ∈ x.funs y ↔ x.IsFunc y f

full_name: ZFSet.mapDefinableAux
code: @[nolint unusedArguments]
noncomputable instance mapDefinableAux (f : ZFSet → ZFSet) [Definable 1 f] :
    Definable 1 fun (y : ZFSet) => pair y (f y) 
goal: PSet.Definable 1 fun y => y.pair (f y)

full_name: ZFSet.map
code: /-- Graph of a function: `map f x` is the ZFC function which maps `a ∈ x` to `f a` -/
noncomputable def map (f : ZFSet → ZFSet) [Definable 1 f] : ZFSet → ZFSet 
goal: ZFSet → ZFSet

full_name: ZFSet.mem_map
code: @[simp]
theorem mem_map {f : ZFSet → ZFSet} [Definable 1 f] {x y : ZFSet} :
    y ∈ map f x ↔ ∃ z ∈ x, pair z (f z) = y 
goal: y ∈ ZFSet.map f x ↔ ∃ z ∈ x, z.pair (f z) = y

full_name: ZFSet.map_unique
code: theorem map_unique {f : ZFSet.{u} → ZFSet.{u}} [H : Definable 1 f] {x z : ZFSet.{u}}
    (zx : z ∈ x) : ∃! w, pair z w ∈ map f x 
goal: ∃! w, z.pair w ∈ ZFSet.map f x

full_name: ZFSet.map_isFunc
code: @[simp]
theorem map_isFunc {f : ZFSet → ZFSet} [Definable 1 f] {x y : ZFSet} :
    IsFunc x y (map f x) ↔ ∀ z ∈ x, f z ∈ y 
goal: x.IsFunc y (ZFSet.map f x) ↔ ∀ z ∈ x, f z ∈ y

full_name: ZFSet.Hereditarily
code: /-- Given a predicate `p` on ZFC sets. `Hereditarily p x` means that `x` has property `p` and the
members of `x` are all `Hereditarily p`. -/
def Hereditarily (p : ZFSet → Prop) (x : ZFSet) : Prop 
goal: Prop

full_name: ZFSet.hereditarily_iff
code: theorem hereditarily_iff : Hereditarily p x ↔ p x ∧ ∀ y ∈ x, Hereditarily p y 
goal: ZFSet.Hereditarily p x ↔ p x ∧ ∀ y ∈ x, ZFSet.Hereditarily p y

full_name: ZFSet.Hereditarily.self
code: theorem Hereditarily.self (h : x.Hereditarily p) : p x 
goal: p x

full_name: ZFSet.Hereditarily.mem
code: theorem Hereditarily.mem (h : x.Hereditarily p) (hy : y ∈ x) : y.Hereditarily p 
goal: ZFSet.Hereditarily p y

full_name: ZFSet.Hereditarily.empty
code: theorem Hereditarily.empty : Hereditarily p x → p ∅ 
goal: ZFSet.Hereditarily p x → p ∅

full_name: Class
code: /-- The collection of all classes.
We define `Class` as `Set ZFSet`, as this allows us to get many instances automatically. However, in
practice, we treat it as (the definitionally equal) `ZFSet → Prop`. This means, the preferred way to
state that `x : ZFSet` belongs to `A : Class` is to write `A x`. -/
def Class 
goal: Type (u_1 + 1)

full_name: instInsertZFSetClass
code: instance : Insert ZFSet Class 
goal: Insert ZFSet Class

full_name: Class.sep
code: /-- `{x ∈ A | p x}` is the class of elements in `A` satisfying `p` -/
protected def sep (p : ZFSet → Prop) (A : Class) : Class 
goal: Class

full_name: Class.ext
code: @[ext]
theorem ext {x y : Class.{u}} : (∀ z : ZFSet.{u}, x z ↔ y z) → x = y 
goal: (∀ (z : ZFSet), x z ↔ y z) → x = y

full_name: Class.ext_iff
code: theorem ext_iff {x y : Class.{u}} : x = y ↔ ∀ z, x z ↔ y z 
goal: x = y ↔ ∀ (z : ZFSet), x z ↔ y z

full_name: Class.ofSet
code: /-- Coerce a ZFC set into a class -/
@[coe]
def ofSet (x : ZFSet.{u}) : Class.{u} 
goal: Class

full_name: Class.instCoeZFSet
code: instance : Coe ZFSet Class 
goal: Coe ZFSet Class

full_name: Class.univ
code: /-- The universal class -/
def univ : Class 
goal: Class

full_name: Class.ToSet
code: /-- Assert that `A` is a ZFC set satisfying `B` -/
def ToSet (B : Class.{u}) (A : Class.{u}) : Prop 
goal: Prop

full_name: Class.Mem
code: /-- `A ∈ B` if `A` is a ZFC set which satisfies `B` -/
protected def Mem (A B : Class.{u}) : Prop 
goal: Prop

full_name: Class.instMembership
code: instance : Membership Class Class 
goal: Membership Class Class

full_name: Class.mem_def
code: theorem mem_def (A B : Class.{u}) : A ∈ B ↔ ∃ x : ZFSet, ↑x = A ∧ B x 
goal: A ∈ B ↔ ∃ x, ↑x = A ∧ B x

full_name: Class.not_mem_empty
code: @[simp]
theorem not_mem_empty (x : Class.{u}) : x ∉ (∅ : Class.{u}) 
goal: x ∉ ∅

full_name: Class.not_empty_hom
code: @[simp]
theorem not_empty_hom (x : ZFSet.{u}) : ¬(∅ : Class.{u}) x 
goal: ¬∅ x

full_name: Class.mem_univ
code: @[simp]
theorem mem_univ {A : Class.{u}} : A ∈ univ.{u} ↔ ∃ x : ZFSet.{u}, ↑x = A 
goal: A ∈ Class.univ ↔ ∃ x, ↑x = A

full_name: Class.mem_univ_hom
code: @[simp]
theorem mem_univ_hom (x : ZFSet.{u}) : univ.{u} x 
goal: Class.univ x

full_name: Class.eq_univ_iff_forall
code: theorem eq_univ_iff_forall {A : Class.{u}} : A = univ ↔ ∀ x : ZFSet, A x 
goal: A = Class.univ ↔ ∀ (x : ZFSet), A x

full_name: Class.eq_univ_of_forall
code: theorem eq_univ_of_forall {A : Class.{u}} : (∀ x : ZFSet, A x) → A = univ 
goal: (∀ (x : ZFSet), A x) → A = Class.univ

full_name: Class.mem_wf
code: theorem mem_wf : @WellFounded Class.{u} (· ∈ ·) 
goal: WellFounded fun x x_1 => x ∈ x_1

full_name: Class.instWellFoundedRelation
code: instance : WellFoundedRelation Class 
goal: WellFoundedRelation Class

full_name: Class.instIsAsymmMem
code: instance : IsAsymm Class (· ∈ ·) 
goal: IsAsymm Class fun x x_1 => x ∈ x_1

full_name: Class.instIsIrreflMem
code: instance : IsIrrefl Class (· ∈ ·) 
goal: IsIrrefl Class fun x x_1 => x ∈ x_1

full_name: Class.mem_asymm
code: theorem mem_asymm {x y : Class} : x ∈ y → y ∉ x 
goal: x ∈ y → y ∉ x

full_name: Class.mem_irrefl
code: theorem mem_irrefl (x : Class) : x ∉ x 
goal: x ∉ x

full_name: Class.univ_not_mem_univ
code: /-- **There is no universal set.**
This is stated as `univ ∉ univ`, meaning that `univ` (the class of all sets) is proper (does not
belong to the class of all sets). -/
theorem univ_not_mem_univ : univ ∉ univ 
goal: Class.univ ∉ Class.univ

full_name: Class.congToClass
code: /-- Convert a conglomerate (a collection of classes) into a class -/
def congToClass (x : Set Class.{u}) : Class.{u} 
goal: Class

full_name: Class.congToClass_empty
code: @[simp]
theorem congToClass_empty : congToClass ∅ = ∅ 
goal: Class.congToClass ∅ = ∅

full_name: Class.classToCong
code: /-- Convert a class into a conglomerate (a collection of classes) -/
def classToCong (x : Class.{u}) : Set Class.{u} 
goal: Set Class

full_name: Class.classToCong_empty
code: @[simp]
theorem classToCong_empty : classToCong ∅ = ∅ 
goal: ∅.classToCong = ∅

full_name: Class.powerset
code: /-- The power class of a class is the class of all subclasses that are ZFC sets -/
def powerset (x : Class) : Class 
goal: Class

full_name: Class.sUnion
code: /-- The union of a class is the class of all members of ZFC sets in the class -/
def sUnion (x : Class) : Class 
goal: Class

full_name: Class.«_aux_Mathlib_SetTheory_ZFC_Basic___macroRules_Class_term⋃₀__1»
code: @[inherit_doc]
prefix:110 "⋃₀ " => Class.sUnion
goal: Lean.Macro

full_name: Class._aux_Mathlib_SetTheory_ZFC_Basic___unexpand_Class_sUnion_1
code: @[inherit_doc]
prefix:110 "⋃₀ " => Class.sUnion
goal: Lean.PrettyPrinter.Unexpander

full_name: Class.sInter
code: /-- The intersection of a class is the class of all members of ZFC sets in the class -/
def sInter (x : Class) : Class 
goal: Class

full_name: Class._aux_Mathlib_SetTheory_ZFC_Basic___unexpand_Class_sInter_1
code: @[inherit_doc]
prefix:110 "⋂₀ " => Class.sInter
goal: Lean.PrettyPrinter.Unexpander

full_name: Class.«_aux_Mathlib_SetTheory_ZFC_Basic___macroRules_Class_term⋂₀__1»
code: @[inherit_doc]
prefix:110 "⋂₀ " => Class.sInter
goal: Lean.Macro

full_name: Class.ofSet.inj
code: theorem ofSet.inj {x y : ZFSet.{u}} (h : (x : Class.{u}) = y) : x = y 
goal: x = y

full_name: Class.toSet_of_ZFSet
code: @[simp]
theorem toSet_of_ZFSet (A : Class.{u}) (x : ZFSet.{u}) : ToSet A x ↔ A x 
goal: A.ToSet ↑x ↔ A x

full_name: Class.coe_mem
code: @[simp, norm_cast]
theorem coe_mem {x : ZFSet.{u}} {A : Class.{u}} : ↑x ∈ A ↔ A x 
goal: ↑x ∈ A ↔ A x

full_name: Class.coe_apply
code: @[simp]
theorem coe_apply {x y : ZFSet.{u}} : (y : Class.{u}) x ↔ x ∈ y 
goal: ↑y x ↔ x ∈ y

full_name: Class.coe_subset
code: @[simp, norm_cast]
theorem coe_subset (x y : ZFSet.{u}) : (x : Class.{u}) ⊆ y ↔ x ⊆ y 
goal: ↑x ⊆ ↑y ↔ x ⊆ y

full_name: Class.coe_sep
code: @[simp, norm_cast]
theorem coe_sep (p : Class.{u}) (x : ZFSet.{u}) :
    (ZFSet.sep p x : Class) = { y ∈ x | p y } 
goal: ↑(ZFSet.sep p x) = {y | y ∈ x ∧ p y}

full_name: Class.coe_empty
code: @[simp, norm_cast]
theorem coe_empty : ↑(∅ : ZFSet.{u}) = (∅ : Class.{u}) 
goal: ↑∅ = ∅

full_name: Class.coe_insert
code: @[simp, norm_cast]
theorem coe_insert (x y : ZFSet.{u}) : ↑(insert x y) = @insert ZFSet.{u} Class.{u} _ x y 
goal: ↑(insert x y) = insert x ↑y

full_name: Class.coe_union
code: @[simp, norm_cast]
theorem coe_union (x y : ZFSet.{u}) : ↑(x ∪ y) = (x : Class.{u}) ∪ y 
goal: ↑(x ∪ y) = ↑x ∪ ↑y

full_name: Class.coe_inter
code: @[simp, norm_cast]
theorem coe_inter (x y : ZFSet.{u}) : ↑(x ∩ y) = (x : Class.{u}) ∩ y 
goal: ↑(x ∩ y) = ↑x ∩ ↑y

full_name: Class.coe_diff
code: @[simp, norm_cast]
theorem coe_diff (x y : ZFSet.{u}) : ↑(x \ y) = (x : Class.{u}) \ y 
goal: ↑(x \ y) = ↑x \ ↑y

full_name: Class.coe_powerset
code: @[simp, norm_cast]
theorem coe_powerset (x : ZFSet.{u}) : ↑x.powerset = powerset.{u} x 
goal: ↑x.powerset = (↑x).powerset

full_name: Class.powerset_apply
code: @[simp]
theorem powerset_apply {A : Class.{u}} {x : ZFSet.{u}} : powerset A x ↔ ↑x ⊆ A 
goal: A.powerset x ↔ ↑x ⊆ A

full_name: Class.sUnion_apply
code: @[simp]
theorem sUnion_apply {x : Class} {y : ZFSet} : (⋃₀ x) y ↔ ∃ z : ZFSet, x z ∧ y ∈ z 
goal: (⋃₀ x) y ↔ ∃ z, x z ∧ y ∈ z

full_name: Class.coe_sUnion
code: @[simp, norm_cast]
theorem coe_sUnion (x : ZFSet.{u}) : ↑(⋃₀ x : ZFSet) = ⋃₀ (x : Class.{u}) 
goal: ↑(⋃₀ x) = ⋃₀ ↑x

full_name: Class.mem_sUnion
code: @[simp]
theorem mem_sUnion {x y : Class.{u}} : y ∈ ⋃₀ x ↔ ∃ z, z ∈ x ∧ y ∈ z 
goal: y ∈ ⋃₀ x ↔ ∃ z ∈ x, y ∈ z

full_name: Class.sInter_apply
code: theorem sInter_apply {x : Class.{u}} {y : ZFSet.{u}} : (⋂₀ x) y ↔ ∀ z : ZFSet.{u}, x z → y ∈ z 
goal: (⋂₀ x) y ↔ ∀ (z : ZFSet), x z → y ∈ z

full_name: Class.coe_sInter
code: @[simp, norm_cast]
theorem coe_sInter {x : ZFSet.{u}} (h : x.Nonempty) : ↑(⋂₀ x : ZFSet) = ⋂₀ (x : Class.{u}) 
goal: ↑(⋂₀ x) = ⋂₀ ↑x

full_name: Class.mem_of_mem_sInter
code: theorem mem_of_mem_sInter {x y z : Class} (hy : y ∈ ⋂₀ x) (hz : z ∈ x) : y ∈ z 
goal: y ∈ z

full_name: Class.mem_sInter
code: theorem mem_sInter {x y : Class.{u}} (h : x.Nonempty) : y ∈ ⋂₀ x ↔ ∀ z, z ∈ x → y ∈ z 
goal: y ∈ ⋂₀ x ↔ ∀ z ∈ x, y ∈ z

full_name: Class.sUnion_empty
code: @[simp]
theorem sUnion_empty : ⋃₀ (∅ : Class.{u}) = (∅ : Class.{u}) 
goal: ⋃₀ ∅ = ∅

full_name: Class.sInter_empty
code: @[simp]
theorem sInter_empty : ⋂₀ (∅ : Class.{u}) = univ 
goal: ⋂₀ ∅ = Class.univ

full_name: Class.eq_univ_of_powerset_subset
code: /-- An induction principle for sets. If every subset of a class is a member, then the class is
  universal. -/
theorem eq_univ_of_powerset_subset {A : Class} (hA : powerset A ⊆ A) : A = univ 
goal: A = Class.univ

full_name: Class.iota
code: /-- The definite description operator, which is `{x}` if `{y | A y} = {x}` and `∅` otherwise. -/
def iota (A : Class) : Class 
goal: Class

full_name: Class.iota_val
code: theorem iota_val (A : Class) (x : ZFSet) (H : ∀ y, A y ↔ y = x) : iota A = ↑x 
goal: A.iota = ↑x

full_name: Class.iota_ex
code: /-- Unlike the other set constructors, the `iota` definite descriptor
  is a set for any set input, but not constructively so, so there is no
  associated `Class → Set` function. -/
theorem iota_ex (A) : iota.{u} A ∈ univ.{u} 
goal: A.iota ∈ Class.univ

full_name: Class.fval
code: /-- Function value -/
def fval (F A : Class.{u}) : Class.{u} 
goal: Class

full_name: Class.«_aux_Mathlib_SetTheory_ZFC_Basic___macroRules_Class_term_′__1»
code: @[inherit_doc]
infixl:100 " ′ " => fval
goal: Lean.Macro

full_name: Class._aux_Mathlib_SetTheory_ZFC_Basic___unexpand_Class_fval_1
code: @[inherit_doc]
infixl:100 " ′ " => fval
goal: Lean.PrettyPrinter.Unexpander

full_name: Class.fval_ex
code: theorem fval_ex (F A : Class.{u}) : F ′ A ∈ univ.{u} 
goal: F ′ A ∈ Class.univ

full_name: ZFSet.map_fval
code: @[simp]
theorem map_fval {f : ZFSet.{u} → ZFSet.{u}} [H : PSet.Definable 1 f] {x y : ZFSet.{u}}
    (h : y ∈ x) : (ZFSet.map f x ′ y : Class.{u}) = f y 
goal: ↑(ZFSet.map f x) ′ ↑y = ↑(f y)

full_name: ZFSet.choice
code: /-- A choice function on the class of nonempty ZFC sets. -/
noncomputable def choice : ZFSet 
goal: ZFSet

full_name: ZFSet.choice_mem_aux
code: theorem choice_mem_aux (h : ∅ ∉ x) (y : ZFSet.{u}) (yx : y ∈ x) :
    (Classical.epsilon fun z : ZFSet.{u} => z ∈ y) ∈ y 
goal: (Classical.epsilon fun z => z ∈ y) ∈ y

full_name: ZFSet.choice_isFunc
code: theorem choice_isFunc (h : ∅ ∉ x) : IsFunc x (⋃₀ x) (choice x) 
goal: x.IsFunc (⋃₀ x) x.choice

full_name: ZFSet.choice_mem
code: theorem choice_mem (h : ∅ ∉ x) (y : ZFSet.{u}) (yx : y ∈ x) :
    (choice x ′ y : Class.{u}) ∈ (y : Class.{u}) 
goal: ↑x.choice ′ ↑y ∈ ↑y

full_name: _private.Mathlib.SetTheory.ZFC.Basic.0.ZFSet.toSet_equiv_aux
code: private lemma toSet_equiv_aux {s : Set ZFSet.{u}} (hs : Small.{u} s) :
  (mk <| PSet.mk (Shrink s) fun x ↦ ((equivShrink s).symm x).1.out).toSet = s 
goal: (ZFSet.mk (PSet.mk (Shrink.{u, u + 1} ↑s) fun x => Quotient.out ↑((equivShrink ↑s).symm x))).toSet = s

full_name: ZFSet.toSet_equiv_apply_coe
code: /-- `ZFSet.toSet` as an equivalence. -/
@[simps apply_coe]
noncomputable def toSet_equiv : ZFSet.{u} ≃ {s : Set ZFSet.{u} // Small.{u, u+1} s} 
goal: ↑(ZFSet.toSet_equiv x) = x.toSet

full_name: ZFSet.toSet_equiv
code: /-- `ZFSet.toSet` as an equivalence. -/
@[simps apply_coe]
noncomputable def toSet_equiv : ZFSet.{u} ≃ {s : Set ZFSet.{u} // Small.{u, u+1} s} 
goal: ZFSet ≃ { s // Small.{u, u + 1} ↑s }