ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
-- PSet.Resp.Equiv.symm
@[symm]
protected theorem Resp.Equiv.symm {n} {a b : Resp n} : Resp.Equiv a b → Resp.Equiv b a 
Arguments: {n : ℕ} {a b : PSet.Resp n}
Goal: a.Equiv b → b.Equiv a
-- PSet.Resp.Equiv.trans
@[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 
Arguments: {n : ℕ} {x y z : PSet.Resp n} (h1 : x.Equiv y) (h2 : y.Equiv z)
Goal: x.Equiv z
-- PSet.Resp.eval_val
theorem eval_val {n f x} :
    (@eval (n + 1) f : ZFSet → OfArity ZFSet ZFSet n) ⟦x⟧ = eval n (Resp.f f x) 
Arguments: {n : ℕ} {f : PSet.Resp (n + 1)} {x : PSet}
Goal: PSet.Resp.eval (n + 1) f ⟦x⟧ = PSet.Resp.eval n (f.f x)
-- PSet.Definable.eq
theorem Definable.eq {n} :
    ∀ (s : OfArity ZFSet.{u} ZFSet.{u} n) [H : Definable n s], (@Definable.Resp n s H).eval _ = s
  
Arguments: {n : ℕ} (s : Function.OfArity ZFSet ZFSet n) [H : PSet.Definable n s]
Goal: PSet.Resp.eval n (PSet.Definable.Resp s) = s
-- ZFSet.mk_eq
@[simp]
theorem mk_eq (x : PSet) : @Eq ZFSet ⟦x⟧ (mk x) 
Arguments: (x : PSet)
Goal: ⟦x⟧ = ZFSet.mk x
-- ZFSet.mk_out
@[simp]
theorem mk_out : ∀ x : ZFSet, mk x.out = x 
Arguments: (x : ZFSet)
Goal: ZFSet.mk (Quotient.out x) = x
-- ZFSet.eq
theorem eq {x y : PSet} : mk x = mk y ↔ Equiv x y 
Arguments: {x y : PSet}
Goal: ZFSet.mk x = ZFSet.mk y ↔ x.Equiv y
-- ZFSet.sound
theorem sound {x y : PSet} (h : PSet.Equiv x y) : mk x = mk y 
Arguments: {x y : PSet} (h : x.Equiv y)
Goal: ZFSet.mk x = ZFSet.mk y
-- ZFSet.exact
theorem exact {x y : PSet} : mk x = mk y → PSet.Equiv x y 
Arguments: {x y : PSet}
Goal: ZFSet.mk x = ZFSet.mk y → x.Equiv y
-- ZFSet.eval_mk
@[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) 
Arguments: {n : ℕ} {f : PSet.Resp (n + 1)} {x : PSet}
Goal: PSet.Resp.eval (n + 1) f (ZFSet.mk x) = PSet.Resp.eval n (f.f x)
-- ZFSet.mk_mem_iff
@[simp]
theorem mk_mem_iff {x y : PSet} : mk x ∈ mk y ↔ x ∈ y 
Arguments: {x y : PSet}
Goal: ZFSet.mk x ∈ ZFSet.mk y ↔ x ∈ y
-- ZFSet.mem_toSet
@[simp]
theorem mem_toSet (a u : ZFSet.{u}) : a ∈ u.toSet ↔ a ∈ u 
Arguments: (a u : ZFSet)
Goal: a ∈ u.toSet ↔ a ∈ u
-- ZFSet.nonempty_def
theorem nonempty_def (u : ZFSet) : u.Nonempty ↔ ∃ x, x ∈ u 
Arguments: (u : ZFSet)
Goal: u.Nonempty ↔ ∃ x, x ∈ u
-- ZFSet.nonempty_of_mem
theorem nonempty_of_mem {x u : ZFSet} (h : x ∈ u) : u.Nonempty 
Arguments: {x u : ZFSet} (h : x ∈ u)
Goal: u.Nonempty
-- ZFSet.nonempty_toSet_iff
@[simp]
theorem nonempty_toSet_iff {u : ZFSet} : u.toSet.Nonempty ↔ u.Nonempty 
Arguments: {u : ZFSet}
Goal: u.toSet.Nonempty ↔ u.Nonempty
-- ZFSet.subset_def
theorem subset_def {x y : ZFSet.{u}} : x ⊆ y ↔ ∀ ⦃z⦄, z ∈ x → z ∈ y 
Arguments: {x y : ZFSet}
Goal: x ⊆ y ↔ ∀ ⦃z : ZFSet⦄, z ∈ x → z ∈ y
-- ZFSet.subset_iff
@[simp]
theorem subset_iff : ∀ {x y : PSet}, mk x ⊆ mk y ↔ x ⊆ y
  
Arguments: {x y : PSet}
Goal: ZFSet.mk x ⊆ ZFSet.mk y ↔ x ⊆ y
-- ZFSet.toSet_subset_iff
@[simp]
theorem toSet_subset_iff {x y : ZFSet} : x.toSet ⊆ y.toSet ↔ x ⊆ y 
Arguments: {x y : ZFSet}
Goal: x.toSet ⊆ y.toSet ↔ x ⊆ y
-- ZFSet.ext
@[ext]
theorem ext {x y : ZFSet.{u}} : (∀ z : ZFSet.{u}, z ∈ x ↔ z ∈ y) → x = y 
Arguments: {x y : ZFSet}
Goal: (∀ (z : ZFSet), z ∈ x ↔ z ∈ y) → x = y
-- ZFSet.ext_iff
theorem ext_iff {x y : ZFSet.{u}} : x = y ↔ ∀ z : ZFSet.{u}, z ∈ x ↔ z ∈ y 
Arguments: {x y : ZFSet}
Goal: x = y ↔ ∀ (z : ZFSet), z ∈ x ↔ z ∈ y
-- ZFSet.toSet_injective
theorem toSet_injective : Function.Injective toSet 
Goal: Function.Injective ZFSet.toSet
-- ZFSet.toSet_inj
@[simp]
theorem toSet_inj {x y : ZFSet} : x.toSet = y.toSet ↔ x = y 
Arguments: {x y : ZFSet}
Goal: x.toSet = y.toSet ↔ x = y
-- ZFSet.not_mem_empty
@[simp]
theorem not_mem_empty (x) : x ∉ (∅ : ZFSet.{u}) 
Arguments: (x : ZFSet)
Goal: x ∉ ∅
-- ZFSet.toSet_empty
@[simp]
theorem toSet_empty : toSet ∅ = ∅ 
Goal: ∅.toSet = ∅
-- ZFSet.empty_subset
@[simp]
theorem empty_subset (x : ZFSet.{u}) : (∅ : ZFSet) ⊆ x 
Arguments: (x : ZFSet)
Goal: ∅ ⊆ x
-- ZFSet.not_nonempty_empty
@[simp]
theorem not_nonempty_empty : ¬ZFSet.Nonempty ∅ 
Goal: ¬∅.Nonempty
-- ZFSet.nonempty_mk_iff
@[simp]
theorem nonempty_mk_iff {x : PSet} : (mk x).Nonempty ↔ x.Nonempty 
Arguments: {x : PSet}
Goal: (ZFSet.mk x).Nonempty ↔ x.Nonempty
-- ZFSet.eq_empty
theorem eq_empty (x : ZFSet.{u}) : x = ∅ ↔ ∀ y : ZFSet.{u}, y ∉ x 
Arguments: (x : ZFSet)
Goal: x = ∅ ↔ ∀ (y : ZFSet), y ∉ x
-- ZFSet.eq_empty_or_nonempty
theorem eq_empty_or_nonempty (u : ZFSet) : u = ∅ ∨ u.Nonempty 
Arguments: (u : ZFSet)
Goal: u = ∅ ∨ u.Nonempty
-- ZFSet.mem_insert_iff
@[simp]
theorem mem_insert_iff {x y z : ZFSet.{u}} : x ∈ insert y z ↔ x = y ∨ x ∈ z 
Arguments: {x y z : ZFSet}
Goal: x ∈ insert y z ↔ x = y ∨ x ∈ z
-- ZFSet.mem_insert
theorem mem_insert (x y : ZFSet) : x ∈ insert x y 
Arguments: (x y : ZFSet)
Goal: x ∈ insert x y
-- ZFSet.mem_insert_of_mem
theorem mem_insert_of_mem {y z : ZFSet} (x) (h : z ∈ y) : z ∈ insert x y 
Arguments: {y z : ZFSet} (x : ZFSet) (h : z ∈ y)
Goal: z ∈ insert x y
-- ZFSet.toSet_insert
@[simp]
theorem toSet_insert (x y : ZFSet) : (insert x y).toSet = insert x y.toSet 
Arguments: (x y : ZFSet)
Goal: (insert x y).toSet = insert x y.toSet
-- ZFSet.mem_singleton
@[simp]
theorem mem_singleton {x y : ZFSet.{u}} : x ∈ @singleton ZFSet.{u} ZFSet.{u} _ y ↔ x = y 
Arguments: {x y : ZFSet}
Goal: x ∈ {y} ↔ x = y
-- ZFSet.toSet_singleton
@[simp]
theorem toSet_singleton (x : ZFSet) : ({x} : ZFSet).toSet = {x} 
Arguments: (x : ZFSet)
Goal: {x}.toSet = {x}
-- ZFSet.insert_nonempty
theorem insert_nonempty (u v : ZFSet) : (insert u v).Nonempty 
Arguments: (u v : ZFSet)
Goal: (insert u v).Nonempty
-- ZFSet.singleton_nonempty
theorem singleton_nonempty (u : ZFSet) : ZFSet.Nonempty {u} 
Arguments: (u : ZFSet)
Goal: {u}.Nonempty
-- ZFSet.mem_pair
theorem mem_pair {x y z : ZFSet.{u}} : x ∈ ({y, z} : ZFSet) ↔ x = y ∨ x = z 
Arguments: {x y z : ZFSet}
Goal: x ∈ {y, z} ↔ x = y ∨ x = z
-- ZFSet.omega_zero
@[simp]
theorem omega_zero : ∅ ∈ omega 
Goal: ∅ ∈ ZFSet.omega
-- ZFSet.omega_succ
@[simp]
theorem omega_succ {n} : n ∈ omega.{u} → insert n n ∈ omega.{u} 
Arguments: {n : ZFSet}
Goal: n ∈ ZFSet.omega → insert n n ∈ ZFSet.omega
-- ZFSet.mem_sep
@[simp]
theorem mem_sep {p : ZFSet.{u} → Prop} {x y : ZFSet.{u}} :
    y ∈ ZFSet.sep p x ↔ y ∈ x ∧ p y 
Arguments: {p : ZFSet → Prop} {x y : ZFSet}
Goal: y ∈ ZFSet.sep p x ↔ y ∈ x ∧ p y
-- ZFSet.toSet_sep
@[simp]
theorem toSet_sep (a : ZFSet) (p : ZFSet → Prop) :
    (ZFSet.sep p a).toSet = { x ∈ a.toSet | p x } 
Arguments: (a : ZFSet) (p : ZFSet → Prop)
Goal: (ZFSet.sep p a).toSet = {x | x ∈ a.toSet ∧ p x}
-- ZFSet.mem_powerset
@[simp]
theorem mem_powerset {x y : ZFSet.{u}} : y ∈ powerset x ↔ y ⊆ x 
Arguments: {x y : ZFSet}
Goal: y ∈ x.powerset ↔ y ⊆ x
-- ZFSet.sUnion_lem
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)
  
Arguments: {α β : Type u} (A : α → PSet) (B : β → PSet) (αβ : ∀ (a : α), ∃ b, (A a).Equiv (B b)) (a : (⋃₀ PSet.mk α A).Type)
Goal: ∃ b, ((⋃₀ PSet.mk α A).Func a).Equiv ((⋃₀ PSet.mk β B).Func b)
-- ZFSet.mem_sUnion
@[simp]
theorem mem_sUnion {x y : ZFSet.{u}} : y ∈ ⋃₀ x ↔ ∃ z ∈ x, y ∈ z 
Arguments: {x y : ZFSet}
Goal: y ∈ ⋃₀ x ↔ ∃ z ∈ x, y ∈ z
-- ZFSet.mem_sInter
theorem mem_sInter {x y : ZFSet} (h : x.Nonempty) : y ∈ ⋂₀ x ↔ ∀ z ∈ x, y ∈ z 
Arguments: {x y : ZFSet} (h : x.Nonempty)
Goal: y ∈ ⋂₀ x ↔ ∀ z ∈ x, y ∈ z
-- ZFSet.sUnion_empty
@[simp]
theorem sUnion_empty : ⋃₀ (∅ : ZFSet.{u}) = ∅ 
Goal: ⋃₀ ∅ = ∅
-- ZFSet.sInter_empty
@[simp]
theorem sInter_empty : ⋂₀ (∅ : ZFSet) = ∅ 
Goal: ⋂₀ ∅ = ∅
-- ZFSet.mem_of_mem_sInter
theorem mem_of_mem_sInter {x y z : ZFSet} (hy : y ∈ ⋂₀ x) (hz : z ∈ x) : y ∈ z 
Arguments: {x y z : ZFSet} (hy : y ∈ ⋂₀ x) (hz : z ∈ x)
Goal: y ∈ z
-- ZFSet.mem_sUnion_of_mem
theorem mem_sUnion_of_mem {x y z : ZFSet} (hy : y ∈ z) (hz : z ∈ x) : y ∈ ⋃₀ x 
Arguments: {x y z : ZFSet} (hy : y ∈ z) (hz : z ∈ x)
Goal: y ∈ ⋃₀ x
-- ZFSet.not_mem_sInter_of_not_mem
theorem not_mem_sInter_of_not_mem {x y z : ZFSet} (hy : ¬y ∈ z) (hz : z ∈ x) : ¬y ∈ ⋂₀ x 
Arguments: {x y z : ZFSet} (hy : y ∉ z) (hz : z ∈ x)
Goal: y ∉ ⋂₀ x
-- ZFSet.sUnion_singleton
@[simp]
theorem sUnion_singleton {x : ZFSet.{u}} : ⋃₀ ({x} : ZFSet) = x 
Arguments: {x : ZFSet}
Goal: ⋃₀ {x} = x
-- ZFSet.sInter_singleton
@[simp]
theorem sInter_singleton {x : ZFSet.{u}} : ⋂₀ ({x} : ZFSet) = x 
Arguments: {x : ZFSet}
Goal: ⋂₀ {x} = x
-- ZFSet.toSet_sUnion
@[simp]
theorem toSet_sUnion (x : ZFSet.{u}) : (⋃₀ x).toSet = ⋃₀ (toSet '' x.toSet) 
Arguments: (x : ZFSet)
Goal: (⋃₀ x).toSet = ⋃₀ (ZFSet.toSet '' x.toSet)
-- ZFSet.toSet_sInter
theorem toSet_sInter {x : ZFSet.{u}} (h : x.Nonempty) : (⋂₀ x).toSet = ⋂₀ (toSet '' x.toSet) 
Arguments: {x : ZFSet} (h : x.Nonempty)
Goal: (⋂₀ x).toSet = ⋂₀ (ZFSet.toSet '' x.toSet)
-- ZFSet.singleton_injective
theorem singleton_injective : Function.Injective (@singleton ZFSet ZFSet _) 
Goal: Function.Injective singleton
-- ZFSet.singleton_inj
@[simp]
theorem singleton_inj {x y : ZFSet} : ({x} : ZFSet) = {y} ↔ x = y 
Arguments: {x y : ZFSet}
Goal: {x} = {y} ↔ x = y
-- ZFSet.toSet_union
@[simp]
theorem toSet_union (x y : ZFSet.{u}) : (x ∪ y).toSet = x.toSet ∪ y.toSet 
Arguments: (x y : ZFSet)
Goal: (x ∪ y).toSet = x.toSet ∪ y.toSet
-- ZFSet.toSet_inter
@[simp]
theorem toSet_inter (x y : ZFSet.{u}) : (x ∩ y).toSet = x.toSet ∩ y.toSet 
Arguments: (x y : ZFSet)
Goal: (x ∩ y).toSet = x.toSet ∩ y.toSet
-- ZFSet.toSet_sdiff
@[simp]
theorem toSet_sdiff (x y : ZFSet.{u}) : (x \ y).toSet = x.toSet \ y.toSet 
Arguments: (x y : ZFSet)
Goal: (x \ y).toSet = x.toSet \ y.toSet
-- ZFSet.mem_union
@[simp]
theorem mem_union {x y z : ZFSet.{u}} : z ∈ x ∪ y ↔ z ∈ x ∨ z ∈ y 
Arguments: {x y z : ZFSet}
Goal: z ∈ x ∪ y ↔ z ∈ x ∨ z ∈ y
-- ZFSet.mem_inter
@[simp]
theorem mem_inter {x y z : ZFSet.{u}} : z ∈ x ∩ y ↔ z ∈ x ∧ z ∈ y 
Arguments: {x y z : ZFSet}
Goal: z ∈ x ∩ y ↔ z ∈ x ∧ z ∈ y
-- ZFSet.mem_diff
@[simp]
theorem mem_diff {x y z : ZFSet.{u}} : z ∈ x \ y ↔ z ∈ x ∧ z ∉ y 
Arguments: {x y z : ZFSet}
Goal: z ∈ x \ y ↔ z ∈ x ∧ z ∉ y
-- ZFSet.sUnion_pair
@[simp]
theorem sUnion_pair {x y : ZFSet.{u}} : ⋃₀ ({x, y} : ZFSet.{u}) = x ∪ y 
Arguments: {x y : ZFSet}
Goal: ⋃₀ {x, y} = x ∪ y
-- ZFSet.mem_wf
theorem mem_wf : @WellFounded ZFSet (· ∈ ·) 
Goal: WellFounded fun x x_1 => x ∈ x_1
-- ZFSet.inductionOn
@[elab_as_elim]
theorem inductionOn {p : ZFSet → Prop} (x) (h : ∀ x, (∀ y ∈ x, p y) → p x) : p x 
Arguments: {p : ZFSet → Prop} (x : ZFSet) (h : ∀ (x : ZFSet), (∀ y ∈ x, p y) → p x)
Goal: p x
-- ZFSet.mem_asymm
theorem mem_asymm {x y : ZFSet} : x ∈ y → y ∉ x 
Arguments: {x y : ZFSet}
Goal: x ∈ y → y ∉ x
-- ZFSet.mem_irrefl
theorem mem_irrefl (x : ZFSet) : x ∉ x 
Arguments: (x : ZFSet)
Goal: x ∉ x
-- ZFSet.regularity
theorem regularity (x : ZFSet.{u}) (h : x ≠ ∅) : ∃ y ∈ x, x ∩ y = ∅ 
Arguments: (x : ZFSet) (h : x ≠ ∅)
Goal: ∃ y ∈ x, x ∩ y = ∅
-- ZFSet.image.mk
theorem image.mk :
    ∀ (f : ZFSet.{u} → ZFSet.{u}) [H : Definable 1 f] (x) {y} (_ : y ∈ x), f y ∈ @image f H x
  
Arguments: (f : ZFSet → ZFSet) [H : PSet.Definable 1 f] (x : ZFSet) {y : ZFSet}
Goal: y ∈ x → f y ∈ ZFSet.image f x
-- ZFSet.mem_image
@[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
  
Arguments: {f : ZFSet → ZFSet} [H : PSet.Definable 1 f] {x y : ZFSet}
Goal: y ∈ ZFSet.image f x ↔ ∃ z ∈ x, f z = y
-- ZFSet.toSet_image
@[simp]
theorem toSet_image (f : ZFSet → ZFSet) [H : Definable 1 f] (x : ZFSet) :
    (image f x).toSet = f '' x.toSet 
Arguments: (f : ZFSet → ZFSet) [H : PSet.Definable 1 f] (x : ZFSet)
Goal: (ZFSet.image f x).toSet = f '' x.toSet
-- ZFSet.mem_range
@[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 
Arguments: {α : Type u} {f : α → ZFSet} {x : ZFSet}
Goal: x ∈ ZFSet.range f ↔ x ∈ Set.range f
-- ZFSet.toSet_range
@[simp]
theorem toSet_range {α : Type u} (f : α → ZFSet.{max u v}) :
    (range.{u, v} f).toSet = Set.range f 
Arguments: {α : Type u} (f : α → ZFSet)
Goal: (ZFSet.range f).toSet = Set.range f
-- ZFSet.toSet_pair
@[simp]
theorem toSet_pair (x y : ZFSet.{u}) : (pair x y).toSet = {{x}, {x, y}} 
Arguments: (x y : ZFSet)
Goal: (x.pair y).toSet = {{x}, {x, y}}
-- ZFSet.mem_pairSep
@[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 
Arguments: {p : ZFSet → ZFSet → Prop} {x y z : ZFSet}
Goal: z ∈ ZFSet.pairSep p x y ↔ ∃ a ∈ x, ∃ b ∈ y, z = a.pair b ∧ p a b
-- ZFSet.pair_injective
theorem pair_injective : Function.Injective2 pair 
Goal: Function.Injective2 ZFSet.pair
-- ZFSet.pair_inj
@[simp]
theorem pair_inj {x y x' y' : ZFSet} : pair x y = pair x' y' ↔ x = x' ∧ y = y' 
Arguments: {x y x' y' : ZFSet}
Goal: x.pair y = x'.pair y' ↔ x = x' ∧ y = y'
-- ZFSet.mem_prod
@[simp]
theorem mem_prod {x y z : ZFSet.{u}} : z ∈ prod x y ↔ ∃ a ∈ x, ∃ b ∈ y, z = pair a b 
Arguments: {x y z : ZFSet}
Goal: z ∈ x.prod y ↔ ∃ a ∈ x, ∃ b ∈ y, z = a.pair b
-- ZFSet.pair_mem_prod
theorem pair_mem_prod {x y a b : ZFSet.{u}} : pair a b ∈ prod x y ↔ a ∈ x ∧ b ∈ y 
Arguments: {x y a b : ZFSet}
Goal: a.pair b ∈ x.prod y ↔ a ∈ x ∧ b ∈ y
-- ZFSet.mem_funs
@[simp]
theorem mem_funs {x y f : ZFSet.{u}} : f ∈ funs x y ↔ IsFunc x y f 
Arguments: {x y f : ZFSet}
Goal: f ∈ x.funs y ↔ x.IsFunc y f
-- ZFSet.mem_map
@[simp]
theorem mem_map {f : ZFSet → ZFSet} [Definable 1 f] {x y : ZFSet} :
    y ∈ map f x ↔ ∃ z ∈ x, pair z (f z) = y 
Arguments: {f : ZFSet → ZFSet} [PSet.Definable 1 f] {x y : ZFSet}
Goal: y ∈ ZFSet.map f x ↔ ∃ z ∈ x, z.pair (f z) = y
-- ZFSet.map_unique
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 
Arguments: {f : ZFSet → ZFSet} [H : PSet.Definable 1 f] {x z : ZFSet} (zx : z ∈ x)
Goal: ∃! w, z.pair w ∈ ZFSet.map f x
-- ZFSet.map_isFunc
@[simp]
theorem map_isFunc {f : ZFSet → ZFSet} [Definable 1 f] {x y : ZFSet} :
    IsFunc x y (map f x) ↔ ∀ z ∈ x, f z ∈ y 
Arguments: {f : ZFSet → ZFSet} [PSet.Definable 1 f] {x y : ZFSet}
Goal: x.IsFunc y (ZFSet.map f x) ↔ ∀ z ∈ x, f z ∈ y
-- ZFSet.hereditarily_iff
theorem hereditarily_iff : Hereditarily p x ↔ p x ∧ ∀ y ∈ x, Hereditarily p y 
Arguments: {p : ZFSet → Prop} {x : ZFSet}
Goal: ZFSet.Hereditarily p x ↔ p x ∧ ∀ y ∈ x, ZFSet.Hereditarily p y
-- ZFSet.Hereditarily.self
theorem Hereditarily.self (h : x.Hereditarily p) : p x 
Arguments: {p : ZFSet → Prop} {x : ZFSet} (h : ZFSet.Hereditarily p x)
Goal: p x
-- ZFSet.Hereditarily.mem
theorem Hereditarily.mem (h : x.Hereditarily p) (hy : y ∈ x) : y.Hereditarily p 
Arguments: {p : ZFSet → Prop} {x y : ZFSet} (h : ZFSet.Hereditarily p x) (hy : y ∈ x)
Goal: ZFSet.Hereditarily p y
-- ZFSet.Hereditarily.empty
theorem Hereditarily.empty : Hereditarily p x → p ∅ 
Arguments: {p : ZFSet → Prop} {x : ZFSet}
Goal: ZFSet.Hereditarily p x → p ∅
-- Class.ext
@[ext]
theorem ext {x y : Class.{u}} : (∀ z : ZFSet.{u}, x z ↔ y z) → x = y 
Arguments: {x y : Class}
Goal: (∀ (z : ZFSet), x z ↔ y z) → x = y
-- Class.ext_iff
theorem ext_iff {x y : Class.{u}} : x = y ↔ ∀ z, x z ↔ y z 
Arguments: {x y : Class}
Goal: x = y ↔ ∀ (z : ZFSet), x z ↔ y z
-- Class.mem_def
theorem mem_def (A B : Class.{u}) : A ∈ B ↔ ∃ x : ZFSet, ↑x = A ∧ B x 
Arguments: (A B : Class)
Goal: A ∈ B ↔ ∃ x, ↑x = A ∧ B x
-- Class.not_mem_empty
@[simp]
theorem not_mem_empty (x : Class.{u}) : x ∉ (∅ : Class.{u}) 
Arguments: (x : Class)
Goal: x ∉ ∅
-- Class.not_empty_hom
@[simp]
theorem not_empty_hom (x : ZFSet.{u}) : ¬(∅ : Class.{u}) x 
Arguments: (x : ZFSet)
Goal: ¬∅ x
-- Class.mem_univ
@[simp]
theorem mem_univ {A : Class.{u}} : A ∈ univ.{u} ↔ ∃ x : ZFSet.{u}, ↑x = A 
Arguments: {A : Class}
Goal: A ∈ Class.univ ↔ ∃ x, ↑x = A
-- Class.mem_univ_hom
@[simp]
theorem mem_univ_hom (x : ZFSet.{u}) : univ.{u} x 
Arguments: (x : ZFSet)
Goal: Class.univ x
-- Class.eq_univ_iff_forall
theorem eq_univ_iff_forall {A : Class.{u}} : A = univ ↔ ∀ x : ZFSet, A x 
Arguments: {A : Class}
Goal: A = Class.univ ↔ ∀ (x : ZFSet), A x
-- Class.eq_univ_of_forall
theorem eq_univ_of_forall {A : Class.{u}} : (∀ x : ZFSet, A x) → A = univ 
Arguments: {A : Class}
Goal: (∀ (x : ZFSet), A x) → A = Class.univ
-- Class.mem_wf
theorem mem_wf : @WellFounded Class.{u} (· ∈ ·) 
Goal: WellFounded fun x x_1 => x ∈ x_1
-- Class.mem_asymm
theorem mem_asymm {x y : Class} : x ∈ y → y ∉ x 
Arguments: {x y : Class}
Goal: x ∈ y → y ∉ x
-- Class.mem_irrefl
theorem mem_irrefl (x : Class) : x ∉ x 
Arguments: (x : Class)
Goal: x ∉ x
-- Class.univ_not_mem_univ
theorem univ_not_mem_univ : univ ∉ univ 
Goal: Class.univ ∉ Class.univ
-- Class.congToClass_empty
@[simp]
theorem congToClass_empty : congToClass ∅ = ∅ 
Goal: Class.congToClass ∅ = ∅
-- Class.classToCong_empty
@[simp]
theorem classToCong_empty : classToCong ∅ = ∅ 
Goal: ∅.classToCong = ∅
-- Class.ofSet.inj
theorem ofSet.inj {x y : ZFSet.{u}} (h : (x : Class.{u}) = y) : x = y 
Arguments: {x y : ZFSet} (h : ↑x = ↑y)
Goal: x = y
-- Class.toSet_of_ZFSet
@[simp]
theorem toSet_of_ZFSet (A : Class.{u}) (x : ZFSet.{u}) : ToSet A x ↔ A x 
Arguments: (A : Class) (x : ZFSet)
Goal: A.ToSet ↑x ↔ A x
-- Class.coe_mem
@[simp, norm_cast]
theorem coe_mem {x : ZFSet.{u}} {A : Class.{u}} : ↑x ∈ A ↔ A x 
Arguments: {x : ZFSet} {A : Class}
Goal: ↑x ∈ A ↔ A x
-- Class.coe_apply
@[simp]
theorem coe_apply {x y : ZFSet.{u}} : (y : Class.{u}) x ↔ x ∈ y 
Arguments: {x y : ZFSet}
Goal: ↑y x ↔ x ∈ y
-- Class.coe_subset
@[simp, norm_cast]
theorem coe_subset (x y : ZFSet.{u}) : (x : Class.{u}) ⊆ y ↔ x ⊆ y 
Arguments: (x y : ZFSet)
Goal: ↑x ⊆ ↑y ↔ x ⊆ y
-- Class.coe_sep
@[simp, norm_cast]
theorem coe_sep (p : Class.{u}) (x : ZFSet.{u}) :
    (ZFSet.sep p x : Class) = { y ∈ x | p y } 
Arguments: (p : Class) (x : ZFSet)
Goal: ↑(ZFSet.sep p x) = {y | y ∈ x ∧ p y}
-- Class.coe_empty
@[simp, norm_cast]
theorem coe_empty : ↑(∅ : ZFSet.{u}) = (∅ : Class.{u}) 
Goal: ↑∅ = ∅
-- Class.coe_insert
@[simp, norm_cast]
theorem coe_insert (x y : ZFSet.{u}) : ↑(insert x y) = @insert ZFSet.{u} Class.{u} _ x y 
Arguments: (x y : ZFSet)
Goal: ↑(insert x y) = insert x ↑y
-- Class.coe_union
@[simp, norm_cast]
theorem coe_union (x y : ZFSet.{u}) : ↑(x ∪ y) = (x : Class.{u}) ∪ y 
Arguments: (x y : ZFSet)
Goal: ↑(x ∪ y) = ↑x ∪ ↑y
-- Class.coe_inter
@[simp, norm_cast]
theorem coe_inter (x y : ZFSet.{u}) : ↑(x ∩ y) = (x : Class.{u}) ∩ y 
Arguments: (x y : ZFSet)
Goal: ↑(x ∩ y) = ↑x ∩ ↑y
-- Class.coe_diff
@[simp, norm_cast]
theorem coe_diff (x y : ZFSet.{u}) : ↑(x \ y) = (x : Class.{u}) \ y 
Arguments: (x y : ZFSet)
Goal: ↑(x \ y) = ↑x \ ↑y
-- Class.coe_powerset
@[simp, norm_cast]
theorem coe_powerset (x : ZFSet.{u}) : ↑x.powerset = powerset.{u} x 
Arguments: (x : ZFSet)
Goal: ↑x.powerset = (↑x).powerset
-- Class.powerset_apply
@[simp]
theorem powerset_apply {A : Class.{u}} {x : ZFSet.{u}} : powerset A x ↔ ↑x ⊆ A 
Arguments: {A : Class} {x : ZFSet}
Goal: A.powerset x ↔ ↑x ⊆ A
-- Class.sUnion_apply
@[simp]
theorem sUnion_apply {x : Class} {y : ZFSet} : (⋃₀ x) y ↔ ∃ z : ZFSet, x z ∧ y ∈ z 
Arguments: {x : Class} {y : ZFSet}
Goal: (⋃₀ x) y ↔ ∃ z, x z ∧ y ∈ z
-- Class.coe_sUnion
@[simp, norm_cast]
theorem coe_sUnion (x : ZFSet.{u}) : ↑(⋃₀ x : ZFSet) = ⋃₀ (x : Class.{u}) 
Arguments: (x : ZFSet)
Goal: ↑(⋃₀ x) = ⋃₀ ↑x
-- Class.mem_sUnion
@[simp]
theorem mem_sUnion {x y : Class.{u}} : y ∈ ⋃₀ x ↔ ∃ z, z ∈ x ∧ y ∈ z 
Arguments: {x y : Class}
Goal: y ∈ ⋃₀ x ↔ ∃ z ∈ x, y ∈ z
-- Class.sInter_apply
theorem sInter_apply {x : Class.{u}} {y : ZFSet.{u}} : (⋂₀ x) y ↔ ∀ z : ZFSet.{u}, x z → y ∈ z 
Arguments: {x : Class} {y : ZFSet}
Goal: (⋂₀ x) y ↔ ∀ (z : ZFSet), x z → y ∈ z
-- Class.coe_sInter
@[simp, norm_cast]
theorem coe_sInter {x : ZFSet.{u}} (h : x.Nonempty) : ↑(⋂₀ x : ZFSet) = ⋂₀ (x : Class.{u}) 
Arguments: {x : ZFSet} (h : x.Nonempty)
Goal: ↑(⋂₀ x) = ⋂₀ ↑x
-- Class.mem_of_mem_sInter
theorem mem_of_mem_sInter {x y z : Class} (hy : y ∈ ⋂₀ x) (hz : z ∈ x) : y ∈ z 
Arguments: {x y z : Class} (hy : y ∈ ⋂₀ x) (hz : z ∈ x)
Goal: y ∈ z
-- Class.mem_sInter
theorem mem_sInter {x y : Class.{u}} (h : x.Nonempty) : y ∈ ⋂₀ x ↔ ∀ z, z ∈ x → y ∈ z 
Arguments: {x y : Class} (h : Set.Nonempty x)
Goal: y ∈ ⋂₀ x ↔ ∀ z ∈ x, y ∈ z
-- Class.sUnion_empty
@[simp]
theorem sUnion_empty : ⋃₀ (∅ : Class.{u}) = (∅ : Class.{u}) 
Goal: ⋃₀ ∅ = ∅
-- Class.sInter_empty
@[simp]
theorem sInter_empty : ⋂₀ (∅ : Class.{u}) = univ 
Goal: ⋂₀ ∅ = Class.univ
-- Class.eq_univ_of_powerset_subset
theorem eq_univ_of_powerset_subset {A : Class} (hA : powerset A ⊆ A) : A = univ 
Arguments: {A : Class} (hA : A.powerset ⊆ A)
Goal: A = Class.univ
-- Class.iota_val
theorem iota_val (A : Class) (x : ZFSet) (H : ∀ y, A y ↔ y = x) : iota A = ↑x 
Arguments: (A : Class) (x : ZFSet) (H : ∀ (y : ZFSet), A y ↔ y = x)
Goal: A.iota = ↑x
-- Class.iota_ex
theorem iota_ex (A) : iota.{u} A ∈ univ.{u} 
Arguments: (A : Class)
Goal: A.iota ∈ Class.univ
-- Class.fval_ex
theorem fval_ex (F A : Class.{u}) : F ′ A ∈ univ.{u} 
Arguments: (F A : Class)
Goal: F ′ A ∈ Class.univ
-- ZFSet.map_fval
@[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 
Arguments: {f : ZFSet → ZFSet} [H : PSet.Definable 1 f] {x y : ZFSet} (h : y ∈ x)
Goal: ↑(ZFSet.map f x) ′ ↑y = ↑(f y)
-- ZFSet.choice_mem_aux
theorem choice_mem_aux (h : ∅ ∉ x) (y : ZFSet.{u}) (yx : y ∈ x) :
    (Classical.epsilon fun z : ZFSet.{u} => z ∈ y) ∈ y 
Arguments: (x : ZFSet) (h : ∅ ∉ x) (y : ZFSet) (yx : y ∈ x)
Goal: (Classical.epsilon fun z => z ∈ y) ∈ y
-- ZFSet.choice_isFunc
theorem choice_isFunc (h : ∅ ∉ x) : IsFunc x (⋃₀ x) (choice x) 
Arguments: (x : ZFSet) (h : ∅ ∉ x)
Goal: x.IsFunc (⋃₀ x) x.choice
-- ZFSet.choice_mem
theorem choice_mem (h : ∅ ∉ x) (y : ZFSet.{u}) (yx : y ∈ x) :
    (choice x ′ y : Class.{u}) ∈ (y : Class.{u}) 
Arguments: (x : ZFSet) (h : ∅ ∉ x) (y : ZFSet) (yx : y ∈ x)
Goal: ↑x.choice ′ ↑y ∈ ↑y
-- _private.Mathlib.SetTheory.ZFC.Basic.0.ZFSet.toSet_equiv_aux
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 
Arguments: {s : Set ZFSet} (hs : Small.{u, u + 1} ↑s)
Goal: (ZFSet.mk (PSet.mk (Shrink.{u, u + 1} ↑s) fun x => Quotient.out ↑((equivShrink ↑s).symm x))).toSet = s
-- ZFSet.toSet_equiv_apply_coe
@[simps apply_coe]
noncomputable def toSet_equiv : ZFSet.{u} ≃ {s : Set ZFSet.{u} // Small.{u, u+1} s} 
Arguments: (x : ZFSet)
Goal: ↑(ZFSet.toSet_equiv x) = x.toSet
-- SetTheory.PGame.impartialAux_def
theorem impartialAux_def {G : PGame} :
    G.ImpartialAux ↔
      (G ≈ -G) ∧ (∀ i, ImpartialAux (G.moveLeft i)) ∧ ∀ j, ImpartialAux (G.moveRight j) 
Arguments: {G : SetTheory.PGame}
Goal: G.ImpartialAux ↔
  G ≈ -G ∧ (∀ (i : G.LeftMoves), (G.moveLeft i).ImpartialAux) ∧ ∀ (j : G.RightMoves), (G.moveRight j).ImpartialAux
-- SetTheory.PGame.Impartial.out
class Impartial (G : PGame) : Prop where
  out : ImpartialAux G
Arguments: {G : SetTheory.PGame} [self : G.Impartial]
Goal: G.ImpartialAux
-- SetTheory.PGame.impartial_iff_aux
theorem impartial_iff_aux {G : PGame} : G.Impartial ↔ G.ImpartialAux 
Arguments: {G : SetTheory.PGame}
Goal: G.Impartial ↔ G.ImpartialAux
-- SetTheory.PGame.impartial_def
theorem impartial_def {G : PGame} :
    G.Impartial ↔ (G ≈ -G) ∧ (∀ i, Impartial (G.moveLeft i)) ∧ ∀ j, Impartial (G.moveRight j) 
Arguments: {G : SetTheory.PGame}
Goal: G.Impartial ↔ G ≈ -G ∧ (∀ (i : G.LeftMoves), (G.moveLeft i).Impartial) ∧ ∀ (j : G.RightMoves), (G.moveRight j).Impartial
-- SetTheory.PGame.Impartial.neg_equiv_self
theorem neg_equiv_self (G : PGame) [h : G.Impartial] : G ≈ -G 
Arguments: (G : SetTheory.PGame) [h : G.Impartial]
Goal: G ≈ -G
-- SetTheory.PGame.Impartial.mk'_neg_equiv_self
@[simp]
theorem mk'_neg_equiv_self (G : PGame) [G.Impartial] : -(⟦G⟧ : Quotient setoid) = ⟦G⟧ 
Arguments: (G : SetTheory.PGame) [G.Impartial]
Goal: -⟦G⟧ = ⟦G⟧
-- SetTheory.PGame.Impartial.impartial_congr
theorem impartial_congr : ∀ {G H : PGame} (_ : G ≡r H) [G.Impartial], H.Impartial
  
Arguments: {G H : SetTheory.PGame}
Goal: G.Relabelling H → ∀ [inst : G.Impartial], H.Impartial
-- SetTheory.PGame.Impartial.nonpos
theorem nonpos : ¬0 < G 
Arguments: (G : SetTheory.PGame) [G.Impartial]
Goal: ¬0 < G
-- SetTheory.PGame.Impartial.nonneg
theorem nonneg : ¬G < 0 
Arguments: (G : SetTheory.PGame) [G.Impartial]
Goal: ¬G < 0