Datasets:

akjadhav
/

leandojo-lean4-formal-informal-strings-split

Dataset card Data Studio Files Files and versions Community

Split (3)

train · 47.4k rows

formal stringlengths 41 427k	informal stringclasses 1 value
PSet.equiv_of_isEmpty x : PSet y : PSet inst✝¹ : IsEmpty (Type x) inst✝ : IsEmpty (Type y) ⊢ (∀ (i : Type x), ∃ j, Equiv (Func x i) (Func y j)) ∧ ∀ (j : Type y), ∃ i, Equiv (Func x i) (Func y j) simp ** Qed
PSet.func_mem x : PSet i : Type x ⊢ Func x i ∈ x cases x case mk α✝ : Type u_1 A✝ : α✝ → PSet i : Type (mk α✝ A✝) ⊢ Func (mk α✝ A✝) i ∈ mk α✝ A✝ apply Mem.mk ** Qed
PSet.mem_wf_aux α : Type u A : α → PSet β : Type u B : β → PSet H : Equiv (mk α A) (mk β B) ⊢ ∀ (y : PSet), y ∈ mk β B → Acc (fun x x_1 => x ∈ x_1) y rintro ⟨γ, C⟩ ⟨b, hc⟩ case mk.intro α : Type u A : α → PSet β : Type u B : β → PSet H : Equiv (mk α A) (mk β B) γ : Type u C : γ → PSet b : Type (mk β B) hc : Equiv (mk γ C) (Func (mk β B) b) ⊢ Acc (fun x x_1 => x ∈ x_1) (mk γ C) cases' H.exists_right b with a ha case mk.intro.intro α : Type u A : α → PSet β : Type u B : β → PSet H : Equiv (mk α A) (mk β B) γ : Type u C : γ → PSet b : Type (mk β B) hc : Equiv (mk γ C) (Func (mk β B) b) a : Type (mk α A) ha : Equiv (Func (mk α A) a) (Func (mk β B) b) ⊢ Acc (fun x x_1 => x ∈ x_1) (mk γ C) have H := ha.trans hc.symm case mk.intro.intro α : Type u A : α → PSet β : Type u B : β → PSet H✝ : Equiv (mk α A) (mk β B) γ : Type u C : γ → PSet b : Type (mk β B) hc : Equiv (mk γ C) (Func (mk β B) b) a : Type (mk α A) ha : Equiv (Func (mk α A) a) (Func (mk β B) b) H : Equiv (Func (mk α A) a) (mk γ C) ⊢ Acc (fun x x_1 => x ∈ x_1) (mk γ C) rw [mk_func] at H case mk.intro.intro α : Type u A : α → PSet β : Type u B : β → PSet H✝ : Equiv (mk α A) (mk β B) γ : Type u C : γ → PSet b : Type (mk β B) hc : Equiv (mk γ C) (Func (mk β B) b) a : Type (mk α A) ha : Equiv (Func (mk α A) a) (Func (mk β B) b) H : Equiv (A a) (mk γ C) ⊢ Acc (fun x x_1 => x ∈ x_1) (mk γ C) exact mem_wf_aux H ** Qed
PSet.toSet_empty ⊢ toSet ∅ = ∅ simp [toSet] ** Qed
PSet.not_nonempty_empty ⊢ ¬PSet.Nonempty ∅ simp [PSet.Nonempty] ** Qed
PSet.mem_sUnion α : Type u A : α → PSet y : PSet x✝ : y ∈ ⋃₀ mk α A a : Type (mk α A) c : Type (Func (mk α A) a) e : Equiv y (Func (A a) c) this : Func (A a) c ∈ mk (Type (A a)) (Func (A a)) ⊢ Func (A a) c ∈ A (?m.24436 α A y x✝ a c e this) rwa [eta] at this α : Type u A : α → PSet y : PSet x✝ : ∃ z, z ∈ mk α A ∧ y ∈ z β : Type u B : β → PSet a : Type (mk α A) e : Equiv (mk β B) (A a) b : Type (mk β B) yb : Equiv y (Func (mk β B) b) ⊢ y ∈ ⋃₀ mk α A rw [← eta (A a)] at e α : Type u A : α → PSet y : PSet x✝ : ∃ z, z ∈ mk α A ∧ y ∈ z β : Type u B : β → PSet a : Type (mk α A) e : Equiv (mk β B) (mk (Type (A a)) (Func (A a))) b : Type (mk β B) yb : Equiv y (Func (mk β B) b) ⊢ y ∈ ⋃₀ mk α A exact let ⟨βt, _⟩ := e let ⟨c, bc⟩ := βt b ⟨⟨a, c⟩, yb.trans bc⟩ ** Qed
PSet.toSet_sUnion x : PSet ⊢ toSet (⋃₀ x) = ⋃₀ (toSet '' toSet x) ext case h x x✝ : PSet ⊢ x✝ ∈ toSet (⋃₀ x) ↔ x✝ ∈ ⋃₀ (toSet '' toSet x) simp ** Qed
ZFSet.toSet_subset_iff x y : ZFSet ⊢ toSet x ⊆ toSet y ↔ x ⊆ y simp [subset_def, Set.subset_def] ** Qed
ZFSet.ext_iff x y : ZFSet h : x = y ⊢ ∀ (z : ZFSet), z ∈ x ↔ z ∈ y simp [h] ** Qed
ZFSet.toSet_empty ⊢ toSet ∅ = ∅ simp [toSet] ** Qed
ZFSet.not_nonempty_empty ⊢ ¬ZFSet.Nonempty ∅ simp [ZFSet.Nonempty] ** Qed
ZFSet.nonempty_mk_iff x : PSet ⊢ ZFSet.Nonempty (mk x) ↔ PSet.Nonempty x refine' ⟨_, fun ⟨a, h⟩ => ⟨mk a, h⟩⟩ x : PSet ⊢ ZFSet.Nonempty (mk x) → PSet.Nonempty x rintro ⟨a, h⟩ case intro x : PSet a : ZFSet h : a ∈ toSet (mk x) ⊢ PSet.Nonempty x induction a using Quotient.inductionOn case intro.h x a✝ : PSet h : Quotient.mk setoid a✝ ∈ toSet (mk x) ⊢ PSet.Nonempty x exact ⟨_, h⟩ ** Qed
ZFSet.eq_empty x : ZFSet ⊢ x = ∅ ↔ ∀ (y : ZFSet), ¬y ∈ x rw [ext_iff] x : ZFSet ⊢ (∀ (z : ZFSet), z ∈ x ↔ z ∈ ∅) ↔ ∀ (y : ZFSet), ¬y ∈ x simp ** Qed
ZFSet.eq_empty_or_nonempty u : ZFSet ⊢ u = ∅ ∨ ZFSet.Nonempty u rw [eq_empty, ← not_exists] u : ZFSet ⊢ (¬∃ x, x ∈ u) ∨ ZFSet.Nonempty u apply em' ** Qed
ZFSet.toSet_insert x y : ZFSet ⊢ toSet (insert x y) = insert x (toSet y) ext case h x y x✝ : ZFSet ⊢ x✝ ∈ toSet (insert x y) ↔ x✝ ∈ insert x (toSet y) simp ** Qed
ZFSet.toSet_singleton x : ZFSet ⊢ toSet {x} = {x} ext case h x x✝ : ZFSet ⊢ x✝ ∈ toSet {x} ↔ x✝ ∈ {x} simp ** Qed
ZFSet.mem_pair x y z : ZFSet ⊢ x ∈ {y, z} ↔ x = y ∨ x = z simp ** Qed
ZFSet.omega_succ n✝ : ZFSet x : PSet x✝ : Quotient.mk setoid x ∈ omega n : ℕ h : PSet.Equiv x (Func PSet.omega { down := n }) ⊢ insert (mk x) (mk x) = insert (mk (ofNat n)) (mk (ofNat n)) rw [ZFSet.sound h] n✝ : ZFSet x : PSet x✝ : Quotient.mk setoid x ∈ omega n : ℕ h : PSet.Equiv x (Func PSet.omega { down := n }) ⊢ insert (mk (Func PSet.omega { down := n })) (mk (Func PSet.omega { down := n })) = insert (mk (ofNat n)) (mk (ofNat n)) rfl ** Qed
ZFSet.mem_sep p : ZFSet → Prop x y✝ : ZFSet x✝¹ y : PSet α : Type u A : α → PSet x✝ : Quotient.mk setoid y ∈ ZFSet.sep p (Quotient.mk setoid (PSet.mk α A)) a : Type (PSet.mk α A) pa : (fun y => p (mk y)) (Func (PSet.mk α A) a) h : PSet.Equiv y (Func ↑(Resp.f { val := PSet.sep fun y => p (mk y), property := (_ : ∀ (x x_1 : PSet), PSet.Equiv x x_1 → Arity.Equiv (PSet.sep (fun y => p (mk y)) x) (PSet.sep (fun y => p (mk y)) x_1)) } (PSet.mk α A)) { val := a, property := pa }) ⊢ p (Quotient.mk setoid y) rwa [@Quotient.sound PSet _ _ _ h] p : ZFSet → Prop x y✝ : ZFSet x✝¹ y : PSet α : Type u A : α → PSet x✝ : Quotient.mk setoid y ∈ Quotient.mk setoid (PSet.mk α A) ∧ p (Quotient.mk setoid y) a : Type (PSet.mk α A) h : PSet.Equiv y (Func (PSet.mk α A) a) pa : p (Quotient.mk setoid y) ⊢ (fun y => p (mk y)) (Func (PSet.mk α A) a) rw [mk_func] at h p : ZFSet → Prop x y✝ : ZFSet x✝¹ y : PSet α : Type u A : α → PSet x✝ : Quotient.mk setoid y ∈ Quotient.mk setoid (PSet.mk α A) ∧ p (Quotient.mk setoid y) a : Type (PSet.mk α A) h : PSet.Equiv y (A a) pa : p (Quotient.mk setoid y) ⊢ p (mk (Func (PSet.mk α A) a)) rwa [mk_func, ← ZFSet.sound h] ** Qed
ZFSet.toSet_sep a : ZFSet p : ZFSet → Prop ⊢ toSet (ZFSet.sep p a) = {x \| x ∈ toSet a ∧ p x} ext case h a : ZFSet p : ZFSet → Prop x✝ : ZFSet ⊢ x✝ ∈ toSet (ZFSet.sep p a) ↔ x✝ ∈ {x \| x ∈ toSet a ∧ p x} simp ** Qed
ZFSet.mem_powerset x y : ZFSet x✝¹ x✝ : PSet α : Type u A : α → PSet β : Type u B : β → PSet ⊢ PSet.mk β B ∈ PSet.powerset (PSet.mk α A) ↔ Quotient.mk setoid (PSet.mk β B) ⊆ Quotient.mk setoid (PSet.mk α A) simp [mem_powerset, subset_iff] ** Qed
ZFSet.sUnion_lem α β : Type u A : α → PSet B : β → PSet αβ : ∀ (a : α), ∃ b, PSet.Equiv (A a) (B b) a : Type (PSet.mk α A) c : Type (Func (PSet.mk α A) a) ⊢ ∃ b, PSet.Equiv (Func (⋃₀ PSet.mk α A) { fst := a, snd := c }) (Func (⋃₀ PSet.mk β B) b) let ⟨b, hb⟩ := αβ a α β : Type u A : α → PSet B : β → PSet αβ : ∀ (a : α), ∃ b, PSet.Equiv (A a) (B b) a : Type (PSet.mk α A) c : Type (Func (PSet.mk α A) a) b : β hb : PSet.Equiv (A a) (B b) ⊢ ∃ b, PSet.Equiv (Func (⋃₀ PSet.mk α A) { fst := a, snd := c }) (Func (⋃₀ PSet.mk β B) b) induction' ea : A a with γ Γ case mk α β : Type u A : α → PSet B : β → PSet αβ : ∀ (a : α), ∃ b, PSet.Equiv (A a) (B b) a : Type (PSet.mk α A) c : Type (Func (PSet.mk α A) a) b : β hb : PSet.Equiv (A a) (B b) x✝ : PSet ea✝ : A a = x✝ γ : Type u Γ : γ → PSet A_ih✝ : ∀ (a_1 : γ), A a = Γ a_1 → ∃ b, PSet.Equiv (Func (⋃₀ PSet.mk α A) { fst := a, snd := c }) (Func (⋃₀ PSet.mk β B) b) ea : A a = PSet.mk γ Γ ⊢ ∃ b, PSet.Equiv (Func (⋃₀ PSet.mk α A) { fst := a, snd := c }) (Func (⋃₀ PSet.mk β B) b) induction' eb : B b with δ Δ case mk.mk α β : Type u A : α → PSet B : β → PSet αβ : ∀ (a : α), ∃ b, PSet.Equiv (A a) (B b) a : Type (PSet.mk α A) c : Type (Func (PSet.mk α A) a) b : β hb : PSet.Equiv (A a) (B b) x✝¹ : PSet ea✝ : A a = x✝¹ γ : Type u Γ : γ → PSet A_ih✝¹ : ∀ (a_1 : γ), A a = Γ a_1 → ∃ b, PSet.Equiv (Func (⋃₀ PSet.mk α A) { fst := a, snd := c }) (Func (⋃₀ PSet.mk β B) b) ea : A a = PSet.mk γ Γ x✝ : PSet eb✝ : B b = x✝ δ : Type u Δ : δ → PSet A_ih✝ : ∀ (a_1 : δ), B b = Δ a_1 → ∃ b, PSet.Equiv (Func (⋃₀ PSet.mk α A) { fst := a, snd := c }) (Func (⋃₀ PSet.mk β B) b) eb : B b = PSet.mk δ Δ ⊢ ∃ b, PSet.Equiv (Func (⋃₀ PSet.mk α A) { fst := a, snd := c }) (Func (⋃₀ PSet.mk β B) b) rw [ea, eb] at hb case mk.mk α β : Type u A : α → PSet B : β → PSet αβ : ∀ (a : α), ∃ b, PSet.Equiv (A a) (B b) a : Type (PSet.mk α A) c : Type (Func (PSet.mk α A) a) b : β x✝¹ : PSet ea✝ : A a = x✝¹ γ : Type u Γ : γ → PSet A_ih✝¹ : ∀ (a_1 : γ), A a = Γ a_1 → ∃ b, PSet.Equiv (Func (⋃₀ PSet.mk α A) { fst := a, snd := c }) (Func (⋃₀ PSet.mk β B) b) ea : A a = PSet.mk γ Γ x✝ : PSet eb✝ : B b = x✝ δ : Type u Δ : δ → PSet hb : PSet.Equiv (PSet.mk γ Γ) (PSet.mk δ Δ) A_ih✝ : ∀ (a_1 : δ), B b = Δ a_1 → ∃ b, PSet.Equiv (Func (⋃₀ PSet.mk α A) { fst := a, snd := c }) (Func (⋃₀ PSet.mk β B) b) eb : B b = PSet.mk δ Δ ⊢ ∃ b, PSet.Equiv (Func (⋃₀ PSet.mk α A) { fst := a, snd := c }) (Func (⋃₀ PSet.mk β B) b) cases' hb with γδ δγ case mk.mk.intro α β : Type u A : α → PSet B : β → PSet αβ : ∀ (a : α), ∃ b, PSet.Equiv (A a) (B b) a : Type (PSet.mk α A) c : Type (Func (PSet.mk α A) a) b : β x✝¹ : PSet ea✝ : A a = x✝¹ γ : Type u Γ : γ → PSet A_ih✝¹ : ∀ (a_1 : γ), A a = Γ a_1 → ∃ b, PSet.Equiv (Func (⋃₀ PSet.mk α A) { fst := a, snd := c }) (Func (⋃₀ PSet.mk β B) b) ea : A a = PSet.mk γ Γ x✝ : PSet eb✝ : B b = x✝ δ : Type u Δ : δ → PSet A_ih✝ : ∀ (a_1 : δ), B b = Δ a_1 → ∃ b, PSet.Equiv (Func (⋃₀ PSet.mk α A) { fst := a, snd := c }) (Func (⋃₀ PSet.mk β B) b) eb : B b = PSet.mk δ Δ γδ : ∀ (a : γ), ∃ b, PSet.Equiv (Γ a) (Δ b) δγ : ∀ (b : δ), ∃ a, PSet.Equiv (Γ a) (Δ b) ⊢ ∃ b, PSet.Equiv (Func (⋃₀ PSet.mk α A) { fst := a, snd := c }) (Func (⋃₀ PSet.mk β B) b) let c : (A a).Type := c case mk.mk.intro α β : Type u A : α → PSet B : β → PSet αβ : ∀ (a : α), ∃ b, PSet.Equiv (A a) (B b) a : Type (PSet.mk α A) c✝ : Type (Func (PSet.mk α A) a) b : β x✝¹ : PSet ea✝ : A a = x✝¹ γ : Type u Γ : γ → PSet A_ih✝¹ : ∀ (a_1 : γ), A a = Γ a_1 → ∃ b, PSet.Equiv (Func (⋃₀ PSet.mk α A) { fst := a, snd := c✝ }) (Func (⋃₀ PSet.mk β B) b) ea : A a = PSet.mk γ Γ x✝ : PSet eb✝ : B b = x✝ δ : Type u Δ : δ → PSet A_ih✝ : ∀ (a_1 : δ), B b = Δ a_1 → ∃ b, PSet.Equiv (Func (⋃₀ PSet.mk α A) { fst := a, snd := c✝ }) (Func (⋃₀ PSet.mk β B) b) eb : B b = PSet.mk δ Δ γδ : ∀ (a : γ), ∃ b, PSet.Equiv (Γ a) (Δ b) δγ : ∀ (b : δ), ∃ a, PSet.Equiv (Γ a) (Δ b) c : Type (A a) := c✝ ⊢ ∃ b, PSet.Equiv (Func (⋃₀ PSet.mk α A) { fst := a, snd := c✝ }) (Func (⋃₀ PSet.mk β B) b) let ⟨d, hd⟩ := γδ (by rwa [ea] at c) case mk.mk.intro α β : Type u A : α → PSet B : β → PSet αβ : ∀ (a : α), ∃ b, PSet.Equiv (A a) (B b) a : Type (PSet.mk α A) c✝ : Type (Func (PSet.mk α A) a) b : β x✝¹ : PSet ea✝ : A a = x✝¹ γ : Type u Γ : γ → PSet A_ih✝¹ : ∀ (a_1 : γ), A a = Γ a_1 → ∃ b, PSet.Equiv (Func (⋃₀ PSet.mk α A) { fst := a, snd := c✝ }) (Func (⋃₀ PSet.mk β B) b) ea : A a = PSet.mk γ Γ x✝ : PSet eb✝ : B b = x✝ δ : Type u Δ : δ → PSet A_ih✝ : ∀ (a_1 : δ), B b = Δ a_1 → ∃ b, PSet.Equiv (Func (⋃₀ PSet.mk α A) { fst := a, snd := c✝ }) (Func (⋃₀ PSet.mk β B) b) eb : B b = PSet.mk δ Δ γδ : ∀ (a : γ), ∃ b, PSet.Equiv (Γ a) (Δ b) δγ : ∀ (b : δ), ∃ a, PSet.Equiv (Γ a) (Δ b) c : Type (A a) := c✝ d : δ hd : PSet.Equiv (Γ (Eq.mp (_ : Type (A a) = Type (PSet.mk γ Γ)) c)) (Δ d) ⊢ ∃ b, PSet.Equiv (Func (⋃₀ PSet.mk α A) { fst := a, snd := c✝ }) (Func (⋃₀ PSet.mk β B) b) use ⟨b, Eq.ndrec d (Eq.symm eb)⟩ case h α β : Type u A : α → PSet B : β → PSet αβ : ∀ (a : α), ∃ b, PSet.Equiv (A a) (B b) a : Type (PSet.mk α A) c✝ : Type (Func (PSet.mk α A) a) b : β x✝¹ : PSet ea✝ : A a = x✝¹ γ : Type u Γ : γ → PSet A_ih✝¹ : ∀ (a_1 : γ), A a = Γ a_1 → ∃ b, PSet.Equiv (Func (⋃₀ PSet.mk α A) { fst := a, snd := c✝ }) (Func (⋃₀ PSet.mk β B) b) ea : A a = PSet.mk γ Γ x✝ : PSet eb✝ : B b = x✝ δ : Type u Δ : δ → PSet A_ih✝ : ∀ (a_1 : δ), B b = Δ a_1 → ∃ b, PSet.Equiv (Func (⋃₀ PSet.mk α A) { fst := a, snd := c✝ }) (Func (⋃₀ PSet.mk β B) b) eb : B b = PSet.mk δ Δ γδ : ∀ (a : γ), ∃ b, PSet.Equiv (Γ a) (Δ b) δγ : ∀ (b : δ), ∃ a, PSet.Equiv (Γ a) (Δ b) c : Type (A a) := c✝ d : δ hd : PSet.Equiv (Γ (Eq.mp (_ : Type (A a) = Type (PSet.mk γ Γ)) c)) (Δ d) ⊢ PSet.Equiv (Func (⋃₀ PSet.mk α A) { fst := a, snd := c✝ }) (Func (⋃₀ PSet.mk β B) { fst := b, snd := (_ : PSet.mk δ Δ = Func (PSet.mk β B) b) ▸ d }) change PSet.Equiv ((A a).Func c) ((B b).Func (Eq.ndrec d eb.symm)) case h α β : Type u A : α → PSet B : β → PSet αβ : ∀ (a : α), ∃ b, PSet.Equiv (A a) (B b) a : Type (PSet.mk α A) c✝ : Type (Func (PSet.mk α A) a) b : β x✝¹ : PSet ea✝ : A a = x✝¹ γ : Type u Γ : γ → PSet A_ih✝¹ : ∀ (a_1 : γ), A a = Γ a_1 → ∃ b, PSet.Equiv (Func (⋃₀ PSet.mk α A) { fst := a, snd := c✝ }) (Func (⋃₀ PSet.mk β B) b) ea : A a = PSet.mk γ Γ x✝ : PSet eb✝ : B b = x✝ δ : Type u Δ : δ → PSet A_ih✝ : ∀ (a_1 : δ), B b = Δ a_1 → ∃ b, PSet.Equiv (Func (⋃₀ PSet.mk α A) { fst := a, snd := c✝ }) (Func (⋃₀ PSet.mk β B) b) eb : B b = PSet.mk δ Δ γδ : ∀ (a : γ), ∃ b, PSet.Equiv (Γ a) (Δ b) δγ : ∀ (b : δ), ∃ a, PSet.Equiv (Γ a) (Δ b) c : Type (A a) := c✝ d : δ hd : PSet.Equiv (Γ (Eq.mp (_ : Type (A a) = Type (PSet.mk γ Γ)) c)) (Δ d) ⊢ PSet.Equiv (Func (A a) c) (Func (B b) ((_ : PSet.mk δ Δ = B b) ▸ d)) match A a, B b, ea, eb, c, d, hd with \| _, _, rfl, rfl, _, _, hd => exact hd α β : Type u A : α → PSet B : β → PSet αβ : ∀ (a : α), ∃ b, PSet.Equiv (A a) (B b) a : Type (PSet.mk α A) c✝ : Type (Func (PSet.mk α A) a) b : β x✝¹ : PSet ea✝ : A a = x✝¹ γ : Type u Γ : γ → PSet A_ih✝¹ : ∀ (a_1 : γ), A a = Γ a_1 → ∃ b, PSet.Equiv (Func (⋃₀ PSet.mk α A) { fst := a, snd := c✝ }) (Func (⋃₀ PSet.mk β B) b) ea : A a = PSet.mk γ Γ x✝ : PSet eb✝ : B b = x✝ δ : Type u Δ : δ → PSet A_ih✝ : ∀ (a_1 : δ), B b = Δ a_1 → ∃ b, PSet.Equiv (Func (⋃₀ PSet.mk α A) { fst := a, snd := c✝ }) (Func (⋃₀ PSet.mk β B) b) eb : B b = PSet.mk δ Δ γδ : ∀ (a : γ), ∃ b, PSet.Equiv (Γ a) (Δ b) δγ : ∀ (b : δ), ∃ a, PSet.Equiv (Γ a) (Δ b) c : Type (A a) := c✝ ⊢ γ rwa [ea] at c α β : Type u A : α → PSet B : β → PSet αβ : ∀ (a : α), ∃ b, PSet.Equiv (A a) (B b) a : Type (PSet.mk α A) c✝ : Type (Func (PSet.mk α A) a) b : β x✝³ : PSet ea✝ : A a = x✝³ γ : Type u Γ : γ → PSet A_ih✝¹ : ∀ (a_1 : γ), A a = Γ a_1 → ∃ b, PSet.Equiv (Func (⋃₀ PSet.mk α A) { fst := a, snd := c✝ }) (Func (⋃₀ PSet.mk β B) b) ea : A a = PSet.mk γ Γ x✝² : PSet eb✝ : B b = x✝² δ : Type u Δ : δ → PSet A_ih✝ : ∀ (a_1 : δ), B b = Δ a_1 → ∃ b, PSet.Equiv (Func (⋃₀ PSet.mk α A) { fst := a, snd := c✝ }) (Func (⋃₀ PSet.mk β B) b) eb : B b = PSet.mk δ Δ γδ : ∀ (a : γ), ∃ b, PSet.Equiv (Γ a) (Δ b) δγ : ∀ (b : δ), ∃ a, PSet.Equiv (Γ a) (Δ b) c : Type (A a) := c✝ d : δ hd✝ : PSet.Equiv (Γ (Eq.mp (_ : Type (A a) = Type (PSet.mk γ Γ)) c)) (Δ d) x✝¹ : Type (PSet.mk γ Γ) x✝ : δ hd : PSet.Equiv (Γ (Eq.mp (_ : Type (PSet.mk γ Γ) = Type (PSet.mk γ Γ)) x✝¹)) (Δ x✝) ⊢ PSet.Equiv (Func (PSet.mk γ Γ) x✝¹) (Func (PSet.mk δ Δ) ((_ : PSet.mk δ Δ = PSet.mk δ Δ) ▸ x✝)) exact hd ** Qed
ZFSet.mem_sInter x y : ZFSet h : ZFSet.Nonempty x ⊢ y ∈ ⋂₀ x ↔ ∀ (z : ZFSet), z ∈ x → y ∈ z rw [sInter, dif_pos h] x y : ZFSet h : ZFSet.Nonempty x ⊢ y ∈ ZFSet.sep (fun y => ∀ (z : ZFSet), z ∈ x → y ∈ z) (Set.Nonempty.some h) ↔ ∀ (z : ZFSet), z ∈ x → y ∈ z simp only [mem_toSet, mem_sep, and_iff_right_iff_imp] x y : ZFSet h : ZFSet.Nonempty x ⊢ (∀ (z : ZFSet), z ∈ x → y ∈ z) → y ∈ Set.Nonempty.some h exact fun H => H _ h.some_mem ** Qed
ZFSet.sUnion_empty ⊢ ⋃₀ ∅ = ∅ ext case a z✝ : ZFSet ⊢ z✝ ∈ ⋃₀ ∅ ↔ z✝ ∈ ∅ simp ** Qed
ZFSet.sInter_empty ⊢ ¬ZFSet.Nonempty ∅ simp ** Qed
ZFSet.mem_of_mem_sInter x y z : ZFSet hy : y ∈ ⋂₀ x hz : z ∈ x ⊢ y ∈ z rcases eq_empty_or_nonempty x with (rfl \| hx) case inl y z : ZFSet hy : y ∈ ⋂₀ ∅ hz : z ∈ ∅ ⊢ y ∈ z exact (not_mem_empty z hz).elim case inr x y z : ZFSet hy : y ∈ ⋂₀ x hz : z ∈ x hx : ZFSet.Nonempty x ⊢ y ∈ z exact (mem_sInter hx).1 hy z hz ** Qed
ZFSet.sUnion_singleton x y : ZFSet ⊢ y ∈ ⋃₀ {x} ↔ y ∈ x simp_rw [mem_sUnion, mem_singleton, exists_eq_left] ** Qed
ZFSet.sInter_singleton x y : ZFSet ⊢ y ∈ ⋂₀ {x} ↔ y ∈ x simp_rw [mem_sInter (singleton_nonempty x), mem_singleton, forall_eq] ** Qed
ZFSet.toSet_sUnion x : ZFSet ⊢ toSet (⋃₀ x) = ⋃₀ (toSet '' toSet x) ext case h x x✝ : ZFSet ⊢ x✝ ∈ toSet (⋃₀ x) ↔ x✝ ∈ ⋃₀ (toSet '' toSet x) simp ** Qed
ZFSet.toSet_sInter x : ZFSet h : ZFSet.Nonempty x ⊢ toSet (⋂₀ x) = ⋂₀ (toSet '' toSet x) ext case h x : ZFSet h : ZFSet.Nonempty x x✝ : ZFSet ⊢ x✝ ∈ toSet (⋂₀ x) ↔ x✝ ∈ ⋂₀ (toSet '' toSet x) simp [mem_sInter h] ** Qed
ZFSet.singleton_injective x y : ZFSet H : {x} = {y} ⊢ x = y let this := congr_arg sUnion H x y : ZFSet H : {x} = {y} this : ⋃₀ {x} = ⋃₀ {y} := congr_arg sUnion H ⊢ x = y rwa [sUnion_singleton, sUnion_singleton] at this ** Qed
ZFSet.toSet_union x y : ZFSet ⊢ toSet (x ∪ y) = toSet x ∪ toSet y change (⋃₀ {x, y}).toSet = _ x y : ZFSet ⊢ toSet (⋃₀ {x, y}) = toSet x ∪ toSet y simp ** Qed
ZFSet.toSet_inter x y : ZFSet ⊢ toSet (x ∩ y) = toSet x ∩ toSet y change (ZFSet.sep (fun z => z ∈ y) x).toSet = _ x y : ZFSet ⊢ toSet (ZFSet.sep (fun z => z ∈ y) x) = toSet x ∩ toSet y ext case h x y x✝ : ZFSet ⊢ x✝ ∈ toSet (ZFSet.sep (fun z => z ∈ y) x) ↔ x✝ ∈ toSet x ∩ toSet y simp ** Qed
ZFSet.toSet_sdiff x y : ZFSet ⊢ toSet (x \ y) = toSet x \ toSet y change (ZFSet.sep (fun z => z ∉ y) x).toSet = _ x y : ZFSet ⊢ toSet (ZFSet.sep (fun z => ¬z ∈ y) x) = toSet x \ toSet y ext case h x y x✝ : ZFSet ⊢ x✝ ∈ toSet (ZFSet.sep (fun z => ¬z ∈ y) x) ↔ x✝ ∈ toSet x \ toSet y simp ** Qed
ZFSet.mem_union x y z : ZFSet ⊢ z ∈ x ∪ y ↔ z ∈ x ∨ z ∈ y rw [← mem_toSet] x y z : ZFSet ⊢ z ∈ toSet (x ∪ y) ↔ z ∈ x ∨ z ∈ y simp ** Qed
ZFSet.toSet_image f : ZFSet → ZFSet H : Definable 1 f x : ZFSet ⊢ toSet (image f x) = f '' toSet x ext case h f : ZFSet → ZFSet H : Definable 1 f x x✝ : ZFSet ⊢ x✝ ∈ toSet (image f x) ↔ x✝ ∈ f '' toSet x simp ** Qed
ZFSet.mem_range α : Type u f : α → ZFSet x : ZFSet y : PSet ⊢ Quotient.mk setoid y ∈ range f ↔ Quotient.mk setoid y ∈ Set.range f constructor case mp α : Type u f : α → ZFSet x : ZFSet y : PSet ⊢ Quotient.mk setoid y ∈ range f → Quotient.mk setoid y ∈ Set.range f rintro ⟨z, hz⟩ case mp.intro α : Type u f : α → ZFSet x : ZFSet y : PSet z : Type (PSet.mk (ULift.{v, u} α) (Quotient.out ∘ f ∘ ULift.down)) hz : PSet.Equiv y (Func (PSet.mk (ULift.{v, u} α) (Quotient.out ∘ f ∘ ULift.down)) z) ⊢ Quotient.mk setoid y ∈ Set.range f exact ⟨z.down, Quotient.eq_mk_iff_out.2 hz.symm⟩ case mpr α : Type u f : α → ZFSet x : ZFSet y : PSet ⊢ Quotient.mk setoid y ∈ Set.range f → Quotient.mk setoid y ∈ range f rintro ⟨z, hz⟩ case mpr.intro α : Type u f : α → ZFSet x : ZFSet y : PSet z : α hz : f z = Quotient.mk setoid y ⊢ Quotient.mk setoid y ∈ range f use ULift.up z case h α : Type u f : α → ZFSet x : ZFSet y : PSet z : α hz : f z = Quotient.mk setoid y ⊢ PSet.Equiv y (Func (PSet.mk (ULift.{v, u} α) (Quotient.out ∘ f ∘ ULift.down)) { down := z }) simpa [hz] using PSet.Equiv.symm (Quotient.mk_out y) ** Qed
ZFSet.toSet_range α : Type u f : α → ZFSet ⊢ toSet (range f) = Set.range f ext case h α : Type u f : α → ZFSet x✝ : ZFSet ⊢ x✝ ∈ toSet (range f) ↔ x✝ ∈ Set.range f simp ** Qed
ZFSet.toSet_pair x y : ZFSet ⊢ toSet (pair x y) = {{x}, {x, y}} simp [pair] ** Qed
ZFSet.mem_pairSep p : ZFSet → ZFSet → Prop x y z : ZFSet ⊢ z ∈ pairSep p x y ↔ ∃ a, a ∈ x ∧ ∃ b, b ∈ y ∧ z = pair a b ∧ p a b refine' mem_sep.trans ⟨And.right, fun e => ⟨_, e⟩⟩ p : ZFSet → ZFSet → Prop x y z : ZFSet e : ∃ a, a ∈ x ∧ ∃ b, b ∈ y ∧ z = pair a b ∧ p a b ⊢ z ∈ powerset (powerset (x ∪ y)) rcases e with ⟨a, ax, b, bY, rfl, pab⟩ case intro.intro.intro.intro.intro p : ZFSet → ZFSet → Prop x y a : ZFSet ax : a ∈ x b : ZFSet bY : b ∈ y pab : p a b ⊢ pair a b ∈ powerset (powerset (x ∪ y)) simp only [mem_powerset, subset_def, mem_union, pair, mem_pair] case intro.intro.intro.intro.intro p : ZFSet → ZFSet → Prop x y a : ZFSet ax : a ∈ x b : ZFSet bY : b ∈ y pab : p a b ⊢ ∀ ⦃z : ZFSet⦄, z = {a} ∨ z = {a, b} → ∀ ⦃z_1 : ZFSet⦄, z_1 ∈ z → z_1 ∈ x ∨ z_1 ∈ y rintro u (rfl \| rfl) v <;> simp only [mem_singleton, mem_pair] case intro.intro.intro.intro.intro.inl p : ZFSet → ZFSet → Prop x y a : ZFSet ax : a ∈ x b : ZFSet bY : b ∈ y pab : p a b v : ZFSet ⊢ v = a → v ∈ x ∨ v ∈ y rintro rfl case intro.intro.intro.intro.intro.inl p : ZFSet → ZFSet → Prop x y b : ZFSet bY : b ∈ y v : ZFSet ax : v ∈ x pab : p v b ⊢ v ∈ x ∨ v ∈ y exact Or.inl ax case intro.intro.intro.intro.intro.inr p : ZFSet → ZFSet → Prop x y a : ZFSet ax : a ∈ x b : ZFSet bY : b ∈ y pab : p a b v : ZFSet ⊢ v = a ∨ v = b → v ∈ x ∨ v ∈ y rintro (rfl \| rfl) <;> [left; right] <;> assumption ** Qed
ZFSet.pair_injective x x' y y' : ZFSet H : pair x y = pair x' y' ⊢ x = x' ∧ y = y' have ae := ext_iff.1 H x x' y y' : ZFSet H : pair x y = pair x' y' ae : ∀ (z : ZFSet), z ∈ pair x y ↔ z ∈ pair x' y' ⊢ x = x' ∧ y = y' simp only [pair, mem_pair] at ae x y y' : ZFSet H : pair x y = pair x y' ae : ∀ (z : ZFSet), z = {x} ∨ z = {x, y} ↔ z = {x} ∨ z = {x, y'} he : x = y → y = y' ⊢ x = x ∧ y = y' obtain xyx \| xyy' := (ae {x, y}).1 (by simp) x x' y y' : ZFSet H : pair x y = pair x' y' ae : ∀ (z : ZFSet), z = {x} ∨ z = {x, y} ↔ z = {x'} ∨ z = {x', y'} ⊢ x = x' cases' (ae {x}).1 (by simp) with h h x x' y y' : ZFSet H : pair x y = pair x' y' ae : ∀ (z : ZFSet), z = {x} ∨ z = {x, y} ↔ z = {x'} ∨ z = {x', y'} ⊢ {x} = {x} ∨ {x} = {x, y} simp case inl x x' y y' : ZFSet H : pair x y = pair x' y' ae : ∀ (z : ZFSet), z = {x} ∨ z = {x, y} ↔ z = {x'} ∨ z = {x', y'} h : {x} = {x'} ⊢ x = x' exact singleton_injective h case inr x x' y y' : ZFSet H : pair x y = pair x' y' ae : ∀ (z : ZFSet), z = {x} ∨ z = {x, y} ↔ z = {x'} ∨ z = {x', y'} h : {x} = {x', y'} ⊢ x = x' have m : x' ∈ ({x} : ZFSet) := by simp [h] case inr x x' y y' : ZFSet H : pair x y = pair x' y' ae : ∀ (z : ZFSet), z = {x} ∨ z = {x, y} ↔ z = {x'} ∨ z = {x', y'} h : {x} = {x', y'} m : x' ∈ {x} ⊢ x = x' rw [mem_singleton.mp m] x x' y y' : ZFSet H : pair x y = pair x' y' ae : ∀ (z : ZFSet), z = {x} ∨ z = {x, y} ↔ z = {x'} ∨ z = {x', y'} h : {x} = {x', y'} ⊢ x' ∈ {x} simp [h] x y y' : ZFSet H : pair x y = pair x y' ae : ∀ (z : ZFSet), z = {x} ∨ z = {x, y} ↔ z = {x} ∨ z = {x, y'} ⊢ x = y → y = y' rintro rfl x y' : ZFSet H : pair x x = pair x y' ae : ∀ (z : ZFSet), z = {x} ∨ z = {x, x} ↔ z = {x} ∨ z = {x, y'} ⊢ x = y' cases' (ae {x, y'}).2 (by simp only [eq_self_iff_true, or_true_iff]) with xy'x xy'xx x y' : ZFSet H : pair x x = pair x y' ae : ∀ (z : ZFSet), z = {x} ∨ z = {x, x} ↔ z = {x} ∨ z = {x, y'} ⊢ {x, y'} = {x} ∨ {x, y'} = {x, y'} simp only [eq_self_iff_true, or_true_iff] case inl x y' : ZFSet H : pair x x = pair x y' ae : ∀ (z : ZFSet), z = {x} ∨ z = {x, x} ↔ z = {x} ∨ z = {x, y'} xy'x : {x, y'} = {x} ⊢ x = y' rw [eq_comm, ← mem_singleton, ← xy'x, mem_pair] case inl x y' : ZFSet H : pair x x = pair x y' ae : ∀ (z : ZFSet), z = {x} ∨ z = {x, x} ↔ z = {x} ∨ z = {x, y'} xy'x : {x, y'} = {x} ⊢ y' = x ∨ y' = y' exact Or.inr rfl case inr x y' : ZFSet H : pair x x = pair x y' ae : ∀ (z : ZFSet), z = {x} ∨ z = {x, x} ↔ z = {x} ∨ z = {x, y'} xy'xx : {x, y'} = {x, x} ⊢ x = y' simpa [eq_comm] using (ext_iff.1 xy'xx y').1 (by simp) x y' : ZFSet H : pair x x = pair x y' ae : ∀ (z : ZFSet), z = {x} ∨ z = {x, x} ↔ z = {x} ∨ z = {x, y'} xy'xx : {x, y'} = {x, x} ⊢ y' ∈ {x, y'} simp x y y' : ZFSet H : pair x y = pair x y' ae : ∀ (z : ZFSet), z = {x} ∨ z = {x, y} ↔ z = {x} ∨ z = {x, y'} he : x = y → y = y' ⊢ {x, y} = {x} ∨ {x, y} = {x, y} simp case inl x y y' : ZFSet H : pair x y = pair x y' ae : ∀ (z : ZFSet), z = {x} ∨ z = {x, y} ↔ z = {x} ∨ z = {x, y'} he : x = y → y = y' xyx : {x, y} = {x} ⊢ x = x ∧ y = y' obtain rfl := mem_singleton.mp ((ext_iff.1 xyx y).1 <\| by simp) case inl y y' : ZFSet H : pair y y = pair y y' ae : ∀ (z : ZFSet), z = {y} ∨ z = {y, y} ↔ z = {y} ∨ z = {y, y'} he : y = y → y = y' xyx : {y, y} = {y} ⊢ y = y ∧ y = y' simp [he rfl] x y y' : ZFSet H : pair x y = pair x y' ae : ∀ (z : ZFSet), z = {x} ∨ z = {x, y} ↔ z = {x} ∨ z = {x, y'} he : x = y → y = y' xyx : {x, y} = {x} ⊢ y ∈ {x, y} simp case inr x y y' : ZFSet H : pair x y = pair x y' ae : ∀ (z : ZFSet), z = {x} ∨ z = {x, y} ↔ z = {x} ∨ z = {x, y'} he : x = y → y = y' xyy' : {x, y} = {x, y'} ⊢ x = x ∧ y = y' obtain rfl \| yy' := mem_pair.mp ((ext_iff.1 xyy' y).1 <\| by simp) x y y' : ZFSet H : pair x y = pair x y' ae : ∀ (z : ZFSet), z = {x} ∨ z = {x, y} ↔ z = {x} ∨ z = {x, y'} he : x = y → y = y' xyy' : {x, y} = {x, y'} ⊢ y ∈ {x, y} simp case inr.inl y y' : ZFSet H : pair y y = pair y y' ae : ∀ (z : ZFSet), z = {y} ∨ z = {y, y} ↔ z = {y} ∨ z = {y, y'} he : y = y → y = y' xyy' : {y, y} = {y, y'} ⊢ y = y ∧ y = y' simp [he rfl] case inr.inr x y y' : ZFSet H : pair x y = pair x y' ae : ∀ (z : ZFSet), z = {x} ∨ z = {x, y} ↔ z = {x} ∨ z = {x, y'} he : x = y → y = y' xyy' : {x, y} = {x, y'} yy' : y = y' ⊢ x = x ∧ y = y' simp [yy'] ** Qed
ZFSet.mem_prod x y z : ZFSet ⊢ z ∈ prod x y ↔ ∃ a, a ∈ x ∧ ∃ b, b ∈ y ∧ z = pair a b simp [prod] ** Qed
ZFSet.pair_mem_prod x y a b : ZFSet ⊢ pair a b ∈ prod x y ↔ a ∈ x ∧ b ∈ y simp ** Qed
ZFSet.mem_funs x y f : ZFSet ⊢ f ∈ funs x y ↔ IsFunc x y f simp [funs, IsFunc] ** Qed
ZFSet.map_unique f : ZFSet → ZFSet H : Definable 1 f x z : ZFSet zx : z ∈ x y : ZFSet yx : (fun w => pair z w ∈ map f x) y ⊢ y = f z let ⟨w, _, we⟩ := mem_image.1 yx f : ZFSet → ZFSet H : Definable 1 f x z : ZFSet zx : z ∈ x y : ZFSet yx : (fun w => pair z w ∈ map f x) y w : ZFSet left✝ : w ∈ x we : pair w (f w) = pair z y ⊢ y = f z let ⟨wz, fy⟩ := pair_injective we f : ZFSet → ZFSet H : Definable 1 f x z : ZFSet zx : z ∈ x y : ZFSet yx : (fun w => pair z w ∈ map f x) y w : ZFSet left✝ : w ∈ x we : pair w (f w) = pair z y wz : w = z fy : f w = y ⊢ y = f z rw [← fy, wz] ** Qed
ZFSet.hereditarily_iff p : ZFSet → Prop x y : ZFSet ⊢ Hereditarily p x ↔ p x ∧ ∀ (y : ZFSet), y ∈ x → Hereditarily p y rw [← Hereditarily] ** Qed
ZFSet.Hereditarily.empty p : ZFSet → Prop x y : ZFSet ⊢ Hereditarily p x → p ∅ apply @ZFSet.inductionOn _ x p : ZFSet → Prop x y : ZFSet ⊢ ∀ (x : ZFSet), (∀ (y : ZFSet), y ∈ x → Hereditarily p y → p ∅) → Hereditarily p x → p ∅ intro y IH h p : ZFSet → Prop x y✝ y : ZFSet IH : ∀ (y_1 : ZFSet), y_1 ∈ y → Hereditarily p y_1 → p ∅ h : Hereditarily p y ⊢ p ∅ rcases ZFSet.eq_empty_or_nonempty y with (rfl \| ⟨a, ha⟩) case inl p : ZFSet → Prop x y : ZFSet IH : ∀ (y : ZFSet), y ∈ ∅ → Hereditarily p y → p ∅ h : Hereditarily p ∅ ⊢ p ∅ exact h.self case inr.intro p : ZFSet → Prop x y✝ y : ZFSet IH : ∀ (y_1 : ZFSet), y_1 ∈ y → Hereditarily p y_1 → p ∅ h : Hereditarily p y a : ZFSet ha : a ∈ toSet y ⊢ p ∅ exact IH a ha (h.mem ha) ** Qed
Class.mem_wf ⊢ ∀ (x : ZFSet), Acc (fun x x_1 => x ∈ x_1) ↑x refine' fun a => ZFSet.inductionOn a fun x IH => ⟨_, _⟩ a x : ZFSet IH : ∀ (y : ZFSet), y ∈ x → Acc (fun x x_1 => x ∈ x_1) ↑y ⊢ ∀ (y : Class), y ∈ ↑x → Acc (fun x x_1 => x ∈ x_1) y rintro A ⟨z, rfl, hz⟩ case intro.intro a x : ZFSet IH : ∀ (y : ZFSet), y ∈ x → Acc (fun x x_1 => x ∈ x_1) ↑y z : ZFSet hz : ↑x z ⊢ Acc (fun x x_1 => x ∈ x_1) ↑z exact IH z hz H : ∀ (x : ZFSet), Acc (fun x x_1 => x ∈ x_1) ↑x ⊢ ∀ (a : Class), Acc (fun x x_1 => x ∈ x_1) a refine' fun A => ⟨A, _⟩ H : ∀ (x : ZFSet), Acc (fun x x_1 => x ∈ x_1) ↑x A : Class ⊢ ∀ (y : Class), y ∈ A → Acc (fun x x_1 => x ∈ x_1) y rintro B ⟨x, rfl, _⟩ case intro.intro H : ∀ (x : ZFSet), Acc (fun x x_1 => x ∈ x_1) ↑x A : Class x : ZFSet right✝ : A x ⊢ Acc (fun x x_1 => x ∈ x_1) ↑x exact H x ** Qed
Class.congToClass_empty ⊢ congToClass ∅ = ∅ ext z case a z : ZFSet ⊢ congToClass ∅ z ↔ ∅ z simp only [congToClass, not_empty_hom, iff_false_iff] case a z : ZFSet ⊢ ¬setOf (fun y => ↑y ∈ ∅) z exact Set.not_mem_empty z ** Qed
Class.classToCong_empty ⊢ classToCong ∅ = ∅ ext case h x✝ : Class ⊢ x✝ ∈ classToCong ∅ ↔ x✝ ∈ ∅ simp [classToCong] ** Qed
Class.ofSet.inj x y : ZFSet h : ↑x = ↑y z : ZFSet ⊢ z ∈ x ↔ z ∈ y change (x : Class.{u}) z ↔ (y : Class.{u}) z x y : ZFSet h : ↑x = ↑y z : ZFSet ⊢ ↑x z ↔ ↑y z rw [h] ** Qed
Class.toSet_of_ZFSet A : Class x : ZFSet x✝ : ToSet A ↑x y : ZFSet yx : ↑y = ↑x py : A y ⊢ A x rwa [ofSet.inj yx] at py ** Qed
Class.sUnion_apply x : Class y : ZFSet ⊢ (⋃₀ x) y ↔ ∃ z, x z ∧ y ∈ z constructor case mp x : Class y : ZFSet ⊢ (⋃₀ x) y → ∃ z, x z ∧ y ∈ z rintro ⟨-, ⟨z, rfl, hxz⟩, hyz⟩ case mp.intro.intro.intro.intro x : Class y z : ZFSet hxz : x z hyz : y ∈ ↑z ⊢ ∃ z, x z ∧ y ∈ z exact ⟨z, hxz, hyz⟩ case mpr x : Class y : ZFSet ⊢ (∃ z, x z ∧ y ∈ z) → (⋃₀ x) y exact fun ⟨z, hxz, hyz⟩ => ⟨_, coe_mem.2 hxz, hyz⟩ ** Qed
Class.coe_sUnion x y : ZFSet ⊢ (∃ z, ↑x z ∧ y ∈ z) ↔ ∃ z, z ∈ x ∧ y ∈ z rfl ** Qed
Class.mem_sUnion x y : Class ⊢ y ∈ ⋃₀ x ↔ ∃ z, z ∈ x ∧ y ∈ z constructor case mp x y : Class ⊢ y ∈ ⋃₀ x → ∃ z, z ∈ x ∧ y ∈ z rintro ⟨w, rfl, z, hzx, hwz⟩ case mp.intro.intro.intro.intro x : Class w : ZFSet z : Set ZFSet hzx : z ∈ classToCong x hwz : w ∈ z ⊢ ∃ z, z ∈ x ∧ ↑w ∈ z exact ⟨z, hzx, coe_mem.2 hwz⟩ case mpr x y : Class ⊢ (∃ z, z ∈ x ∧ y ∈ z) → y ∈ ⋃₀ x rintro ⟨w, hwx, z, rfl, hwz⟩ case mpr.intro.intro.intro.intro x w : Class hwx : w ∈ x z : ZFSet hwz : w z ⊢ ↑z ∈ ⋃₀ x exact ⟨z, rfl, w, hwx, hwz⟩ ** Qed
Class.sInter_apply x : Class y : ZFSet ⊢ (⋂₀ x) y ↔ ∀ (z : ZFSet), x z → y ∈ z refine' ⟨fun hxy z hxz => hxy _ ⟨z, rfl, hxz⟩, _⟩ x : Class y : ZFSet ⊢ (∀ (z : ZFSet), x z → y ∈ z) → (⋂₀ x) y rintro H - ⟨z, rfl, hxz⟩ case intro.intro x : Class y : ZFSet H : ∀ (z : ZFSet), x z → y ∈ z z : ZFSet hxz : x z ⊢ y ∈ ↑z exact H _ hxz ** Qed
Class.mem_of_mem_sInter x y z : Class hy : y ∈ ⋂₀ x hz : z ∈ x ⊢ y ∈ z obtain ⟨w, rfl, hw⟩ := hy case intro.intro x z : Class hz : z ∈ x w : ZFSet hw : (⋂₀ x) w ⊢ ↑w ∈ z exact coe_mem.2 (hw z hz) ** Qed
Class.mem_sInter x y : Class h : Set.Nonempty x ⊢ y ∈ ⋂₀ x ↔ ∀ (z : Class), z ∈ x → y ∈ z refine' ⟨fun hy z => mem_of_mem_sInter hy, fun H => _⟩ x y : Class h : Set.Nonempty x H : ∀ (z : Class), z ∈ x → y ∈ z ⊢ y ∈ ⋂₀ x simp_rw [mem_def, sInter_apply] x y : Class h : Set.Nonempty x H : ∀ (z : Class), z ∈ x → y ∈ z ⊢ ∃ x_1, ↑x_1 = y ∧ ∀ (z : ZFSet), x z → x_1 ∈ z obtain ⟨z, hz⟩ := h case intro x y : Class H : ∀ (z : Class), z ∈ x → y ∈ z z : ZFSet hz : z ∈ x ⊢ ∃ x_1, ↑x_1 = y ∧ ∀ (z : ZFSet), x z → x_1 ∈ z obtain ⟨y, rfl, _⟩ := H z (coe_mem.2 hz) case intro.intro.intro x : Class z : ZFSet hz : z ∈ x y : ZFSet right✝ : ↑z y H : ∀ (z : Class), z ∈ x → ↑y ∈ z ⊢ ∃ x_1, ↑x_1 = ↑y ∧ ∀ (z : ZFSet), x z → x_1 ∈ z refine' ⟨y, rfl, fun w hxw => _⟩ case intro.intro.intro x : Class z : ZFSet hz : z ∈ x y : ZFSet right✝ : ↑z y H : ∀ (z : Class), z ∈ x → ↑y ∈ z w : ZFSet hxw : x w ⊢ y ∈ w simpa only [coe_mem, coe_apply] using H w (coe_mem.2 hxw) ** Qed
Class.sUnion_empty ⊢ ⋃₀ ∅ = ∅ ext case a z✝ : ZFSet ⊢ (⋃₀ ∅) z✝ ↔ ∅ z✝ simp ** Qed
Class.sInter_empty ⊢ ⋂₀ ∅ = univ rw [sInter, classToCong_empty, Set.sInter_empty, univ] ** Qed
Class.eq_univ_of_powerset_subset A : Class hA : powerset A ⊆ A ⊢ ∀ (x : ZFSet), A x by_contra' hnA A : Class hA : powerset A ⊆ A hnA : ∃ x, ¬A x ⊢ False exact WellFounded.min_mem ZFSet.mem_wf _ hnA (hA fun x hx => Classical.not_not.1 fun hB => WellFounded.not_lt_min ZFSet.mem_wf _ hnA hB <\| coe_apply.1 hx) ** Qed
Class.iota_val A : Class x : ZFSet H : ∀ (y : ZFSet), A y ↔ y = x y : ZFSet x✝ : iota A y x' : ZFSet h : setOf (fun x => ∀ (y : ZFSet), A y ↔ y = x) x' yx' : y ∈ ↑x' ⊢ ↑x y rwa [← (H x').1 <\| (h x').2 rfl] ** Qed
ZFSet.map_fval f : ZFSet → ZFSet H : PSet.Definable 1 f x y : ZFSet h : y ∈ x z : ZFSet ⊢ Class.ToSet (fun x_1 => ↑(map f x) (pair x_1 z)) ↑y ↔ z = f y rw [Class.toSet_of_ZFSet, Class.coe_apply, mem_map] f : ZFSet → ZFSet H : PSet.Definable 1 f x y : ZFSet h : y ∈ x z : ZFSet ⊢ (∃ z_1, z_1 ∈ x ∧ pair z_1 (f z_1) = pair y z) ↔ z = f y exact ⟨fun ⟨w, _, pr⟩ => by let ⟨wy, fw⟩ := ZFSet.pair_injective pr rw [← fw, wy], fun e => by subst e exact ⟨_, h, rfl⟩⟩ f : ZFSet → ZFSet H : PSet.Definable 1 f x y : ZFSet h : y ∈ x z : ZFSet x✝ : ∃ z_1, z_1 ∈ x ∧ pair z_1 (f z_1) = pair y z w : ZFSet left✝ : w ∈ x pr : pair w (f w) = pair y z ⊢ z = f y let ⟨wy, fw⟩ := ZFSet.pair_injective pr f : ZFSet → ZFSet H : PSet.Definable 1 f x y : ZFSet h : y ∈ x z : ZFSet x✝ : ∃ z_1, z_1 ∈ x ∧ pair z_1 (f z_1) = pair y z w : ZFSet left✝ : w ∈ x pr : pair w (f w) = pair y z wy : w = y fw : f w = z ⊢ z = f y rw [← fw, wy] f : ZFSet → ZFSet H : PSet.Definable 1 f x y : ZFSet h : y ∈ x z : ZFSet e : z = f y ⊢ ∃ z_1, z_1 ∈ x ∧ pair z_1 (f z_1) = pair y z subst e f : ZFSet → ZFSet H : PSet.Definable 1 f x y : ZFSet h : y ∈ x ⊢ ∃ z, z ∈ x ∧ pair z (f z) = pair y (f y) exact ⟨_, h, rfl⟩ ** Qed
ZFSet.choice_mem_aux x : ZFSet h : ¬∅ ∈ x y : ZFSet yx : y ∈ x n : ¬∃ y_1, y_1 ∈ y ⊢ ∅ ∈ x rwa [← (eq_empty y).2 fun z zx => n ⟨z, zx⟩] ** Qed
ZFSet.choice_mem x : ZFSet h : ¬∅ ∈ x y : ZFSet yx : y ∈ x ⊢ ↑(choice x) ′ ↑y ∈ ↑y delta choice x : ZFSet h : ¬∅ ∈ x y : ZFSet yx : y ∈ x ⊢ ↑(map (fun y => Classical.epsilon fun z => z ∈ y) x) ′ ↑y ∈ ↑y rw [@map_fval _ (Classical.allDefinable _) x y yx, Class.coe_mem, Class.coe_apply] x : ZFSet h : ¬∅ ∈ x y : ZFSet yx : y ∈ x ⊢ (Classical.epsilon fun z => z ∈ y) ∈ y exact choice_mem_aux x h y yx ** Qed
SetTheory.PGame.turnBound_ne_zero_of_left_move S : Type u inst✝ : State S s t : S m : t ∈ l s ⊢ turnBound s ≠ 0 intro h S : Type u inst✝ : State S s t : S m : t ∈ l s h : turnBound s = 0 ⊢ False have t := left_bound m S : Type u inst✝ : State S s t✝ : S m : t✝ ∈ l s h : turnBound s = 0 t : turnBound t✝ < turnBound s ⊢ False rw [h] at t S : Type u inst✝ : State S s t✝ : S m : t✝ ∈ l s h : turnBound s = 0 t : turnBound t✝ < 0 ⊢ False exact Nat.not_succ_le_zero _ t ** Qed
SetTheory.PGame.turnBound_ne_zero_of_right_move S : Type u inst✝ : State S s t : S m : t ∈ r s ⊢ turnBound s ≠ 0 intro h S : Type u inst✝ : State S s t : S m : t ∈ r s h : turnBound s = 0 ⊢ False have t := right_bound m S : Type u inst✝ : State S s t✝ : S m : t✝ ∈ r s h : turnBound s = 0 t : turnBound t✝ < turnBound s ⊢ False rw [h] at t S : Type u inst✝ : State S s t✝ : S m : t✝ ∈ r s h : turnBound s = 0 t : turnBound t✝ < 0 ⊢ False exact Nat.not_succ_le_zero _ t ** Qed
SetTheory.PGame.wf_isOption x✝ x : PGame IHl : ∀ (i : LeftMoves x), Acc IsOption (moveLeft x i) IHr : ∀ (j : RightMoves x), Acc IsOption (moveRight x j) y : PGame h : IsOption y x ⊢ Acc IsOption y induction' h with _ i _ j case moveLeft x✝¹ x : PGame IHl✝ : ∀ (i : LeftMoves x), Acc IsOption (moveLeft x i) IHr✝ : ∀ (j : RightMoves x), Acc IsOption (moveRight x j) y x✝ : PGame i : LeftMoves x✝ IHl : ∀ (i : LeftMoves x✝), Acc IsOption (moveLeft x✝ i) IHr : ∀ (j : RightMoves x✝), Acc IsOption (moveRight x✝ j) ⊢ Acc IsOption (moveLeft x✝ i) exact IHl i case moveRight x✝¹ x : PGame IHl✝ : ∀ (i : LeftMoves x), Acc IsOption (moveLeft x i) IHr✝ : ∀ (j : RightMoves x), Acc IsOption (moveRight x j) y x✝ : PGame j : RightMoves x✝ IHl : ∀ (i : LeftMoves x✝), Acc IsOption (moveLeft x✝ i) IHr : ∀ (j : RightMoves x✝), Acc IsOption (moveRight x✝ j) ⊢ Acc IsOption (moveRight x✝ j) exact IHr j ** Qed
SetTheory.PGame.Subsequent.mk_right' xl xr : Type u_1 xL : xl → PGame xR : xr → PGame j : RightMoves (mk xl xr xL xR) ⊢ Subsequent (xR j) (mk xl xr xL xR) pgame_wf_tac ** Qed
SetTheory.PGame.Subsequent.moveRight_mk_left xl : Type u_1 i : xl xr : Type u_1 xR : xr → PGame xL : xl → PGame j : RightMoves (xL i) ⊢ Subsequent (PGame.moveRight (xL i) j) (mk xl xr xL xR) pgame_wf_tac ** Qed
SetTheory.PGame.Subsequent.moveRight_mk_right xr : Type u_1 i : xr xl : Type u_1 xL : xl → PGame xR : xr → PGame j : RightMoves (xR i) ⊢ Subsequent (PGame.moveRight (xR i) j) (mk xl xr xL xR) pgame_wf_tac ** Qed
SetTheory.PGame.Subsequent.moveLeft_mk_left xl : Type u_1 i : xl xr : Type u_1 xR : xr → PGame xL : xl → PGame j : LeftMoves (xL i) ⊢ Subsequent (PGame.moveLeft (xL i) j) (mk xl xr xL xR) pgame_wf_tac ** Qed
SetTheory.PGame.Subsequent.moveLeft_mk_right xr : Type u_1 i : xr xl : Type u_1 xL : xl → PGame xR : xr → PGame j : LeftMoves (xR i) ⊢ Subsequent (PGame.moveLeft (xR i) j) (mk xl xr xL xR) pgame_wf_tac ** Qed
SetTheory.PGame.le_iff_forall_lf x y : PGame ⊢ x ≤ y ↔ (∀ (i : LeftMoves x), moveLeft x i ⧏ y) ∧ ∀ (j : RightMoves y), x ⧏ moveRight y j unfold LE.le le x y : PGame ⊢ { le := Sym2.GameAdd.fix wf_isOption fun x y le => (∀ (i : LeftMoves x), ¬le y (moveLeft x i) (_ : Sym2.GameAdd IsOption (Quotient.mk (Sym2.Rel.setoid PGame) (y, moveLeft x i)) (Quotient.mk (Sym2.Rel.setoid PGame) (x, y)))) ∧ ∀ (j : RightMoves y), ¬le (moveRight y j) x (_ : Sym2.GameAdd IsOption (Quotient.mk (Sym2.Rel.setoid PGame) (moveRight y j, x)) (Quotient.mk (Sym2.Rel.setoid PGame) (x, y))) }.1 x y ↔ (∀ (i : LeftMoves x), moveLeft x i ⧏ y) ∧ ∀ (j : RightMoves y), x ⧏ moveRight y j simp only x y : PGame ⊢ Sym2.GameAdd.fix wf_isOption (fun x y le => (∀ (i : LeftMoves x), ¬le y (moveLeft x i) (_ : Sym2.GameAdd IsOption (Quotient.mk (Sym2.Rel.setoid PGame) (y, moveLeft x i)) (Quotient.mk (Sym2.Rel.setoid PGame) (x, y)))) ∧ ∀ (j : RightMoves y), ¬le (moveRight y j) x (_ : Sym2.GameAdd IsOption (Quotient.mk (Sym2.Rel.setoid PGame) (moveRight y j, x)) (Quotient.mk (Sym2.Rel.setoid PGame) (x, y)))) x y ↔ (∀ (i : LeftMoves x), moveLeft x i ⧏ y) ∧ ∀ (j : RightMoves y), x ⧏ moveRight y j rw [Sym2.GameAdd.fix_eq] x y : PGame ⊢ ((∀ (i : LeftMoves x), ¬(fun a' b' x => Sym2.GameAdd.fix wf_isOption (fun x y le => (∀ (i : LeftMoves x), ¬le y (moveLeft x i) (_ : Sym2.GameAdd IsOption (Quotient.mk (Sym2.Rel.setoid PGame) (y, moveLeft x i)) (Quotient.mk (Sym2.Rel.setoid PGame) (x, y)))) ∧ ∀ (j : RightMoves y), ¬le (moveRight y j) x (_ : Sym2.GameAdd IsOption (Quotient.mk (Sym2.Rel.setoid PGame) (moveRight y j, x)) (Quotient.mk (Sym2.Rel.setoid PGame) (x, y)))) a' b') y (moveLeft x i) (_ : Sym2.GameAdd IsOption (Quotient.mk (Sym2.Rel.setoid PGame) (y, moveLeft x i)) (Quotient.mk (Sym2.Rel.setoid PGame) (x, y)))) ∧ ∀ (j : RightMoves y), ¬(fun a' b' x => Sym2.GameAdd.fix wf_isOption (fun x y le => (∀ (i : LeftMoves x), ¬le y (moveLeft x i) (_ : Sym2.GameAdd IsOption (Quotient.mk (Sym2.Rel.setoid PGame) (y, moveLeft x i)) (Quotient.mk (Sym2.Rel.setoid PGame) (x, y)))) ∧ ∀ (j : RightMoves y), ¬le (moveRight y j) x (_ : Sym2.GameAdd IsOption (Quotient.mk (Sym2.Rel.setoid PGame) (moveRight y j, x)) (Quotient.mk (Sym2.Rel.setoid PGame) (x, y)))) a' b') (moveRight y j) x (_ : Sym2.GameAdd IsOption (Quotient.mk (Sym2.Rel.setoid PGame) (moveRight y j, x)) (Quotient.mk (Sym2.Rel.setoid PGame) (x, y)))) ↔ (∀ (i : LeftMoves x), moveLeft x i ⧏ y) ∧ ∀ (j : RightMoves y), x ⧏ moveRight y j rfl ** Qed
SetTheory.PGame.lf_iff_exists_le x y : PGame ⊢ x ⧏ y ↔ (∃ i, x ≤ moveLeft y i) ∨ ∃ j, moveRight x j ≤ y rw [LF, le_iff_forall_lf, not_and_or] x y : PGame ⊢ ((¬∀ (i : LeftMoves y), moveLeft y i ⧏ x) ∨ ¬∀ (j : RightMoves x), y ⧏ moveRight x j) ↔ (∃ i, x ≤ moveLeft y i) ∨ ∃ j, moveRight x j ≤ y simp ** Qed
SetTheory.PGame.le_or_gf x y : PGame ⊢ x ≤ y ∨ y ⧏ x rw [← PGame.not_le] x y : PGame ⊢ x ≤ y ∨ ¬x ≤ y apply em ** Qed
SetTheory.PGame.lf_of_le_of_lf x y z : PGame h₁ : x ≤ y h₂ : y ⧏ z ⊢ x ⧏ z rw [← PGame.not_le] at h₂ ⊢ x y z : PGame h₁ : x ≤ y h₂ : ¬z ≤ y ⊢ ¬z ≤ x exact fun h₃ => h₂ (h₃.trans h₁) ** Qed
SetTheory.PGame.lf_of_lf_of_le x y z : PGame h₁ : x ⧏ y h₂ : y ≤ z ⊢ x ⧏ z rw [← PGame.not_le] at h₁ ⊢ x y z : PGame h₁ : ¬y ≤ x h₂ : y ≤ z ⊢ ¬z ≤ x exact fun h₃ => h₁ (h₂.trans h₃) ** Qed
SetTheory.PGame.le_def x y : PGame ⊢ x ≤ y ↔ (∀ (i : LeftMoves x), (∃ i', moveLeft x i ≤ moveLeft y i') ∨ ∃ j, moveRight (moveLeft x i) j ≤ y) ∧ ∀ (j : RightMoves y), (∃ i, x ≤ moveLeft (moveRight y j) i) ∨ ∃ j', moveRight x j' ≤ moveRight y j rw [le_iff_forall_lf] x y : PGame ⊢ ((∀ (i : LeftMoves x), moveLeft x i ⧏ y) ∧ ∀ (j : RightMoves y), x ⧏ moveRight y j) ↔ (∀ (i : LeftMoves x), (∃ i', moveLeft x i ≤ moveLeft y i') ∨ ∃ j, moveRight (moveLeft x i) j ≤ y) ∧ ∀ (j : RightMoves y), (∃ i, x ≤ moveLeft (moveRight y j) i) ∨ ∃ j', moveRight x j' ≤ moveRight y j conv => lhs simp only [lf_iff_exists_le] ** Qed
SetTheory.PGame.lf_def x y : PGame ⊢ x ⧏ y ↔ (∃ i, (∀ (i' : LeftMoves x), moveLeft x i' ⧏ moveLeft y i) ∧ ∀ (j : RightMoves (moveLeft y i)), x ⧏ moveRight (moveLeft y i) j) ∨ ∃ j, (∀ (i : LeftMoves (moveRight x j)), moveLeft (moveRight x j) i ⧏ y) ∧ ∀ (j' : RightMoves y), moveRight x j ⧏ moveRight y j' rw [lf_iff_exists_le] x y : PGame ⊢ ((∃ i, x ≤ moveLeft y i) ∨ ∃ j, moveRight x j ≤ y) ↔ (∃ i, (∀ (i' : LeftMoves x), moveLeft x i' ⧏ moveLeft y i) ∧ ∀ (j : RightMoves (moveLeft y i)), x ⧏ moveRight (moveLeft y i) j) ∨ ∃ j, (∀ (i : LeftMoves (moveRight x j)), moveLeft (moveRight x j) i ⧏ y) ∧ ∀ (j' : RightMoves y), moveRight x j ⧏ moveRight y j' conv => lhs simp only [le_iff_forall_lf] ** Qed
SetTheory.PGame.zero_le_lf x : PGame ⊢ 0 ≤ x ↔ ∀ (j : RightMoves x), 0 ⧏ moveRight x j rw [le_iff_forall_lf] x : PGame ⊢ ((∀ (i : LeftMoves 0), moveLeft 0 i ⧏ x) ∧ ∀ (j : RightMoves x), 0 ⧏ moveRight x j) ↔ ∀ (j : RightMoves x), 0 ⧏ moveRight x j simp ** Qed
SetTheory.PGame.le_zero_lf x : PGame ⊢ x ≤ 0 ↔ ∀ (i : LeftMoves x), moveLeft x i ⧏ 0 rw [le_iff_forall_lf] x : PGame ⊢ ((∀ (i : LeftMoves x), moveLeft x i ⧏ 0) ∧ ∀ (j : RightMoves 0), x ⧏ moveRight 0 j) ↔ ∀ (i : LeftMoves x), moveLeft x i ⧏ 0 simp ** Qed
SetTheory.PGame.zero_lf_le x : PGame ⊢ 0 ⧏ x ↔ ∃ i, 0 ≤ moveLeft x i rw [lf_iff_exists_le] x : PGame ⊢ ((∃ i, 0 ≤ moveLeft x i) ∨ ∃ j, moveRight 0 j ≤ x) ↔ ∃ i, 0 ≤ moveLeft x i simp ** Qed
SetTheory.PGame.lf_zero_le x : PGame ⊢ x ⧏ 0 ↔ ∃ j, moveRight x j ≤ 0 rw [lf_iff_exists_le] x : PGame ⊢ ((∃ i, x ≤ moveLeft 0 i) ∨ ∃ j, moveRight x j ≤ 0) ↔ ∃ j, moveRight x j ≤ 0 simp ** Qed
SetTheory.PGame.zero_le x : PGame ⊢ 0 ≤ x ↔ ∀ (j : RightMoves x), ∃ i, 0 ≤ moveLeft (moveRight x j) i rw [le_def] x : PGame ⊢ ((∀ (i : LeftMoves 0), (∃ i', moveLeft 0 i ≤ moveLeft x i') ∨ ∃ j, moveRight (moveLeft 0 i) j ≤ x) ∧ ∀ (j : RightMoves x), (∃ i, 0 ≤ moveLeft (moveRight x j) i) ∨ ∃ j', moveRight 0 j' ≤ moveRight x j) ↔ ∀ (j : RightMoves x), ∃ i, 0 ≤ moveLeft (moveRight x j) i simp ** Qed
SetTheory.PGame.le_zero x : PGame ⊢ x ≤ 0 ↔ ∀ (i : LeftMoves x), ∃ j, moveRight (moveLeft x i) j ≤ 0 rw [le_def] x : PGame ⊢ ((∀ (i : LeftMoves x), (∃ i', moveLeft x i ≤ moveLeft 0 i') ∨ ∃ j, moveRight (moveLeft x i) j ≤ 0) ∧ ∀ (j : RightMoves 0), (∃ i, x ≤ moveLeft (moveRight 0 j) i) ∨ ∃ j', moveRight x j' ≤ moveRight 0 j) ↔ ∀ (i : LeftMoves x), ∃ j, moveRight (moveLeft x i) j ≤ 0 simp ** Qed
SetTheory.PGame.zero_lf x : PGame ⊢ 0 ⧏ x ↔ ∃ i, ∀ (j : RightMoves (moveLeft x i)), 0 ⧏ moveRight (moveLeft x i) j rw [lf_def] x : PGame ⊢ ((∃ i, (∀ (i' : LeftMoves 0), moveLeft 0 i' ⧏ moveLeft x i) ∧ ∀ (j : RightMoves (moveLeft x i)), 0 ⧏ moveRight (moveLeft x i) j) ∨ ∃ j, (∀ (i : LeftMoves (moveRight 0 j)), moveLeft (moveRight 0 j) i ⧏ x) ∧ ∀ (j' : RightMoves x), moveRight 0 j ⧏ moveRight x j') ↔ ∃ i, ∀ (j : RightMoves (moveLeft x i)), 0 ⧏ moveRight (moveLeft x i) j simp ** Qed
SetTheory.PGame.lf_zero x : PGame ⊢ x ⧏ 0 ↔ ∃ j, ∀ (i : LeftMoves (moveRight x j)), moveLeft (moveRight x j) i ⧏ 0 rw [lf_def] x : PGame ⊢ ((∃ i, (∀ (i' : LeftMoves x), moveLeft x i' ⧏ moveLeft 0 i) ∧ ∀ (j : RightMoves (moveLeft 0 i)), x ⧏ moveRight (moveLeft 0 i) j) ∨ ∃ j, (∀ (i : LeftMoves (moveRight x j)), moveLeft (moveRight x j) i ⧏ 0) ∧ ∀ (j' : RightMoves 0), moveRight x j ⧏ moveRight 0 j') ↔ ∃ j, ∀ (i : LeftMoves (moveRight x j)), moveLeft (moveRight x j) i ⧏ 0 simp ** Qed
SetTheory.PGame.equiv_of_eq x y : PGame h : x = y ⊢ x ≈ y subst h x : PGame ⊢ x ≈ x rfl ** Qed
SetTheory.PGame.lf_or_equiv_or_gf x y : PGame ⊢ x ⧏ y ∨ x ≈ y ∨ y ⧏ x by_cases h : x ⧏ y case pos x y : PGame h : x ⧏ y ⊢ x ⧏ y ∨ x ≈ y ∨ y ⧏ x exact Or.inl h case neg x y : PGame h : ¬x ⧏ y ⊢ x ⧏ y ∨ x ≈ y ∨ y ⧏ x right case neg.h x y : PGame h : ¬x ⧏ y ⊢ x ≈ y ∨ y ⧏ x cases' lt_or_equiv_of_le (PGame.not_lf.1 h) with h' h' case neg.h.inl x y : PGame h : ¬x ⧏ y h' : y < x ⊢ x ≈ y ∨ y ⧏ x exact Or.inr h'.lf case neg.h.inr x y : PGame h : ¬x ⧏ y h' : y ≈ x ⊢ x ≈ y ∨ y ⧏ x exact Or.inl (Equiv.symm h') ** Qed
SetTheory.PGame.equiv_of_mk_equiv x y : PGame L : LeftMoves x ≃ LeftMoves y R : RightMoves x ≃ RightMoves y hl : ∀ (i : LeftMoves x), moveLeft x i ≈ moveLeft y (↑L i) hr : ∀ (j : RightMoves x), moveRight x j ≈ moveRight y (↑R j) ⊢ x ≈ y constructor <;> rw [le_def] case left x y : PGame L : LeftMoves x ≃ LeftMoves y R : RightMoves x ≃ RightMoves y hl : ∀ (i : LeftMoves x), moveLeft x i ≈ moveLeft y (↑L i) hr : ∀ (j : RightMoves x), moveRight x j ≈ moveRight y (↑R j) ⊢ (∀ (i : LeftMoves x), (∃ i', moveLeft x i ≤ moveLeft y i') ∨ ∃ j, moveRight (moveLeft x i) j ≤ y) ∧ ∀ (j : RightMoves y), (∃ i, x ≤ moveLeft (moveRight y j) i) ∨ ∃ j', moveRight x j' ≤ moveRight y j exact ⟨fun i => Or.inl ⟨_, (hl i).1⟩, fun j => Or.inr ⟨_, by simpa using (hr (R.symm j)).1⟩⟩ x y : PGame L : LeftMoves x ≃ LeftMoves y R : RightMoves x ≃ RightMoves y hl : ∀ (i : LeftMoves x), moveLeft x i ≈ moveLeft y (↑L i) hr : ∀ (j : RightMoves x), moveRight x j ≈ moveRight y (↑R j) j : RightMoves y ⊢ moveRight x (?m.65566 j) ≤ moveRight y j simpa using (hr (R.symm j)).1 case right x y : PGame L : LeftMoves x ≃ LeftMoves y R : RightMoves x ≃ RightMoves y hl : ∀ (i : LeftMoves x), moveLeft x i ≈ moveLeft y (↑L i) hr : ∀ (j : RightMoves x), moveRight x j ≈ moveRight y (↑R j) ⊢ (∀ (i : LeftMoves y), (∃ i', moveLeft y i ≤ moveLeft x i') ∨ ∃ j, moveRight (moveLeft y i) j ≤ x) ∧ ∀ (j : RightMoves x), (∃ i, y ≤ moveLeft (moveRight x j) i) ∨ ∃ j', moveRight y j' ≤ moveRight x j exact ⟨fun i => Or.inl ⟨_, by simpa using (hl (L.symm i)).2⟩, fun j => Or.inr ⟨_, (hr j).2⟩⟩ x y : PGame L : LeftMoves x ≃ LeftMoves y R : RightMoves x ≃ RightMoves y hl : ∀ (i : LeftMoves x), moveLeft x i ≈ moveLeft y (↑L i) hr : ∀ (j : RightMoves x), moveRight x j ≈ moveRight y (↑R j) i : LeftMoves y ⊢ moveLeft y i ≤ moveLeft x (?m.66250 i) simpa using (hl (L.symm i)).2 ** Qed
SetTheory.PGame.lf_iff_lt_or_fuzzy x y : PGame ⊢ x ⧏ y ↔ x < y ∨ x ‖ y simp only [lt_iff_le_and_lf, Fuzzy, ← PGame.not_le] x y : PGame ⊢ ¬y ≤ x ↔ x ≤ y ∧ ¬y ≤ x ∨ ¬y ≤ x ∧ ¬x ≤ y tauto ** Qed
SetTheory.PGame.fuzzy_congr x₁ y₁ x₂ y₂ : PGame hx : x₁ ≈ x₂ hy : y₁ ≈ y₂ ⊢ x₁ ⧏ y₁ ∧ y₁ ⧏ x₁ ↔ x₂ ⧏ y₂ ∧ y₂ ⧏ x₂ rw [lf_congr hx hy, lf_congr hy hx] ** Qed
SetTheory.PGame.lt_or_equiv_or_gt_or_fuzzy x y : PGame ⊢ x < y ∨ x ≈ y ∨ y < x ∨ x ‖ y cases' le_or_gf x y with h₁ h₁ <;> cases' le_or_gf y x with h₂ h₂ case inl.inl x y : PGame h₁ : x ≤ y h₂ : y ≤ x ⊢ x < y ∨ x ≈ y ∨ y < x ∨ x ‖ y right case inl.inl.h x y : PGame h₁ : x ≤ y h₂ : y ≤ x ⊢ x ≈ y ∨ y < x ∨ x ‖ y left case inl.inl.h.h x y : PGame h₁ : x ≤ y h₂ : y ≤ x ⊢ x ≈ y exact ⟨h₁, h₂⟩ case inl.inr x y : PGame h₁ : x ≤ y h₂ : x ⧏ y ⊢ x < y ∨ x ≈ y ∨ y < x ∨ x ‖ y left case inl.inr.h x y : PGame h₁ : x ≤ y h₂ : x ⧏ y ⊢ x < y exact ⟨h₁, h₂⟩ case inr.inl x y : PGame h₁ : y ⧏ x h₂ : y ≤ x ⊢ x < y ∨ x ≈ y ∨ y < x ∨ x ‖ y right case inr.inl.h x y : PGame h₁ : y ⧏ x h₂ : y ≤ x ⊢ x ≈ y ∨ y < x ∨ x ‖ y right case inr.inl.h.h x y : PGame h₁ : y ⧏ x h₂ : y ≤ x ⊢ y < x ∨ x ‖ y left case inr.inl.h.h.h x y : PGame h₁ : y ⧏ x h₂ : y ≤ x ⊢ y < x exact ⟨h₂, h₁⟩ case inr.inr x y : PGame h₁ : y ⧏ x h₂ : x ⧏ y ⊢ x < y ∨ x ≈ y ∨ y < x ∨ x ‖ y right case inr.inr.h x y : PGame h₁ : y ⧏ x h₂ : x ⧏ y ⊢ x ≈ y ∨ y < x ∨ x ‖ y right case inr.inr.h.h x y : PGame h₁ : y ⧏ x h₂ : x ⧏ y ⊢ y < x ∨ x ‖ y right case inr.inr.h.h.h x y : PGame h₁ : y ⧏ x h₂ : x ⧏ y ⊢ x ‖ y exact ⟨h₂, h₁⟩ ** Qed
SetTheory.PGame.lt_or_equiv_or_gf x y : PGame ⊢ x < y ∨ x ≈ y ∨ y ⧏ x rw [lf_iff_lt_or_fuzzy, Fuzzy.swap_iff] x y : PGame ⊢ x < y ∨ x ≈ y ∨ y < x ∨ x ‖ y exact lt_or_equiv_or_gt_or_fuzzy x y ** Qed
SetTheory.PGame.relabel_moveLeft x : PGame xl' xr' : Type u_1 el : xl' ≃ LeftMoves x er : xr' ≃ RightMoves x i : LeftMoves x ⊢ moveLeft (relabel el er) (↑el.symm i) = moveLeft x i simp ** Qed
SetTheory.PGame.relabel_moveRight x : PGame xl' xr' : Type u_1 el : xl' ≃ LeftMoves x er : xr' ≃ RightMoves x j : RightMoves x ⊢ moveRight (relabel el er) (↑er.symm j) = moveRight x j simp ** Qed
SetTheory.PGame.neg_ofLists L R : List PGame ⊢ -ofLists L R = ofLists (List.map (fun x => -x) R) (List.map (fun x => -x) L) simp only [ofLists, neg_def, List.length_map, List.nthLe_map', eq_self_iff_true, true_and, mk.injEq] L R : List PGame ⊢ (HEq (fun j => -List.nthLe R ↑j.down (_ : ↑j.down < List.length R)) fun i => -List.nthLe R ↑i.down (_ : ↑i.down < List.length R)) ∧ HEq (fun i => -List.nthLe L ↑i.down (_ : ↑i.down < List.length L)) fun j => -List.nthLe L ↑j.down (_ : ↑j.down < List.length L) constructor case right L R : List PGame ⊢ HEq (fun i => -List.nthLe L ↑i.down (_ : ↑i.down < List.length L)) fun j => -List.nthLe L ↑j.down (_ : ↑j.down < List.length L) apply hfunext case right.hα L R : List PGame ⊢ ULift.{u_1, 0} (Fin (List.length L)) = ULift.{u_1, 0} (Fin (List.length (List.map (fun x => -x) L))) simp case right.h L R : List PGame ⊢ ∀ (a : ULift.{u_1, 0} (Fin (List.length L))) (a' : ULift.{u_1, 0} (Fin (List.length (List.map (fun x => -x) L)))), HEq a a' → HEq (-List.nthLe L ↑a.down (_ : ↑a.down < List.length L)) (-List.nthLe L ↑a'.down (_ : ↑a'.down < List.length L)) intro a a' ha case right.h L R : List PGame a : ULift.{u_1, 0} (Fin (List.length L)) a' : ULift.{u_1, 0} (Fin (List.length (List.map (fun x => -x) L))) ha : HEq a a' ⊢ HEq (-List.nthLe L ↑a.down (_ : ↑a.down < List.length L)) (-List.nthLe L ↑a'.down (_ : ↑a'.down < List.length L)) congr 2 case right.h.h.e_a.e_n L R : List PGame a : ULift.{u_1, 0} (Fin (List.length L)) a' : ULift.{u_1, 0} (Fin (List.length (List.map (fun x => -x) L))) ha : HEq a a' ⊢ ↑a.down = ↑a'.down have : ∀ {m n} (_ : m = n) {b : ULift (Fin m)} {c : ULift (Fin n)} (_ : HEq b c), (b.down : ℕ) = ↑c.down := by rintro m n rfl b c simp only [heq_eq_eq] rintro rfl rfl case right.h.h.e_a.e_n L R : List PGame a : ULift.{u_1, 0} (Fin (List.length L)) a' : ULift.{u_1, 0} (Fin (List.length (List.map (fun x => -x) L))) ha : HEq a a' this : ∀ {m n : ℕ}, m = n → ∀ {b : ULift.{?u.106967, 0} (Fin m)} {c : ULift.{?u.106967, 0} (Fin n)}, HEq b c → ↑b.down = ↑c.down ⊢ ↑a.down = ↑a'.down exact this (List.length_map _ _).symm ha L R : List PGame a : ULift.{u_1, 0} (Fin (List.length L)) a' : ULift.{u_1, 0} (Fin (List.length (List.map (fun x => -x) L))) ha : HEq a a' ⊢ ∀ {m n : ℕ}, m = n → ∀ {b : ULift.{?u.106967, 0} (Fin m)} {c : ULift.{?u.106967, 0} (Fin n)}, HEq b c → ↑b.down = ↑c.down rintro m n rfl b c L R : List PGame a : ULift.{u_1, 0} (Fin (List.length L)) a' : ULift.{u_1, 0} (Fin (List.length (List.map (fun x => -x) L))) ha : HEq a a' m : ℕ b c : ULift.{?u.106967, 0} (Fin m) ⊢ HEq b c → ↑b.down = ↑c.down simp only [heq_eq_eq] L R : List PGame a : ULift.{u_1, 0} (Fin (List.length L)) a' : ULift.{u_1, 0} (Fin (List.length (List.map (fun x => -x) L))) ha : HEq a a' m : ℕ b c : ULift.{?u.106967, 0} (Fin m) ⊢ b = c → ↑b.down = ↑c.down rintro rfl L R : List PGame a : ULift.{u_1, 0} (Fin (List.length L)) a' : ULift.{u_1, 0} (Fin (List.length (List.map (fun x => -x) L))) ha : HEq a a' m : ℕ b : ULift.{?u.106967, 0} (Fin m) ⊢ ↑b.down = ↑b.down rfl ** Qed
SetTheory.PGame.isOption_neg x y : PGame ⊢ IsOption x (-y) ↔ IsOption (-x) y rw [IsOption_iff, IsOption_iff, or_comm] x y : PGame ⊢ ((∃ i, x = moveRight (-y) i) ∨ ∃ i, x = moveLeft (-y) i) ↔ (∃ i, -x = moveLeft y i) ∨ ∃ i, -x = moveRight y i cases y case mk.h₂ x : PGame α✝ β✝ : Type u_1 a✝¹ : α✝ → PGame a✝ : β✝ → PGame ⊢ (∃ i, x = moveLeft (-mk α✝ β✝ a✝¹ a✝) i) ↔ ∃ i, -x = moveRight (mk α✝ β✝ a✝¹ a✝) i apply exists_congr case mk.h₂.h x : PGame α✝ β✝ : Type u_1 a✝¹ : α✝ → PGame a✝ : β✝ → PGame ⊢ ∀ (a : LeftMoves (-mk α✝ β✝ a✝¹ a✝)), x = moveLeft (-mk α✝ β✝ a✝¹ a✝) a ↔ -x = moveRight (mk α✝ β✝ a✝¹ a✝) a intro case mk.h₂.h x : PGame α✝ β✝ : Type u_1 a✝² : α✝ → PGame a✝¹ : β✝ → PGame a✝ : LeftMoves (-mk α✝ β✝ a✝² a✝¹) ⊢ x = moveLeft (-mk α✝ β✝ a✝² a✝¹) a✝ ↔ -x = moveRight (mk α✝ β✝ a✝² a✝¹) a✝ rw [neg_eq_iff_eq_neg] case mk.h₂.h x : PGame α✝ β✝ : Type u_1 a✝² : α✝ → PGame a✝¹ : β✝ → PGame a✝ : LeftMoves (-mk α✝ β✝ a✝² a✝¹) ⊢ x = moveLeft (-mk α✝ β✝ a✝² a✝¹) a✝ ↔ x = -moveRight (mk α✝ β✝ a✝² a✝¹) a✝ rfl ** Qed
SetTheory.PGame.isOption_neg_neg x y : PGame ⊢ IsOption (-x) (-y) ↔ IsOption x y rw [isOption_neg, neg_neg] ** Qed

Subsets and Splits

formal stringlengths 41 427k	informal stringclasses 1 value
PSet.equiv_of_isEmpty x : PSet y : PSet inst✝¹ : IsEmpty (Type x) inst✝ : IsEmpty (Type y) ⊢ (∀ (i : Type x), ∃ j, Equiv (Func x i) (Func y j)) ∧ ∀ (j : Type y), ∃ i, Equiv (Func x i) (Func y j) simp ** Qed
PSet.func_mem x : PSet i : Type x ⊢ Func x i ∈ x cases x case mk α✝ : Type u_1 A✝ : α✝ → PSet i : Type (mk α✝ A✝) ⊢ Func (mk α✝ A✝) i ∈ mk α✝ A✝ apply Mem.mk ** Qed
PSet.mem_wf_aux α : Type u A : α → PSet β : Type u B : β → PSet H : Equiv (mk α A) (mk β B) ⊢ ∀ (y : PSet), y ∈ mk β B → Acc (fun x x_1 => x ∈ x_1) y rintro ⟨γ, C⟩ ⟨b, hc⟩ case mk.intro α : Type u A : α → PSet β : Type u B : β → PSet H : Equiv (mk α A) (mk β B) γ : Type u C : γ → PSet b : Type (mk β B) hc : Equiv (mk γ C) (Func (mk β B) b) ⊢ Acc (fun x x_1 => x ∈ x_1) (mk γ C) cases' H.exists_right b with a ha case mk.intro.intro α : Type u A : α → PSet β : Type u B : β → PSet H : Equiv (mk α A) (mk β B) γ : Type u C : γ → PSet b : Type (mk β B) hc : Equiv (mk γ C) (Func (mk β B) b) a : Type (mk α A) ha : Equiv (Func (mk α A) a) (Func (mk β B) b) ⊢ Acc (fun x x_1 => x ∈ x_1) (mk γ C) have H := ha.trans hc.symm case mk.intro.intro α : Type u A : α → PSet β : Type u B : β → PSet H✝ : Equiv (mk α A) (mk β B) γ : Type u C : γ → PSet b : Type (mk β B) hc : Equiv (mk γ C) (Func (mk β B) b) a : Type (mk α A) ha : Equiv (Func (mk α A) a) (Func (mk β B) b) H : Equiv (Func (mk α A) a) (mk γ C) ⊢ Acc (fun x x_1 => x ∈ x_1) (mk γ C) rw [mk_func] at H case mk.intro.intro α : Type u A : α → PSet β : Type u B : β → PSet H✝ : Equiv (mk α A) (mk β B) γ : Type u C : γ → PSet b : Type (mk β B) hc : Equiv (mk γ C) (Func (mk β B) b) a : Type (mk α A) ha : Equiv (Func (mk α A) a) (Func (mk β B) b) H : Equiv (A a) (mk γ C) ⊢ Acc (fun x x_1 => x ∈ x_1) (mk γ C) exact mem_wf_aux H ** Qed
PSet.toSet_empty ⊢ toSet ∅ = ∅ simp [toSet] ** Qed
PSet.not_nonempty_empty ⊢ ¬PSet.Nonempty ∅ simp [PSet.Nonempty] ** Qed
PSet.mem_sUnion α : Type u A : α → PSet y : PSet x✝ : y ∈ ⋃₀ mk α A a : Type (mk α A) c : Type (Func (mk α A) a) e : Equiv y (Func (A a) c) this : Func (A a) c ∈ mk (Type (A a)) (Func (A a)) ⊢ Func (A a) c ∈ A (?m.24436 α A y x✝ a c e this) rwa [eta] at this α : Type u A : α → PSet y : PSet x✝ : ∃ z, z ∈ mk α A ∧ y ∈ z β : Type u B : β → PSet a : Type (mk α A) e : Equiv (mk β B) (A a) b : Type (mk β B) yb : Equiv y (Func (mk β B) b) ⊢ y ∈ ⋃₀ mk α A rw [← eta (A a)] at e α : Type u A : α → PSet y : PSet x✝ : ∃ z, z ∈ mk α A ∧ y ∈ z β : Type u B : β → PSet a : Type (mk α A) e : Equiv (mk β B) (mk (Type (A a)) (Func (A a))) b : Type (mk β B) yb : Equiv y (Func (mk β B) b) ⊢ y ∈ ⋃₀ mk α A exact let ⟨βt, _⟩ := e let ⟨c, bc⟩ := βt b ⟨⟨a, c⟩, yb.trans bc⟩ ** Qed
PSet.toSet_sUnion x : PSet ⊢ toSet (⋃₀ x) = ⋃₀ (toSet '' toSet x) ext case h x x✝ : PSet ⊢ x✝ ∈ toSet (⋃₀ x) ↔ x✝ ∈ ⋃₀ (toSet '' toSet x) simp ** Qed
ZFSet.toSet_subset_iff x y : ZFSet ⊢ toSet x ⊆ toSet y ↔ x ⊆ y simp [subset_def, Set.subset_def] ** Qed
ZFSet.ext_iff x y : ZFSet h : x = y ⊢ ∀ (z : ZFSet), z ∈ x ↔ z ∈ y simp [h] ** Qed
ZFSet.toSet_empty ⊢ toSet ∅ = ∅ simp [toSet] ** Qed
ZFSet.not_nonempty_empty ⊢ ¬ZFSet.Nonempty ∅ simp [ZFSet.Nonempty] ** Qed
ZFSet.nonempty_mk_iff x : PSet ⊢ ZFSet.Nonempty (mk x) ↔ PSet.Nonempty x refine' ⟨_, fun ⟨a, h⟩ => ⟨mk a, h⟩⟩ x : PSet ⊢ ZFSet.Nonempty (mk x) → PSet.Nonempty x rintro ⟨a, h⟩ case intro x : PSet a : ZFSet h : a ∈ toSet (mk x) ⊢ PSet.Nonempty x induction a using Quotient.inductionOn case intro.h x a✝ : PSet h : Quotient.mk setoid a✝ ∈ toSet (mk x) ⊢ PSet.Nonempty x exact ⟨_, h⟩ ** Qed
ZFSet.eq_empty x : ZFSet ⊢ x = ∅ ↔ ∀ (y : ZFSet), ¬y ∈ x rw [ext_iff] x : ZFSet ⊢ (∀ (z : ZFSet), z ∈ x ↔ z ∈ ∅) ↔ ∀ (y : ZFSet), ¬y ∈ x simp ** Qed
ZFSet.eq_empty_or_nonempty u : ZFSet ⊢ u = ∅ ∨ ZFSet.Nonempty u rw [eq_empty, ← not_exists] u : ZFSet ⊢ (¬∃ x, x ∈ u) ∨ ZFSet.Nonempty u apply em' ** Qed
ZFSet.toSet_insert x y : ZFSet ⊢ toSet (insert x y) = insert x (toSet y) ext case h x y x✝ : ZFSet ⊢ x✝ ∈ toSet (insert x y) ↔ x✝ ∈ insert x (toSet y) simp ** Qed
ZFSet.toSet_singleton x : ZFSet ⊢ toSet {x} = {x} ext case h x x✝ : ZFSet ⊢ x✝ ∈ toSet {x} ↔ x✝ ∈ {x} simp ** Qed
ZFSet.mem_pair x y z : ZFSet ⊢ x ∈ {y, z} ↔ x = y ∨ x = z simp ** Qed
ZFSet.omega_succ n✝ : ZFSet x : PSet x✝ : Quotient.mk setoid x ∈ omega n : ℕ h : PSet.Equiv x (Func PSet.omega { down := n }) ⊢ insert (mk x) (mk x) = insert (mk (ofNat n)) (mk (ofNat n)) rw [ZFSet.sound h] n✝ : ZFSet x : PSet x✝ : Quotient.mk setoid x ∈ omega n : ℕ h : PSet.Equiv x (Func PSet.omega { down := n }) ⊢ insert (mk (Func PSet.omega { down := n })) (mk (Func PSet.omega { down := n })) = insert (mk (ofNat n)) (mk (ofNat n)) rfl ** Qed
ZFSet.mem_sep p : ZFSet → Prop x y✝ : ZFSet x✝¹ y : PSet α : Type u A : α → PSet x✝ : Quotient.mk setoid y ∈ ZFSet.sep p (Quotient.mk setoid (PSet.mk α A)) a : Type (PSet.mk α A) pa : (fun y => p (mk y)) (Func (PSet.mk α A) a) h : PSet.Equiv y (Func ↑(Resp.f { val := PSet.sep fun y => p (mk y), property := (_ : ∀ (x x_1 : PSet), PSet.Equiv x x_1 → Arity.Equiv (PSet.sep (fun y => p (mk y)) x) (PSet.sep (fun y => p (mk y)) x_1)) } (PSet.mk α A)) { val := a, property := pa }) ⊢ p (Quotient.mk setoid y) rwa [@Quotient.sound PSet _ _ _ h] p : ZFSet → Prop x y✝ : ZFSet x✝¹ y : PSet α : Type u A : α → PSet x✝ : Quotient.mk setoid y ∈ Quotient.mk setoid (PSet.mk α A) ∧ p (Quotient.mk setoid y) a : Type (PSet.mk α A) h : PSet.Equiv y (Func (PSet.mk α A) a) pa : p (Quotient.mk setoid y) ⊢ (fun y => p (mk y)) (Func (PSet.mk α A) a) rw [mk_func] at h p : ZFSet → Prop x y✝ : ZFSet x✝¹ y : PSet α : Type u A : α → PSet x✝ : Quotient.mk setoid y ∈ Quotient.mk setoid (PSet.mk α A) ∧ p (Quotient.mk setoid y) a : Type (PSet.mk α A) h : PSet.Equiv y (A a) pa : p (Quotient.mk setoid y) ⊢ p (mk (Func (PSet.mk α A) a)) rwa [mk_func, ← ZFSet.sound h] ** Qed
ZFSet.toSet_sep a : ZFSet p : ZFSet → Prop ⊢ toSet (ZFSet.sep p a) = {x \| x ∈ toSet a ∧ p x} ext case h a : ZFSet p : ZFSet → Prop x✝ : ZFSet ⊢ x✝ ∈ toSet (ZFSet.sep p a) ↔ x✝ ∈ {x \| x ∈ toSet a ∧ p x} simp ** Qed
ZFSet.mem_powerset x y : ZFSet x✝¹ x✝ : PSet α : Type u A : α → PSet β : Type u B : β → PSet ⊢ PSet.mk β B ∈ PSet.powerset (PSet.mk α A) ↔ Quotient.mk setoid (PSet.mk β B) ⊆ Quotient.mk setoid (PSet.mk α A) simp [mem_powerset, subset_iff] ** Qed
ZFSet.sUnion_lem α β : Type u A : α → PSet B : β → PSet αβ : ∀ (a : α), ∃ b, PSet.Equiv (A a) (B b) a : Type (PSet.mk α A) c : Type (Func (PSet.mk α A) a) ⊢ ∃ b, PSet.Equiv (Func (⋃₀ PSet.mk α A) { fst := a, snd := c }) (Func (⋃₀ PSet.mk β B) b) let ⟨b, hb⟩ := αβ a α β : Type u A : α → PSet B : β → PSet αβ : ∀ (a : α), ∃ b, PSet.Equiv (A a) (B b) a : Type (PSet.mk α A) c : Type (Func (PSet.mk α A) a) b : β hb : PSet.Equiv (A a) (B b) ⊢ ∃ b, PSet.Equiv (Func (⋃₀ PSet.mk α A) { fst := a, snd := c }) (Func (⋃₀ PSet.mk β B) b) induction' ea : A a with γ Γ case mk α β : Type u A : α → PSet B : β → PSet αβ : ∀ (a : α), ∃ b, PSet.Equiv (A a) (B b) a : Type (PSet.mk α A) c : Type (Func (PSet.mk α A) a) b : β hb : PSet.Equiv (A a) (B b) x✝ : PSet ea✝ : A a = x✝ γ : Type u Γ : γ → PSet A_ih✝ : ∀ (a_1 : γ), A a = Γ a_1 → ∃ b, PSet.Equiv (Func (⋃₀ PSet.mk α A) { fst := a, snd := c }) (Func (⋃₀ PSet.mk β B) b) ea : A a = PSet.mk γ Γ ⊢ ∃ b, PSet.Equiv (Func (⋃₀ PSet.mk α A) { fst := a, snd := c }) (Func (⋃₀ PSet.mk β B) b) induction' eb : B b with δ Δ case mk.mk α β : Type u A : α → PSet B : β → PSet αβ : ∀ (a : α), ∃ b, PSet.Equiv (A a) (B b) a : Type (PSet.mk α A) c : Type (Func (PSet.mk α A) a) b : β hb : PSet.Equiv (A a) (B b) x✝¹ : PSet ea✝ : A a = x✝¹ γ : Type u Γ : γ → PSet A_ih✝¹ : ∀ (a_1 : γ), A a = Γ a_1 → ∃ b, PSet.Equiv (Func (⋃₀ PSet.mk α A) { fst := a, snd := c }) (Func (⋃₀ PSet.mk β B) b) ea : A a = PSet.mk γ Γ x✝ : PSet eb✝ : B b = x✝ δ : Type u Δ : δ → PSet A_ih✝ : ∀ (a_1 : δ), B b = Δ a_1 → ∃ b, PSet.Equiv (Func (⋃₀ PSet.mk α A) { fst := a, snd := c }) (Func (⋃₀ PSet.mk β B) b) eb : B b = PSet.mk δ Δ ⊢ ∃ b, PSet.Equiv (Func (⋃₀ PSet.mk α A) { fst := a, snd := c }) (Func (⋃₀ PSet.mk β B) b) rw [ea, eb] at hb case mk.mk α β : Type u A : α → PSet B : β → PSet αβ : ∀ (a : α), ∃ b, PSet.Equiv (A a) (B b) a : Type (PSet.mk α A) c : Type (Func (PSet.mk α A) a) b : β x✝¹ : PSet ea✝ : A a = x✝¹ γ : Type u Γ : γ → PSet A_ih✝¹ : ∀ (a_1 : γ), A a = Γ a_1 → ∃ b, PSet.Equiv (Func (⋃₀ PSet.mk α A) { fst := a, snd := c }) (Func (⋃₀ PSet.mk β B) b) ea : A a = PSet.mk γ Γ x✝ : PSet eb✝ : B b = x✝ δ : Type u Δ : δ → PSet hb : PSet.Equiv (PSet.mk γ Γ) (PSet.mk δ Δ) A_ih✝ : ∀ (a_1 : δ), B b = Δ a_1 → ∃ b, PSet.Equiv (Func (⋃₀ PSet.mk α A) { fst := a, snd := c }) (Func (⋃₀ PSet.mk β B) b) eb : B b = PSet.mk δ Δ ⊢ ∃ b, PSet.Equiv (Func (⋃₀ PSet.mk α A) { fst := a, snd := c }) (Func (⋃₀ PSet.mk β B) b) cases' hb with γδ δγ case mk.mk.intro α β : Type u A : α → PSet B : β → PSet αβ : ∀ (a : α), ∃ b, PSet.Equiv (A a) (B b) a : Type (PSet.mk α A) c : Type (Func (PSet.mk α A) a) b : β x✝¹ : PSet ea✝ : A a = x✝¹ γ : Type u Γ : γ → PSet A_ih✝¹ : ∀ (a_1 : γ), A a = Γ a_1 → ∃ b, PSet.Equiv (Func (⋃₀ PSet.mk α A) { fst := a, snd := c }) (Func (⋃₀ PSet.mk β B) b) ea : A a = PSet.mk γ Γ x✝ : PSet eb✝ : B b = x✝ δ : Type u Δ : δ → PSet A_ih✝ : ∀ (a_1 : δ), B b = Δ a_1 → ∃ b, PSet.Equiv (Func (⋃₀ PSet.mk α A) { fst := a, snd := c }) (Func (⋃₀ PSet.mk β B) b) eb : B b = PSet.mk δ Δ γδ : ∀ (a : γ), ∃ b, PSet.Equiv (Γ a) (Δ b) δγ : ∀ (b : δ), ∃ a, PSet.Equiv (Γ a) (Δ b) ⊢ ∃ b, PSet.Equiv (Func (⋃₀ PSet.mk α A) { fst := a, snd := c }) (Func (⋃₀ PSet.mk β B) b) let c : (A a).Type := c case mk.mk.intro α β : Type u A : α → PSet B : β → PSet αβ : ∀ (a : α), ∃ b, PSet.Equiv (A a) (B b) a : Type (PSet.mk α A) c✝ : Type (Func (PSet.mk α A) a) b : β x✝¹ : PSet ea✝ : A a = x✝¹ γ : Type u Γ : γ → PSet A_ih✝¹ : ∀ (a_1 : γ), A a = Γ a_1 → ∃ b, PSet.Equiv (Func (⋃₀ PSet.mk α A) { fst := a, snd := c✝ }) (Func (⋃₀ PSet.mk β B) b) ea : A a = PSet.mk γ Γ x✝ : PSet eb✝ : B b = x✝ δ : Type u Δ : δ → PSet A_ih✝ : ∀ (a_1 : δ), B b = Δ a_1 → ∃ b, PSet.Equiv (Func (⋃₀ PSet.mk α A) { fst := a, snd := c✝ }) (Func (⋃₀ PSet.mk β B) b) eb : B b = PSet.mk δ Δ γδ : ∀ (a : γ), ∃ b, PSet.Equiv (Γ a) (Δ b) δγ : ∀ (b : δ), ∃ a, PSet.Equiv (Γ a) (Δ b) c : Type (A a) := c✝ ⊢ ∃ b, PSet.Equiv (Func (⋃₀ PSet.mk α A) { fst := a, snd := c✝ }) (Func (⋃₀ PSet.mk β B) b) let ⟨d, hd⟩ := γδ (by rwa [ea] at c) case mk.mk.intro α β : Type u A : α → PSet B : β → PSet αβ : ∀ (a : α), ∃ b, PSet.Equiv (A a) (B b) a : Type (PSet.mk α A) c✝ : Type (Func (PSet.mk α A) a) b : β x✝¹ : PSet ea✝ : A a = x✝¹ γ : Type u Γ : γ → PSet A_ih✝¹ : ∀ (a_1 : γ), A a = Γ a_1 → ∃ b, PSet.Equiv (Func (⋃₀ PSet.mk α A) { fst := a, snd := c✝ }) (Func (⋃₀ PSet.mk β B) b) ea : A a = PSet.mk γ Γ x✝ : PSet eb✝ : B b = x✝ δ : Type u Δ : δ → PSet A_ih✝ : ∀ (a_1 : δ), B b = Δ a_1 → ∃ b, PSet.Equiv (Func (⋃₀ PSet.mk α A) { fst := a, snd := c✝ }) (Func (⋃₀ PSet.mk β B) b) eb : B b = PSet.mk δ Δ γδ : ∀ (a : γ), ∃ b, PSet.Equiv (Γ a) (Δ b) δγ : ∀ (b : δ), ∃ a, PSet.Equiv (Γ a) (Δ b) c : Type (A a) := c✝ d : δ hd : PSet.Equiv (Γ (Eq.mp (_ : Type (A a) = Type (PSet.mk γ Γ)) c)) (Δ d) ⊢ ∃ b, PSet.Equiv (Func (⋃₀ PSet.mk α A) { fst := a, snd := c✝ }) (Func (⋃₀ PSet.mk β B) b) use ⟨b, Eq.ndrec d (Eq.symm eb)⟩ case h α β : Type u A : α → PSet B : β → PSet αβ : ∀ (a : α), ∃ b, PSet.Equiv (A a) (B b) a : Type (PSet.mk α A) c✝ : Type (Func (PSet.mk α A) a) b : β x✝¹ : PSet ea✝ : A a = x✝¹ γ : Type u Γ : γ → PSet A_ih✝¹ : ∀ (a_1 : γ), A a = Γ a_1 → ∃ b, PSet.Equiv (Func (⋃₀ PSet.mk α A) { fst := a, snd := c✝ }) (Func (⋃₀ PSet.mk β B) b) ea : A a = PSet.mk γ Γ x✝ : PSet eb✝ : B b = x✝ δ : Type u Δ : δ → PSet A_ih✝ : ∀ (a_1 : δ), B b = Δ a_1 → ∃ b, PSet.Equiv (Func (⋃₀ PSet.mk α A) { fst := a, snd := c✝ }) (Func (⋃₀ PSet.mk β B) b) eb : B b = PSet.mk δ Δ γδ : ∀ (a : γ), ∃ b, PSet.Equiv (Γ a) (Δ b) δγ : ∀ (b : δ), ∃ a, PSet.Equiv (Γ a) (Δ b) c : Type (A a) := c✝ d : δ hd : PSet.Equiv (Γ (Eq.mp (_ : Type (A a) = Type (PSet.mk γ Γ)) c)) (Δ d) ⊢ PSet.Equiv (Func (⋃₀ PSet.mk α A) { fst := a, snd := c✝ }) (Func (⋃₀ PSet.mk β B) { fst := b, snd := (_ : PSet.mk δ Δ = Func (PSet.mk β B) b) ▸ d }) change PSet.Equiv ((A a).Func c) ((B b).Func (Eq.ndrec d eb.symm)) case h α β : Type u A : α → PSet B : β → PSet αβ : ∀ (a : α), ∃ b, PSet.Equiv (A a) (B b) a : Type (PSet.mk α A) c✝ : Type (Func (PSet.mk α A) a) b : β x✝¹ : PSet ea✝ : A a = x✝¹ γ : Type u Γ : γ → PSet A_ih✝¹ : ∀ (a_1 : γ), A a = Γ a_1 → ∃ b, PSet.Equiv (Func (⋃₀ PSet.mk α A) { fst := a, snd := c✝ }) (Func (⋃₀ PSet.mk β B) b) ea : A a = PSet.mk γ Γ x✝ : PSet eb✝ : B b = x✝ δ : Type u Δ : δ → PSet A_ih✝ : ∀ (a_1 : δ), B b = Δ a_1 → ∃ b, PSet.Equiv (Func (⋃₀ PSet.mk α A) { fst := a, snd := c✝ }) (Func (⋃₀ PSet.mk β B) b) eb : B b = PSet.mk δ Δ γδ : ∀ (a : γ), ∃ b, PSet.Equiv (Γ a) (Δ b) δγ : ∀ (b : δ), ∃ a, PSet.Equiv (Γ a) (Δ b) c : Type (A a) := c✝ d : δ hd : PSet.Equiv (Γ (Eq.mp (_ : Type (A a) = Type (PSet.mk γ Γ)) c)) (Δ d) ⊢ PSet.Equiv (Func (A a) c) (Func (B b) ((_ : PSet.mk δ Δ = B b) ▸ d)) match A a, B b, ea, eb, c, d, hd with \| _, _, rfl, rfl, _, _, hd => exact hd α β : Type u A : α → PSet B : β → PSet αβ : ∀ (a : α), ∃ b, PSet.Equiv (A a) (B b) a : Type (PSet.mk α A) c✝ : Type (Func (PSet.mk α A) a) b : β x✝¹ : PSet ea✝ : A a = x✝¹ γ : Type u Γ : γ → PSet A_ih✝¹ : ∀ (a_1 : γ), A a = Γ a_1 → ∃ b, PSet.Equiv (Func (⋃₀ PSet.mk α A) { fst := a, snd := c✝ }) (Func (⋃₀ PSet.mk β B) b) ea : A a = PSet.mk γ Γ x✝ : PSet eb✝ : B b = x✝ δ : Type u Δ : δ → PSet A_ih✝ : ∀ (a_1 : δ), B b = Δ a_1 → ∃ b, PSet.Equiv (Func (⋃₀ PSet.mk α A) { fst := a, snd := c✝ }) (Func (⋃₀ PSet.mk β B) b) eb : B b = PSet.mk δ Δ γδ : ∀ (a : γ), ∃ b, PSet.Equiv (Γ a) (Δ b) δγ : ∀ (b : δ), ∃ a, PSet.Equiv (Γ a) (Δ b) c : Type (A a) := c✝ ⊢ γ rwa [ea] at c α β : Type u A : α → PSet B : β → PSet αβ : ∀ (a : α), ∃ b, PSet.Equiv (A a) (B b) a : Type (PSet.mk α A) c✝ : Type (Func (PSet.mk α A) a) b : β x✝³ : PSet ea✝ : A a = x✝³ γ : Type u Γ : γ → PSet A_ih✝¹ : ∀ (a_1 : γ), A a = Γ a_1 → ∃ b, PSet.Equiv (Func (⋃₀ PSet.mk α A) { fst := a, snd := c✝ }) (Func (⋃₀ PSet.mk β B) b) ea : A a = PSet.mk γ Γ x✝² : PSet eb✝ : B b = x✝² δ : Type u Δ : δ → PSet A_ih✝ : ∀ (a_1 : δ), B b = Δ a_1 → ∃ b, PSet.Equiv (Func (⋃₀ PSet.mk α A) { fst := a, snd := c✝ }) (Func (⋃₀ PSet.mk β B) b) eb : B b = PSet.mk δ Δ γδ : ∀ (a : γ), ∃ b, PSet.Equiv (Γ a) (Δ b) δγ : ∀ (b : δ), ∃ a, PSet.Equiv (Γ a) (Δ b) c : Type (A a) := c✝ d : δ hd✝ : PSet.Equiv (Γ (Eq.mp (_ : Type (A a) = Type (PSet.mk γ Γ)) c)) (Δ d) x✝¹ : Type (PSet.mk γ Γ) x✝ : δ hd : PSet.Equiv (Γ (Eq.mp (_ : Type (PSet.mk γ Γ) = Type (PSet.mk γ Γ)) x✝¹)) (Δ x✝) ⊢ PSet.Equiv (Func (PSet.mk γ Γ) x✝¹) (Func (PSet.mk δ Δ) ((_ : PSet.mk δ Δ = PSet.mk δ Δ) ▸ x✝)) exact hd ** Qed
ZFSet.mem_sInter x y : ZFSet h : ZFSet.Nonempty x ⊢ y ∈ ⋂₀ x ↔ ∀ (z : ZFSet), z ∈ x → y ∈ z rw [sInter, dif_pos h] x y : ZFSet h : ZFSet.Nonempty x ⊢ y ∈ ZFSet.sep (fun y => ∀ (z : ZFSet), z ∈ x → y ∈ z) (Set.Nonempty.some h) ↔ ∀ (z : ZFSet), z ∈ x → y ∈ z simp only [mem_toSet, mem_sep, and_iff_right_iff_imp] x y : ZFSet h : ZFSet.Nonempty x ⊢ (∀ (z : ZFSet), z ∈ x → y ∈ z) → y ∈ Set.Nonempty.some h exact fun H => H _ h.some_mem ** Qed
ZFSet.sUnion_empty ⊢ ⋃₀ ∅ = ∅ ext case a z✝ : ZFSet ⊢ z✝ ∈ ⋃₀ ∅ ↔ z✝ ∈ ∅ simp ** Qed
ZFSet.sInter_empty ⊢ ¬ZFSet.Nonempty ∅ simp ** Qed
ZFSet.mem_of_mem_sInter x y z : ZFSet hy : y ∈ ⋂₀ x hz : z ∈ x ⊢ y ∈ z rcases eq_empty_or_nonempty x with (rfl \| hx) case inl y z : ZFSet hy : y ∈ ⋂₀ ∅ hz : z ∈ ∅ ⊢ y ∈ z exact (not_mem_empty z hz).elim case inr x y z : ZFSet hy : y ∈ ⋂₀ x hz : z ∈ x hx : ZFSet.Nonempty x ⊢ y ∈ z exact (mem_sInter hx).1 hy z hz ** Qed
ZFSet.sUnion_singleton x y : ZFSet ⊢ y ∈ ⋃₀ {x} ↔ y ∈ x simp_rw [mem_sUnion, mem_singleton, exists_eq_left] ** Qed
ZFSet.sInter_singleton x y : ZFSet ⊢ y ∈ ⋂₀ {x} ↔ y ∈ x simp_rw [mem_sInter (singleton_nonempty x), mem_singleton, forall_eq] ** Qed
ZFSet.toSet_sUnion x : ZFSet ⊢ toSet (⋃₀ x) = ⋃₀ (toSet '' toSet x) ext case h x x✝ : ZFSet ⊢ x✝ ∈ toSet (⋃₀ x) ↔ x✝ ∈ ⋃₀ (toSet '' toSet x) simp ** Qed
ZFSet.toSet_sInter x : ZFSet h : ZFSet.Nonempty x ⊢ toSet (⋂₀ x) = ⋂₀ (toSet '' toSet x) ext case h x : ZFSet h : ZFSet.Nonempty x x✝ : ZFSet ⊢ x✝ ∈ toSet (⋂₀ x) ↔ x✝ ∈ ⋂₀ (toSet '' toSet x) simp [mem_sInter h] ** Qed
ZFSet.singleton_injective x y : ZFSet H : {x} = {y} ⊢ x = y let this := congr_arg sUnion H x y : ZFSet H : {x} = {y} this : ⋃₀ {x} = ⋃₀ {y} := congr_arg sUnion H ⊢ x = y rwa [sUnion_singleton, sUnion_singleton] at this ** Qed
ZFSet.toSet_union x y : ZFSet ⊢ toSet (x ∪ y) = toSet x ∪ toSet y change (⋃₀ {x, y}).toSet = _ x y : ZFSet ⊢ toSet (⋃₀ {x, y}) = toSet x ∪ toSet y simp ** Qed
ZFSet.toSet_inter x y : ZFSet ⊢ toSet (x ∩ y) = toSet x ∩ toSet y change (ZFSet.sep (fun z => z ∈ y) x).toSet = _ x y : ZFSet ⊢ toSet (ZFSet.sep (fun z => z ∈ y) x) = toSet x ∩ toSet y ext case h x y x✝ : ZFSet ⊢ x✝ ∈ toSet (ZFSet.sep (fun z => z ∈ y) x) ↔ x✝ ∈ toSet x ∩ toSet y simp ** Qed
ZFSet.toSet_sdiff x y : ZFSet ⊢ toSet (x \ y) = toSet x \ toSet y change (ZFSet.sep (fun z => z ∉ y) x).toSet = _ x y : ZFSet ⊢ toSet (ZFSet.sep (fun z => ¬z ∈ y) x) = toSet x \ toSet y ext case h x y x✝ : ZFSet ⊢ x✝ ∈ toSet (ZFSet.sep (fun z => ¬z ∈ y) x) ↔ x✝ ∈ toSet x \ toSet y simp ** Qed
ZFSet.mem_union x y z : ZFSet ⊢ z ∈ x ∪ y ↔ z ∈ x ∨ z ∈ y rw [← mem_toSet] x y z : ZFSet ⊢ z ∈ toSet (x ∪ y) ↔ z ∈ x ∨ z ∈ y simp ** Qed
ZFSet.toSet_image f : ZFSet → ZFSet H : Definable 1 f x : ZFSet ⊢ toSet (image f x) = f '' toSet x ext case h f : ZFSet → ZFSet H : Definable 1 f x x✝ : ZFSet ⊢ x✝ ∈ toSet (image f x) ↔ x✝ ∈ f '' toSet x simp ** Qed
ZFSet.mem_range α : Type u f : α → ZFSet x : ZFSet y : PSet ⊢ Quotient.mk setoid y ∈ range f ↔ Quotient.mk setoid y ∈ Set.range f constructor case mp α : Type u f : α → ZFSet x : ZFSet y : PSet ⊢ Quotient.mk setoid y ∈ range f → Quotient.mk setoid y ∈ Set.range f rintro ⟨z, hz⟩ case mp.intro α : Type u f : α → ZFSet x : ZFSet y : PSet z : Type (PSet.mk (ULift.{v, u} α) (Quotient.out ∘ f ∘ ULift.down)) hz : PSet.Equiv y (Func (PSet.mk (ULift.{v, u} α) (Quotient.out ∘ f ∘ ULift.down)) z) ⊢ Quotient.mk setoid y ∈ Set.range f exact ⟨z.down, Quotient.eq_mk_iff_out.2 hz.symm⟩ case mpr α : Type u f : α → ZFSet x : ZFSet y : PSet ⊢ Quotient.mk setoid y ∈ Set.range f → Quotient.mk setoid y ∈ range f rintro ⟨z, hz⟩ case mpr.intro α : Type u f : α → ZFSet x : ZFSet y : PSet z : α hz : f z = Quotient.mk setoid y ⊢ Quotient.mk setoid y ∈ range f use ULift.up z case h α : Type u f : α → ZFSet x : ZFSet y : PSet z : α hz : f z = Quotient.mk setoid y ⊢ PSet.Equiv y (Func (PSet.mk (ULift.{v, u} α) (Quotient.out ∘ f ∘ ULift.down)) { down := z }) simpa [hz] using PSet.Equiv.symm (Quotient.mk_out y) ** Qed
ZFSet.toSet_range α : Type u f : α → ZFSet ⊢ toSet (range f) = Set.range f ext case h α : Type u f : α → ZFSet x✝ : ZFSet ⊢ x✝ ∈ toSet (range f) ↔ x✝ ∈ Set.range f simp ** Qed
ZFSet.toSet_pair x y : ZFSet ⊢ toSet (pair x y) = {{x}, {x, y}} simp [pair] ** Qed
ZFSet.mem_pairSep p : ZFSet → ZFSet → Prop x y z : ZFSet ⊢ z ∈ pairSep p x y ↔ ∃ a, a ∈ x ∧ ∃ b, b ∈ y ∧ z = pair a b ∧ p a b refine' mem_sep.trans ⟨And.right, fun e => ⟨_, e⟩⟩ p : ZFSet → ZFSet → Prop x y z : ZFSet e : ∃ a, a ∈ x ∧ ∃ b, b ∈ y ∧ z = pair a b ∧ p a b ⊢ z ∈ powerset (powerset (x ∪ y)) rcases e with ⟨a, ax, b, bY, rfl, pab⟩ case intro.intro.intro.intro.intro p : ZFSet → ZFSet → Prop x y a : ZFSet ax : a ∈ x b : ZFSet bY : b ∈ y pab : p a b ⊢ pair a b ∈ powerset (powerset (x ∪ y)) simp only [mem_powerset, subset_def, mem_union, pair, mem_pair] case intro.intro.intro.intro.intro p : ZFSet → ZFSet → Prop x y a : ZFSet ax : a ∈ x b : ZFSet bY : b ∈ y pab : p a b ⊢ ∀ ⦃z : ZFSet⦄, z = {a} ∨ z = {a, b} → ∀ ⦃z_1 : ZFSet⦄, z_1 ∈ z → z_1 ∈ x ∨ z_1 ∈ y rintro u (rfl \| rfl) v <;> simp only [mem_singleton, mem_pair] case intro.intro.intro.intro.intro.inl p : ZFSet → ZFSet → Prop x y a : ZFSet ax : a ∈ x b : ZFSet bY : b ∈ y pab : p a b v : ZFSet ⊢ v = a → v ∈ x ∨ v ∈ y rintro rfl case intro.intro.intro.intro.intro.inl p : ZFSet → ZFSet → Prop x y b : ZFSet bY : b ∈ y v : ZFSet ax : v ∈ x pab : p v b ⊢ v ∈ x ∨ v ∈ y exact Or.inl ax case intro.intro.intro.intro.intro.inr p : ZFSet → ZFSet → Prop x y a : ZFSet ax : a ∈ x b : ZFSet bY : b ∈ y pab : p a b v : ZFSet ⊢ v = a ∨ v = b → v ∈ x ∨ v ∈ y rintro (rfl \| rfl) <;> [left; right] <;> assumption ** Qed
ZFSet.pair_injective x x' y y' : ZFSet H : pair x y = pair x' y' ⊢ x = x' ∧ y = y' have ae := ext_iff.1 H x x' y y' : ZFSet H : pair x y = pair x' y' ae : ∀ (z : ZFSet), z ∈ pair x y ↔ z ∈ pair x' y' ⊢ x = x' ∧ y = y' simp only [pair, mem_pair] at ae x y y' : ZFSet H : pair x y = pair x y' ae : ∀ (z : ZFSet), z = {x} ∨ z = {x, y} ↔ z = {x} ∨ z = {x, y'} he : x = y → y = y' ⊢ x = x ∧ y = y' obtain xyx \| xyy' := (ae {x, y}).1 (by simp) x x' y y' : ZFSet H : pair x y = pair x' y' ae : ∀ (z : ZFSet), z = {x} ∨ z = {x, y} ↔ z = {x'} ∨ z = {x', y'} ⊢ x = x' cases' (ae {x}).1 (by simp) with h h x x' y y' : ZFSet H : pair x y = pair x' y' ae : ∀ (z : ZFSet), z = {x} ∨ z = {x, y} ↔ z = {x'} ∨ z = {x', y'} ⊢ {x} = {x} ∨ {x} = {x, y} simp case inl x x' y y' : ZFSet H : pair x y = pair x' y' ae : ∀ (z : ZFSet), z = {x} ∨ z = {x, y} ↔ z = {x'} ∨ z = {x', y'} h : {x} = {x'} ⊢ x = x' exact singleton_injective h case inr x x' y y' : ZFSet H : pair x y = pair x' y' ae : ∀ (z : ZFSet), z = {x} ∨ z = {x, y} ↔ z = {x'} ∨ z = {x', y'} h : {x} = {x', y'} ⊢ x = x' have m : x' ∈ ({x} : ZFSet) := by simp [h] case inr x x' y y' : ZFSet H : pair x y = pair x' y' ae : ∀ (z : ZFSet), z = {x} ∨ z = {x, y} ↔ z = {x'} ∨ z = {x', y'} h : {x} = {x', y'} m : x' ∈ {x} ⊢ x = x' rw [mem_singleton.mp m] x x' y y' : ZFSet H : pair x y = pair x' y' ae : ∀ (z : ZFSet), z = {x} ∨ z = {x, y} ↔ z = {x'} ∨ z = {x', y'} h : {x} = {x', y'} ⊢ x' ∈ {x} simp [h] x y y' : ZFSet H : pair x y = pair x y' ae : ∀ (z : ZFSet), z = {x} ∨ z = {x, y} ↔ z = {x} ∨ z = {x, y'} ⊢ x = y → y = y' rintro rfl x y' : ZFSet H : pair x x = pair x y' ae : ∀ (z : ZFSet), z = {x} ∨ z = {x, x} ↔ z = {x} ∨ z = {x, y'} ⊢ x = y' cases' (ae {x, y'}).2 (by simp only [eq_self_iff_true, or_true_iff]) with xy'x xy'xx x y' : ZFSet H : pair x x = pair x y' ae : ∀ (z : ZFSet), z = {x} ∨ z = {x, x} ↔ z = {x} ∨ z = {x, y'} ⊢ {x, y'} = {x} ∨ {x, y'} = {x, y'} simp only [eq_self_iff_true, or_true_iff] case inl x y' : ZFSet H : pair x x = pair x y' ae : ∀ (z : ZFSet), z = {x} ∨ z = {x, x} ↔ z = {x} ∨ z = {x, y'} xy'x : {x, y'} = {x} ⊢ x = y' rw [eq_comm, ← mem_singleton, ← xy'x, mem_pair] case inl x y' : ZFSet H : pair x x = pair x y' ae : ∀ (z : ZFSet), z = {x} ∨ z = {x, x} ↔ z = {x} ∨ z = {x, y'} xy'x : {x, y'} = {x} ⊢ y' = x ∨ y' = y' exact Or.inr rfl case inr x y' : ZFSet H : pair x x = pair x y' ae : ∀ (z : ZFSet), z = {x} ∨ z = {x, x} ↔ z = {x} ∨ z = {x, y'} xy'xx : {x, y'} = {x, x} ⊢ x = y' simpa [eq_comm] using (ext_iff.1 xy'xx y').1 (by simp) x y' : ZFSet H : pair x x = pair x y' ae : ∀ (z : ZFSet), z = {x} ∨ z = {x, x} ↔ z = {x} ∨ z = {x, y'} xy'xx : {x, y'} = {x, x} ⊢ y' ∈ {x, y'} simp x y y' : ZFSet H : pair x y = pair x y' ae : ∀ (z : ZFSet), z = {x} ∨ z = {x, y} ↔ z = {x} ∨ z = {x, y'} he : x = y → y = y' ⊢ {x, y} = {x} ∨ {x, y} = {x, y} simp case inl x y y' : ZFSet H : pair x y = pair x y' ae : ∀ (z : ZFSet), z = {x} ∨ z = {x, y} ↔ z = {x} ∨ z = {x, y'} he : x = y → y = y' xyx : {x, y} = {x} ⊢ x = x ∧ y = y' obtain rfl := mem_singleton.mp ((ext_iff.1 xyx y).1 <\| by simp) case inl y y' : ZFSet H : pair y y = pair y y' ae : ∀ (z : ZFSet), z = {y} ∨ z = {y, y} ↔ z = {y} ∨ z = {y, y'} he : y = y → y = y' xyx : {y, y} = {y} ⊢ y = y ∧ y = y' simp [he rfl] x y y' : ZFSet H : pair x y = pair x y' ae : ∀ (z : ZFSet), z = {x} ∨ z = {x, y} ↔ z = {x} ∨ z = {x, y'} he : x = y → y = y' xyx : {x, y} = {x} ⊢ y ∈ {x, y} simp case inr x y y' : ZFSet H : pair x y = pair x y' ae : ∀ (z : ZFSet), z = {x} ∨ z = {x, y} ↔ z = {x} ∨ z = {x, y'} he : x = y → y = y' xyy' : {x, y} = {x, y'} ⊢ x = x ∧ y = y' obtain rfl \| yy' := mem_pair.mp ((ext_iff.1 xyy' y).1 <\| by simp) x y y' : ZFSet H : pair x y = pair x y' ae : ∀ (z : ZFSet), z = {x} ∨ z = {x, y} ↔ z = {x} ∨ z = {x, y'} he : x = y → y = y' xyy' : {x, y} = {x, y'} ⊢ y ∈ {x, y} simp case inr.inl y y' : ZFSet H : pair y y = pair y y' ae : ∀ (z : ZFSet), z = {y} ∨ z = {y, y} ↔ z = {y} ∨ z = {y, y'} he : y = y → y = y' xyy' : {y, y} = {y, y'} ⊢ y = y ∧ y = y' simp [he rfl] case inr.inr x y y' : ZFSet H : pair x y = pair x y' ae : ∀ (z : ZFSet), z = {x} ∨ z = {x, y} ↔ z = {x} ∨ z = {x, y'} he : x = y → y = y' xyy' : {x, y} = {x, y'} yy' : y = y' ⊢ x = x ∧ y = y' simp [yy'] ** Qed
ZFSet.mem_prod x y z : ZFSet ⊢ z ∈ prod x y ↔ ∃ a, a ∈ x ∧ ∃ b, b ∈ y ∧ z = pair a b simp [prod] ** Qed
ZFSet.pair_mem_prod x y a b : ZFSet ⊢ pair a b ∈ prod x y ↔ a ∈ x ∧ b ∈ y simp ** Qed
ZFSet.mem_funs x y f : ZFSet ⊢ f ∈ funs x y ↔ IsFunc x y f simp [funs, IsFunc] ** Qed
ZFSet.map_unique f : ZFSet → ZFSet H : Definable 1 f x z : ZFSet zx : z ∈ x y : ZFSet yx : (fun w => pair z w ∈ map f x) y ⊢ y = f z let ⟨w, _, we⟩ := mem_image.1 yx f : ZFSet → ZFSet H : Definable 1 f x z : ZFSet zx : z ∈ x y : ZFSet yx : (fun w => pair z w ∈ map f x) y w : ZFSet left✝ : w ∈ x we : pair w (f w) = pair z y ⊢ y = f z let ⟨wz, fy⟩ := pair_injective we f : ZFSet → ZFSet H : Definable 1 f x z : ZFSet zx : z ∈ x y : ZFSet yx : (fun w => pair z w ∈ map f x) y w : ZFSet left✝ : w ∈ x we : pair w (f w) = pair z y wz : w = z fy : f w = y ⊢ y = f z rw [← fy, wz] ** Qed
ZFSet.hereditarily_iff p : ZFSet → Prop x y : ZFSet ⊢ Hereditarily p x ↔ p x ∧ ∀ (y : ZFSet), y ∈ x → Hereditarily p y rw [← Hereditarily] ** Qed
ZFSet.Hereditarily.empty p : ZFSet → Prop x y : ZFSet ⊢ Hereditarily p x → p ∅ apply @ZFSet.inductionOn _ x p : ZFSet → Prop x y : ZFSet ⊢ ∀ (x : ZFSet), (∀ (y : ZFSet), y ∈ x → Hereditarily p y → p ∅) → Hereditarily p x → p ∅ intro y IH h p : ZFSet → Prop x y✝ y : ZFSet IH : ∀ (y_1 : ZFSet), y_1 ∈ y → Hereditarily p y_1 → p ∅ h : Hereditarily p y ⊢ p ∅ rcases ZFSet.eq_empty_or_nonempty y with (rfl \| ⟨a, ha⟩) case inl p : ZFSet → Prop x y : ZFSet IH : ∀ (y : ZFSet), y ∈ ∅ → Hereditarily p y → p ∅ h : Hereditarily p ∅ ⊢ p ∅ exact h.self case inr.intro p : ZFSet → Prop x y✝ y : ZFSet IH : ∀ (y_1 : ZFSet), y_1 ∈ y → Hereditarily p y_1 → p ∅ h : Hereditarily p y a : ZFSet ha : a ∈ toSet y ⊢ p ∅ exact IH a ha (h.mem ha) ** Qed
Class.mem_wf ⊢ ∀ (x : ZFSet), Acc (fun x x_1 => x ∈ x_1) ↑x refine' fun a => ZFSet.inductionOn a fun x IH => ⟨_, _⟩ a x : ZFSet IH : ∀ (y : ZFSet), y ∈ x → Acc (fun x x_1 => x ∈ x_1) ↑y ⊢ ∀ (y : Class), y ∈ ↑x → Acc (fun x x_1 => x ∈ x_1) y rintro A ⟨z, rfl, hz⟩ case intro.intro a x : ZFSet IH : ∀ (y : ZFSet), y ∈ x → Acc (fun x x_1 => x ∈ x_1) ↑y z : ZFSet hz : ↑x z ⊢ Acc (fun x x_1 => x ∈ x_1) ↑z exact IH z hz H : ∀ (x : ZFSet), Acc (fun x x_1 => x ∈ x_1) ↑x ⊢ ∀ (a : Class), Acc (fun x x_1 => x ∈ x_1) a refine' fun A => ⟨A, _⟩ H : ∀ (x : ZFSet), Acc (fun x x_1 => x ∈ x_1) ↑x A : Class ⊢ ∀ (y : Class), y ∈ A → Acc (fun x x_1 => x ∈ x_1) y rintro B ⟨x, rfl, _⟩ case intro.intro H : ∀ (x : ZFSet), Acc (fun x x_1 => x ∈ x_1) ↑x A : Class x : ZFSet right✝ : A x ⊢ Acc (fun x x_1 => x ∈ x_1) ↑x exact H x ** Qed
Class.congToClass_empty ⊢ congToClass ∅ = ∅ ext z case a z : ZFSet ⊢ congToClass ∅ z ↔ ∅ z simp only [congToClass, not_empty_hom, iff_false_iff] case a z : ZFSet ⊢ ¬setOf (fun y => ↑y ∈ ∅) z exact Set.not_mem_empty z ** Qed
Class.classToCong_empty ⊢ classToCong ∅ = ∅ ext case h x✝ : Class ⊢ x✝ ∈ classToCong ∅ ↔ x✝ ∈ ∅ simp [classToCong] ** Qed
Class.ofSet.inj x y : ZFSet h : ↑x = ↑y z : ZFSet ⊢ z ∈ x ↔ z ∈ y change (x : Class.{u}) z ↔ (y : Class.{u}) z x y : ZFSet h : ↑x = ↑y z : ZFSet ⊢ ↑x z ↔ ↑y z rw [h] ** Qed
Class.toSet_of_ZFSet A : Class x : ZFSet x✝ : ToSet A ↑x y : ZFSet yx : ↑y = ↑x py : A y ⊢ A x rwa [ofSet.inj yx] at py ** Qed
Class.sUnion_apply x : Class y : ZFSet ⊢ (⋃₀ x) y ↔ ∃ z, x z ∧ y ∈ z constructor case mp x : Class y : ZFSet ⊢ (⋃₀ x) y → ∃ z, x z ∧ y ∈ z rintro ⟨-, ⟨z, rfl, hxz⟩, hyz⟩ case mp.intro.intro.intro.intro x : Class y z : ZFSet hxz : x z hyz : y ∈ ↑z ⊢ ∃ z, x z ∧ y ∈ z exact ⟨z, hxz, hyz⟩ case mpr x : Class y : ZFSet ⊢ (∃ z, x z ∧ y ∈ z) → (⋃₀ x) y exact fun ⟨z, hxz, hyz⟩ => ⟨_, coe_mem.2 hxz, hyz⟩ ** Qed
Class.coe_sUnion x y : ZFSet ⊢ (∃ z, ↑x z ∧ y ∈ z) ↔ ∃ z, z ∈ x ∧ y ∈ z rfl ** Qed
Class.mem_sUnion x y : Class ⊢ y ∈ ⋃₀ x ↔ ∃ z, z ∈ x ∧ y ∈ z constructor case mp x y : Class ⊢ y ∈ ⋃₀ x → ∃ z, z ∈ x ∧ y ∈ z rintro ⟨w, rfl, z, hzx, hwz⟩ case mp.intro.intro.intro.intro x : Class w : ZFSet z : Set ZFSet hzx : z ∈ classToCong x hwz : w ∈ z ⊢ ∃ z, z ∈ x ∧ ↑w ∈ z exact ⟨z, hzx, coe_mem.2 hwz⟩ case mpr x y : Class ⊢ (∃ z, z ∈ x ∧ y ∈ z) → y ∈ ⋃₀ x rintro ⟨w, hwx, z, rfl, hwz⟩ case mpr.intro.intro.intro.intro x w : Class hwx : w ∈ x z : ZFSet hwz : w z ⊢ ↑z ∈ ⋃₀ x exact ⟨z, rfl, w, hwx, hwz⟩ ** Qed
Class.sInter_apply x : Class y : ZFSet ⊢ (⋂₀ x) y ↔ ∀ (z : ZFSet), x z → y ∈ z refine' ⟨fun hxy z hxz => hxy _ ⟨z, rfl, hxz⟩, _⟩ x : Class y : ZFSet ⊢ (∀ (z : ZFSet), x z → y ∈ z) → (⋂₀ x) y rintro H - ⟨z, rfl, hxz⟩ case intro.intro x : Class y : ZFSet H : ∀ (z : ZFSet), x z → y ∈ z z : ZFSet hxz : x z ⊢ y ∈ ↑z exact H _ hxz ** Qed
Class.mem_of_mem_sInter x y z : Class hy : y ∈ ⋂₀ x hz : z ∈ x ⊢ y ∈ z obtain ⟨w, rfl, hw⟩ := hy case intro.intro x z : Class hz : z ∈ x w : ZFSet hw : (⋂₀ x) w ⊢ ↑w ∈ z exact coe_mem.2 (hw z hz) ** Qed
Class.mem_sInter x y : Class h : Set.Nonempty x ⊢ y ∈ ⋂₀ x ↔ ∀ (z : Class), z ∈ x → y ∈ z refine' ⟨fun hy z => mem_of_mem_sInter hy, fun H => _⟩ x y : Class h : Set.Nonempty x H : ∀ (z : Class), z ∈ x → y ∈ z ⊢ y ∈ ⋂₀ x simp_rw [mem_def, sInter_apply] x y : Class h : Set.Nonempty x H : ∀ (z : Class), z ∈ x → y ∈ z ⊢ ∃ x_1, ↑x_1 = y ∧ ∀ (z : ZFSet), x z → x_1 ∈ z obtain ⟨z, hz⟩ := h case intro x y : Class H : ∀ (z : Class), z ∈ x → y ∈ z z : ZFSet hz : z ∈ x ⊢ ∃ x_1, ↑x_1 = y ∧ ∀ (z : ZFSet), x z → x_1 ∈ z obtain ⟨y, rfl, _⟩ := H z (coe_mem.2 hz) case intro.intro.intro x : Class z : ZFSet hz : z ∈ x y : ZFSet right✝ : ↑z y H : ∀ (z : Class), z ∈ x → ↑y ∈ z ⊢ ∃ x_1, ↑x_1 = ↑y ∧ ∀ (z : ZFSet), x z → x_1 ∈ z refine' ⟨y, rfl, fun w hxw => _⟩ case intro.intro.intro x : Class z : ZFSet hz : z ∈ x y : ZFSet right✝ : ↑z y H : ∀ (z : Class), z ∈ x → ↑y ∈ z w : ZFSet hxw : x w ⊢ y ∈ w simpa only [coe_mem, coe_apply] using H w (coe_mem.2 hxw) ** Qed
Class.sUnion_empty ⊢ ⋃₀ ∅ = ∅ ext case a z✝ : ZFSet ⊢ (⋃₀ ∅) z✝ ↔ ∅ z✝ simp ** Qed
Class.sInter_empty ⊢ ⋂₀ ∅ = univ rw [sInter, classToCong_empty, Set.sInter_empty, univ] ** Qed
Class.eq_univ_of_powerset_subset A : Class hA : powerset A ⊆ A ⊢ ∀ (x : ZFSet), A x by_contra' hnA A : Class hA : powerset A ⊆ A hnA : ∃ x, ¬A x ⊢ False exact WellFounded.min_mem ZFSet.mem_wf _ hnA (hA fun x hx => Classical.not_not.1 fun hB => WellFounded.not_lt_min ZFSet.mem_wf _ hnA hB <\| coe_apply.1 hx) ** Qed
Class.iota_val A : Class x : ZFSet H : ∀ (y : ZFSet), A y ↔ y = x y : ZFSet x✝ : iota A y x' : ZFSet h : setOf (fun x => ∀ (y : ZFSet), A y ↔ y = x) x' yx' : y ∈ ↑x' ⊢ ↑x y rwa [← (H x').1 <\| (h x').2 rfl] ** Qed
ZFSet.map_fval f : ZFSet → ZFSet H : PSet.Definable 1 f x y : ZFSet h : y ∈ x z : ZFSet ⊢ Class.ToSet (fun x_1 => ↑(map f x) (pair x_1 z)) ↑y ↔ z = f y rw [Class.toSet_of_ZFSet, Class.coe_apply, mem_map] f : ZFSet → ZFSet H : PSet.Definable 1 f x y : ZFSet h : y ∈ x z : ZFSet ⊢ (∃ z_1, z_1 ∈ x ∧ pair z_1 (f z_1) = pair y z) ↔ z = f y exact ⟨fun ⟨w, _, pr⟩ => by let ⟨wy, fw⟩ := ZFSet.pair_injective pr rw [← fw, wy], fun e => by subst e exact ⟨_, h, rfl⟩⟩ f : ZFSet → ZFSet H : PSet.Definable 1 f x y : ZFSet h : y ∈ x z : ZFSet x✝ : ∃ z_1, z_1 ∈ x ∧ pair z_1 (f z_1) = pair y z w : ZFSet left✝ : w ∈ x pr : pair w (f w) = pair y z ⊢ z = f y let ⟨wy, fw⟩ := ZFSet.pair_injective pr f : ZFSet → ZFSet H : PSet.Definable 1 f x y : ZFSet h : y ∈ x z : ZFSet x✝ : ∃ z_1, z_1 ∈ x ∧ pair z_1 (f z_1) = pair y z w : ZFSet left✝ : w ∈ x pr : pair w (f w) = pair y z wy : w = y fw : f w = z ⊢ z = f y rw [← fw, wy] f : ZFSet → ZFSet H : PSet.Definable 1 f x y : ZFSet h : y ∈ x z : ZFSet e : z = f y ⊢ ∃ z_1, z_1 ∈ x ∧ pair z_1 (f z_1) = pair y z subst e f : ZFSet → ZFSet H : PSet.Definable 1 f x y : ZFSet h : y ∈ x ⊢ ∃ z, z ∈ x ∧ pair z (f z) = pair y (f y) exact ⟨_, h, rfl⟩ ** Qed
ZFSet.choice_mem_aux x : ZFSet h : ¬∅ ∈ x y : ZFSet yx : y ∈ x n : ¬∃ y_1, y_1 ∈ y ⊢ ∅ ∈ x rwa [← (eq_empty y).2 fun z zx => n ⟨z, zx⟩] ** Qed
ZFSet.choice_mem x : ZFSet h : ¬∅ ∈ x y : ZFSet yx : y ∈ x ⊢ ↑(choice x) ′ ↑y ∈ ↑y delta choice x : ZFSet h : ¬∅ ∈ x y : ZFSet yx : y ∈ x ⊢ ↑(map (fun y => Classical.epsilon fun z => z ∈ y) x) ′ ↑y ∈ ↑y rw [@map_fval _ (Classical.allDefinable _) x y yx, Class.coe_mem, Class.coe_apply] x : ZFSet h : ¬∅ ∈ x y : ZFSet yx : y ∈ x ⊢ (Classical.epsilon fun z => z ∈ y) ∈ y exact choice_mem_aux x h y yx ** Qed
SetTheory.PGame.turnBound_ne_zero_of_left_move S : Type u inst✝ : State S s t : S m : t ∈ l s ⊢ turnBound s ≠ 0 intro h S : Type u inst✝ : State S s t : S m : t ∈ l s h : turnBound s = 0 ⊢ False have t := left_bound m S : Type u inst✝ : State S s t✝ : S m : t✝ ∈ l s h : turnBound s = 0 t : turnBound t✝ < turnBound s ⊢ False rw [h] at t S : Type u inst✝ : State S s t✝ : S m : t✝ ∈ l s h : turnBound s = 0 t : turnBound t✝ < 0 ⊢ False exact Nat.not_succ_le_zero _ t ** Qed
SetTheory.PGame.turnBound_ne_zero_of_right_move S : Type u inst✝ : State S s t : S m : t ∈ r s ⊢ turnBound s ≠ 0 intro h S : Type u inst✝ : State S s t : S m : t ∈ r s h : turnBound s = 0 ⊢ False have t := right_bound m S : Type u inst✝ : State S s t✝ : S m : t✝ ∈ r s h : turnBound s = 0 t : turnBound t✝ < turnBound s ⊢ False rw [h] at t S : Type u inst✝ : State S s t✝ : S m : t✝ ∈ r s h : turnBound s = 0 t : turnBound t✝ < 0 ⊢ False exact Nat.not_succ_le_zero _ t ** Qed
SetTheory.PGame.wf_isOption x✝ x : PGame IHl : ∀ (i : LeftMoves x), Acc IsOption (moveLeft x i) IHr : ∀ (j : RightMoves x), Acc IsOption (moveRight x j) y : PGame h : IsOption y x ⊢ Acc IsOption y induction' h with _ i _ j case moveLeft x✝¹ x : PGame IHl✝ : ∀ (i : LeftMoves x), Acc IsOption (moveLeft x i) IHr✝ : ∀ (j : RightMoves x), Acc IsOption (moveRight x j) y x✝ : PGame i : LeftMoves x✝ IHl : ∀ (i : LeftMoves x✝), Acc IsOption (moveLeft x✝ i) IHr : ∀ (j : RightMoves x✝), Acc IsOption (moveRight x✝ j) ⊢ Acc IsOption (moveLeft x✝ i) exact IHl i case moveRight x✝¹ x : PGame IHl✝ : ∀ (i : LeftMoves x), Acc IsOption (moveLeft x i) IHr✝ : ∀ (j : RightMoves x), Acc IsOption (moveRight x j) y x✝ : PGame j : RightMoves x✝ IHl : ∀ (i : LeftMoves x✝), Acc IsOption (moveLeft x✝ i) IHr : ∀ (j : RightMoves x✝), Acc IsOption (moveRight x✝ j) ⊢ Acc IsOption (moveRight x✝ j) exact IHr j ** Qed
SetTheory.PGame.Subsequent.mk_right' xl xr : Type u_1 xL : xl → PGame xR : xr → PGame j : RightMoves (mk xl xr xL xR) ⊢ Subsequent (xR j) (mk xl xr xL xR) pgame_wf_tac ** Qed
SetTheory.PGame.Subsequent.moveRight_mk_left xl : Type u_1 i : xl xr : Type u_1 xR : xr → PGame xL : xl → PGame j : RightMoves (xL i) ⊢ Subsequent (PGame.moveRight (xL i) j) (mk xl xr xL xR) pgame_wf_tac ** Qed
SetTheory.PGame.Subsequent.moveRight_mk_right xr : Type u_1 i : xr xl : Type u_1 xL : xl → PGame xR : xr → PGame j : RightMoves (xR i) ⊢ Subsequent (PGame.moveRight (xR i) j) (mk xl xr xL xR) pgame_wf_tac ** Qed
SetTheory.PGame.Subsequent.moveLeft_mk_left xl : Type u_1 i : xl xr : Type u_1 xR : xr → PGame xL : xl → PGame j : LeftMoves (xL i) ⊢ Subsequent (PGame.moveLeft (xL i) j) (mk xl xr xL xR) pgame_wf_tac ** Qed
SetTheory.PGame.Subsequent.moveLeft_mk_right xr : Type u_1 i : xr xl : Type u_1 xL : xl → PGame xR : xr → PGame j : LeftMoves (xR i) ⊢ Subsequent (PGame.moveLeft (xR i) j) (mk xl xr xL xR) pgame_wf_tac ** Qed
SetTheory.PGame.le_iff_forall_lf x y : PGame ⊢ x ≤ y ↔ (∀ (i : LeftMoves x), moveLeft x i ⧏ y) ∧ ∀ (j : RightMoves y), x ⧏ moveRight y j unfold LE.le le x y : PGame ⊢ { le := Sym2.GameAdd.fix wf_isOption fun x y le => (∀ (i : LeftMoves x), ¬le y (moveLeft x i) (_ : Sym2.GameAdd IsOption (Quotient.mk (Sym2.Rel.setoid PGame) (y, moveLeft x i)) (Quotient.mk (Sym2.Rel.setoid PGame) (x, y)))) ∧ ∀ (j : RightMoves y), ¬le (moveRight y j) x (_ : Sym2.GameAdd IsOption (Quotient.mk (Sym2.Rel.setoid PGame) (moveRight y j, x)) (Quotient.mk (Sym2.Rel.setoid PGame) (x, y))) }.1 x y ↔ (∀ (i : LeftMoves x), moveLeft x i ⧏ y) ∧ ∀ (j : RightMoves y), x ⧏ moveRight y j simp only x y : PGame ⊢ Sym2.GameAdd.fix wf_isOption (fun x y le => (∀ (i : LeftMoves x), ¬le y (moveLeft x i) (_ : Sym2.GameAdd IsOption (Quotient.mk (Sym2.Rel.setoid PGame) (y, moveLeft x i)) (Quotient.mk (Sym2.Rel.setoid PGame) (x, y)))) ∧ ∀ (j : RightMoves y), ¬le (moveRight y j) x (_ : Sym2.GameAdd IsOption (Quotient.mk (Sym2.Rel.setoid PGame) (moveRight y j, x)) (Quotient.mk (Sym2.Rel.setoid PGame) (x, y)))) x y ↔ (∀ (i : LeftMoves x), moveLeft x i ⧏ y) ∧ ∀ (j : RightMoves y), x ⧏ moveRight y j rw [Sym2.GameAdd.fix_eq] x y : PGame ⊢ ((∀ (i : LeftMoves x), ¬(fun a' b' x => Sym2.GameAdd.fix wf_isOption (fun x y le => (∀ (i : LeftMoves x), ¬le y (moveLeft x i) (_ : Sym2.GameAdd IsOption (Quotient.mk (Sym2.Rel.setoid PGame) (y, moveLeft x i)) (Quotient.mk (Sym2.Rel.setoid PGame) (x, y)))) ∧ ∀ (j : RightMoves y), ¬le (moveRight y j) x (_ : Sym2.GameAdd IsOption (Quotient.mk (Sym2.Rel.setoid PGame) (moveRight y j, x)) (Quotient.mk (Sym2.Rel.setoid PGame) (x, y)))) a' b') y (moveLeft x i) (_ : Sym2.GameAdd IsOption (Quotient.mk (Sym2.Rel.setoid PGame) (y, moveLeft x i)) (Quotient.mk (Sym2.Rel.setoid PGame) (x, y)))) ∧ ∀ (j : RightMoves y), ¬(fun a' b' x => Sym2.GameAdd.fix wf_isOption (fun x y le => (∀ (i : LeftMoves x), ¬le y (moveLeft x i) (_ : Sym2.GameAdd IsOption (Quotient.mk (Sym2.Rel.setoid PGame) (y, moveLeft x i)) (Quotient.mk (Sym2.Rel.setoid PGame) (x, y)))) ∧ ∀ (j : RightMoves y), ¬le (moveRight y j) x (_ : Sym2.GameAdd IsOption (Quotient.mk (Sym2.Rel.setoid PGame) (moveRight y j, x)) (Quotient.mk (Sym2.Rel.setoid PGame) (x, y)))) a' b') (moveRight y j) x (_ : Sym2.GameAdd IsOption (Quotient.mk (Sym2.Rel.setoid PGame) (moveRight y j, x)) (Quotient.mk (Sym2.Rel.setoid PGame) (x, y)))) ↔ (∀ (i : LeftMoves x), moveLeft x i ⧏ y) ∧ ∀ (j : RightMoves y), x ⧏ moveRight y j rfl ** Qed
SetTheory.PGame.lf_iff_exists_le x y : PGame ⊢ x ⧏ y ↔ (∃ i, x ≤ moveLeft y i) ∨ ∃ j, moveRight x j ≤ y rw [LF, le_iff_forall_lf, not_and_or] x y : PGame ⊢ ((¬∀ (i : LeftMoves y), moveLeft y i ⧏ x) ∨ ¬∀ (j : RightMoves x), y ⧏ moveRight x j) ↔ (∃ i, x ≤ moveLeft y i) ∨ ∃ j, moveRight x j ≤ y simp ** Qed
SetTheory.PGame.le_or_gf x y : PGame ⊢ x ≤ y ∨ y ⧏ x rw [← PGame.not_le] x y : PGame ⊢ x ≤ y ∨ ¬x ≤ y apply em ** Qed
SetTheory.PGame.lf_of_le_of_lf x y z : PGame h₁ : x ≤ y h₂ : y ⧏ z ⊢ x ⧏ z rw [← PGame.not_le] at h₂ ⊢ x y z : PGame h₁ : x ≤ y h₂ : ¬z ≤ y ⊢ ¬z ≤ x exact fun h₃ => h₂ (h₃.trans h₁) ** Qed
SetTheory.PGame.lf_of_lf_of_le x y z : PGame h₁ : x ⧏ y h₂ : y ≤ z ⊢ x ⧏ z rw [← PGame.not_le] at h₁ ⊢ x y z : PGame h₁ : ¬y ≤ x h₂ : y ≤ z ⊢ ¬z ≤ x exact fun h₃ => h₁ (h₂.trans h₃) ** Qed
SetTheory.PGame.le_def x y : PGame ⊢ x ≤ y ↔ (∀ (i : LeftMoves x), (∃ i', moveLeft x i ≤ moveLeft y i') ∨ ∃ j, moveRight (moveLeft x i) j ≤ y) ∧ ∀ (j : RightMoves y), (∃ i, x ≤ moveLeft (moveRight y j) i) ∨ ∃ j', moveRight x j' ≤ moveRight y j rw [le_iff_forall_lf] x y : PGame ⊢ ((∀ (i : LeftMoves x), moveLeft x i ⧏ y) ∧ ∀ (j : RightMoves y), x ⧏ moveRight y j) ↔ (∀ (i : LeftMoves x), (∃ i', moveLeft x i ≤ moveLeft y i') ∨ ∃ j, moveRight (moveLeft x i) j ≤ y) ∧ ∀ (j : RightMoves y), (∃ i, x ≤ moveLeft (moveRight y j) i) ∨ ∃ j', moveRight x j' ≤ moveRight y j conv => lhs simp only [lf_iff_exists_le] ** Qed
SetTheory.PGame.lf_def x y : PGame ⊢ x ⧏ y ↔ (∃ i, (∀ (i' : LeftMoves x), moveLeft x i' ⧏ moveLeft y i) ∧ ∀ (j : RightMoves (moveLeft y i)), x ⧏ moveRight (moveLeft y i) j) ∨ ∃ j, (∀ (i : LeftMoves (moveRight x j)), moveLeft (moveRight x j) i ⧏ y) ∧ ∀ (j' : RightMoves y), moveRight x j ⧏ moveRight y j' rw [lf_iff_exists_le] x y : PGame ⊢ ((∃ i, x ≤ moveLeft y i) ∨ ∃ j, moveRight x j ≤ y) ↔ (∃ i, (∀ (i' : LeftMoves x), moveLeft x i' ⧏ moveLeft y i) ∧ ∀ (j : RightMoves (moveLeft y i)), x ⧏ moveRight (moveLeft y i) j) ∨ ∃ j, (∀ (i : LeftMoves (moveRight x j)), moveLeft (moveRight x j) i ⧏ y) ∧ ∀ (j' : RightMoves y), moveRight x j ⧏ moveRight y j' conv => lhs simp only [le_iff_forall_lf] ** Qed
SetTheory.PGame.zero_le_lf x : PGame ⊢ 0 ≤ x ↔ ∀ (j : RightMoves x), 0 ⧏ moveRight x j rw [le_iff_forall_lf] x : PGame ⊢ ((∀ (i : LeftMoves 0), moveLeft 0 i ⧏ x) ∧ ∀ (j : RightMoves x), 0 ⧏ moveRight x j) ↔ ∀ (j : RightMoves x), 0 ⧏ moveRight x j simp ** Qed
SetTheory.PGame.le_zero_lf x : PGame ⊢ x ≤ 0 ↔ ∀ (i : LeftMoves x), moveLeft x i ⧏ 0 rw [le_iff_forall_lf] x : PGame ⊢ ((∀ (i : LeftMoves x), moveLeft x i ⧏ 0) ∧ ∀ (j : RightMoves 0), x ⧏ moveRight 0 j) ↔ ∀ (i : LeftMoves x), moveLeft x i ⧏ 0 simp ** Qed
SetTheory.PGame.zero_lf_le x : PGame ⊢ 0 ⧏ x ↔ ∃ i, 0 ≤ moveLeft x i rw [lf_iff_exists_le] x : PGame ⊢ ((∃ i, 0 ≤ moveLeft x i) ∨ ∃ j, moveRight 0 j ≤ x) ↔ ∃ i, 0 ≤ moveLeft x i simp ** Qed
SetTheory.PGame.lf_zero_le x : PGame ⊢ x ⧏ 0 ↔ ∃ j, moveRight x j ≤ 0 rw [lf_iff_exists_le] x : PGame ⊢ ((∃ i, x ≤ moveLeft 0 i) ∨ ∃ j, moveRight x j ≤ 0) ↔ ∃ j, moveRight x j ≤ 0 simp ** Qed
SetTheory.PGame.zero_le x : PGame ⊢ 0 ≤ x ↔ ∀ (j : RightMoves x), ∃ i, 0 ≤ moveLeft (moveRight x j) i rw [le_def] x : PGame ⊢ ((∀ (i : LeftMoves 0), (∃ i', moveLeft 0 i ≤ moveLeft x i') ∨ ∃ j, moveRight (moveLeft 0 i) j ≤ x) ∧ ∀ (j : RightMoves x), (∃ i, 0 ≤ moveLeft (moveRight x j) i) ∨ ∃ j', moveRight 0 j' ≤ moveRight x j) ↔ ∀ (j : RightMoves x), ∃ i, 0 ≤ moveLeft (moveRight x j) i simp ** Qed
SetTheory.PGame.le_zero x : PGame ⊢ x ≤ 0 ↔ ∀ (i : LeftMoves x), ∃ j, moveRight (moveLeft x i) j ≤ 0 rw [le_def] x : PGame ⊢ ((∀ (i : LeftMoves x), (∃ i', moveLeft x i ≤ moveLeft 0 i') ∨ ∃ j, moveRight (moveLeft x i) j ≤ 0) ∧ ∀ (j : RightMoves 0), (∃ i, x ≤ moveLeft (moveRight 0 j) i) ∨ ∃ j', moveRight x j' ≤ moveRight 0 j) ↔ ∀ (i : LeftMoves x), ∃ j, moveRight (moveLeft x i) j ≤ 0 simp ** Qed
SetTheory.PGame.zero_lf x : PGame ⊢ 0 ⧏ x ↔ ∃ i, ∀ (j : RightMoves (moveLeft x i)), 0 ⧏ moveRight (moveLeft x i) j rw [lf_def] x : PGame ⊢ ((∃ i, (∀ (i' : LeftMoves 0), moveLeft 0 i' ⧏ moveLeft x i) ∧ ∀ (j : RightMoves (moveLeft x i)), 0 ⧏ moveRight (moveLeft x i) j) ∨ ∃ j, (∀ (i : LeftMoves (moveRight 0 j)), moveLeft (moveRight 0 j) i ⧏ x) ∧ ∀ (j' : RightMoves x), moveRight 0 j ⧏ moveRight x j') ↔ ∃ i, ∀ (j : RightMoves (moveLeft x i)), 0 ⧏ moveRight (moveLeft x i) j simp ** Qed
SetTheory.PGame.lf_zero x : PGame ⊢ x ⧏ 0 ↔ ∃ j, ∀ (i : LeftMoves (moveRight x j)), moveLeft (moveRight x j) i ⧏ 0 rw [lf_def] x : PGame ⊢ ((∃ i, (∀ (i' : LeftMoves x), moveLeft x i' ⧏ moveLeft 0 i) ∧ ∀ (j : RightMoves (moveLeft 0 i)), x ⧏ moveRight (moveLeft 0 i) j) ∨ ∃ j, (∀ (i : LeftMoves (moveRight x j)), moveLeft (moveRight x j) i ⧏ 0) ∧ ∀ (j' : RightMoves 0), moveRight x j ⧏ moveRight 0 j') ↔ ∃ j, ∀ (i : LeftMoves (moveRight x j)), moveLeft (moveRight x j) i ⧏ 0 simp ** Qed
SetTheory.PGame.equiv_of_eq x y : PGame h : x = y ⊢ x ≈ y subst h x : PGame ⊢ x ≈ x rfl ** Qed
SetTheory.PGame.lf_or_equiv_or_gf x y : PGame ⊢ x ⧏ y ∨ x ≈ y ∨ y ⧏ x by_cases h : x ⧏ y case pos x y : PGame h : x ⧏ y ⊢ x ⧏ y ∨ x ≈ y ∨ y ⧏ x exact Or.inl h case neg x y : PGame h : ¬x ⧏ y ⊢ x ⧏ y ∨ x ≈ y ∨ y ⧏ x right case neg.h x y : PGame h : ¬x ⧏ y ⊢ x ≈ y ∨ y ⧏ x cases' lt_or_equiv_of_le (PGame.not_lf.1 h) with h' h' case neg.h.inl x y : PGame h : ¬x ⧏ y h' : y < x ⊢ x ≈ y ∨ y ⧏ x exact Or.inr h'.lf case neg.h.inr x y : PGame h : ¬x ⧏ y h' : y ≈ x ⊢ x ≈ y ∨ y ⧏ x exact Or.inl (Equiv.symm h') ** Qed
SetTheory.PGame.equiv_of_mk_equiv x y : PGame L : LeftMoves x ≃ LeftMoves y R : RightMoves x ≃ RightMoves y hl : ∀ (i : LeftMoves x), moveLeft x i ≈ moveLeft y (↑L i) hr : ∀ (j : RightMoves x), moveRight x j ≈ moveRight y (↑R j) ⊢ x ≈ y constructor <;> rw [le_def] case left x y : PGame L : LeftMoves x ≃ LeftMoves y R : RightMoves x ≃ RightMoves y hl : ∀ (i : LeftMoves x), moveLeft x i ≈ moveLeft y (↑L i) hr : ∀ (j : RightMoves x), moveRight x j ≈ moveRight y (↑R j) ⊢ (∀ (i : LeftMoves x), (∃ i', moveLeft x i ≤ moveLeft y i') ∨ ∃ j, moveRight (moveLeft x i) j ≤ y) ∧ ∀ (j : RightMoves y), (∃ i, x ≤ moveLeft (moveRight y j) i) ∨ ∃ j', moveRight x j' ≤ moveRight y j exact ⟨fun i => Or.inl ⟨_, (hl i).1⟩, fun j => Or.inr ⟨_, by simpa using (hr (R.symm j)).1⟩⟩ x y : PGame L : LeftMoves x ≃ LeftMoves y R : RightMoves x ≃ RightMoves y hl : ∀ (i : LeftMoves x), moveLeft x i ≈ moveLeft y (↑L i) hr : ∀ (j : RightMoves x), moveRight x j ≈ moveRight y (↑R j) j : RightMoves y ⊢ moveRight x (?m.65566 j) ≤ moveRight y j simpa using (hr (R.symm j)).1 case right x y : PGame L : LeftMoves x ≃ LeftMoves y R : RightMoves x ≃ RightMoves y hl : ∀ (i : LeftMoves x), moveLeft x i ≈ moveLeft y (↑L i) hr : ∀ (j : RightMoves x), moveRight x j ≈ moveRight y (↑R j) ⊢ (∀ (i : LeftMoves y), (∃ i', moveLeft y i ≤ moveLeft x i') ∨ ∃ j, moveRight (moveLeft y i) j ≤ x) ∧ ∀ (j : RightMoves x), (∃ i, y ≤ moveLeft (moveRight x j) i) ∨ ∃ j', moveRight y j' ≤ moveRight x j exact ⟨fun i => Or.inl ⟨_, by simpa using (hl (L.symm i)).2⟩, fun j => Or.inr ⟨_, (hr j).2⟩⟩ x y : PGame L : LeftMoves x ≃ LeftMoves y R : RightMoves x ≃ RightMoves y hl : ∀ (i : LeftMoves x), moveLeft x i ≈ moveLeft y (↑L i) hr : ∀ (j : RightMoves x), moveRight x j ≈ moveRight y (↑R j) i : LeftMoves y ⊢ moveLeft y i ≤ moveLeft x (?m.66250 i) simpa using (hl (L.symm i)).2 ** Qed
SetTheory.PGame.lf_iff_lt_or_fuzzy x y : PGame ⊢ x ⧏ y ↔ x < y ∨ x ‖ y simp only [lt_iff_le_and_lf, Fuzzy, ← PGame.not_le] x y : PGame ⊢ ¬y ≤ x ↔ x ≤ y ∧ ¬y ≤ x ∨ ¬y ≤ x ∧ ¬x ≤ y tauto ** Qed
SetTheory.PGame.fuzzy_congr x₁ y₁ x₂ y₂ : PGame hx : x₁ ≈ x₂ hy : y₁ ≈ y₂ ⊢ x₁ ⧏ y₁ ∧ y₁ ⧏ x₁ ↔ x₂ ⧏ y₂ ∧ y₂ ⧏ x₂ rw [lf_congr hx hy, lf_congr hy hx] ** Qed
SetTheory.PGame.lt_or_equiv_or_gt_or_fuzzy x y : PGame ⊢ x < y ∨ x ≈ y ∨ y < x ∨ x ‖ y cases' le_or_gf x y with h₁ h₁ <;> cases' le_or_gf y x with h₂ h₂ case inl.inl x y : PGame h₁ : x ≤ y h₂ : y ≤ x ⊢ x < y ∨ x ≈ y ∨ y < x ∨ x ‖ y right case inl.inl.h x y : PGame h₁ : x ≤ y h₂ : y ≤ x ⊢ x ≈ y ∨ y < x ∨ x ‖ y left case inl.inl.h.h x y : PGame h₁ : x ≤ y h₂ : y ≤ x ⊢ x ≈ y exact ⟨h₁, h₂⟩ case inl.inr x y : PGame h₁ : x ≤ y h₂ : x ⧏ y ⊢ x < y ∨ x ≈ y ∨ y < x ∨ x ‖ y left case inl.inr.h x y : PGame h₁ : x ≤ y h₂ : x ⧏ y ⊢ x < y exact ⟨h₁, h₂⟩ case inr.inl x y : PGame h₁ : y ⧏ x h₂ : y ≤ x ⊢ x < y ∨ x ≈ y ∨ y < x ∨ x ‖ y right case inr.inl.h x y : PGame h₁ : y ⧏ x h₂ : y ≤ x ⊢ x ≈ y ∨ y < x ∨ x ‖ y right case inr.inl.h.h x y : PGame h₁ : y ⧏ x h₂ : y ≤ x ⊢ y < x ∨ x ‖ y left case inr.inl.h.h.h x y : PGame h₁ : y ⧏ x h₂ : y ≤ x ⊢ y < x exact ⟨h₂, h₁⟩ case inr.inr x y : PGame h₁ : y ⧏ x h₂ : x ⧏ y ⊢ x < y ∨ x ≈ y ∨ y < x ∨ x ‖ y right case inr.inr.h x y : PGame h₁ : y ⧏ x h₂ : x ⧏ y ⊢ x ≈ y ∨ y < x ∨ x ‖ y right case inr.inr.h.h x y : PGame h₁ : y ⧏ x h₂ : x ⧏ y ⊢ y < x ∨ x ‖ y right case inr.inr.h.h.h x y : PGame h₁ : y ⧏ x h₂ : x ⧏ y ⊢ x ‖ y exact ⟨h₂, h₁⟩ ** Qed
SetTheory.PGame.lt_or_equiv_or_gf x y : PGame ⊢ x < y ∨ x ≈ y ∨ y ⧏ x rw [lf_iff_lt_or_fuzzy, Fuzzy.swap_iff] x y : PGame ⊢ x < y ∨ x ≈ y ∨ y < x ∨ x ‖ y exact lt_or_equiv_or_gt_or_fuzzy x y ** Qed
SetTheory.PGame.relabel_moveLeft x : PGame xl' xr' : Type u_1 el : xl' ≃ LeftMoves x er : xr' ≃ RightMoves x i : LeftMoves x ⊢ moveLeft (relabel el er) (↑el.symm i) = moveLeft x i simp ** Qed
SetTheory.PGame.relabel_moveRight x : PGame xl' xr' : Type u_1 el : xl' ≃ LeftMoves x er : xr' ≃ RightMoves x j : RightMoves x ⊢ moveRight (relabel el er) (↑er.symm j) = moveRight x j simp ** Qed
SetTheory.PGame.neg_ofLists L R : List PGame ⊢ -ofLists L R = ofLists (List.map (fun x => -x) R) (List.map (fun x => -x) L) simp only [ofLists, neg_def, List.length_map, List.nthLe_map', eq_self_iff_true, true_and, mk.injEq] L R : List PGame ⊢ (HEq (fun j => -List.nthLe R ↑j.down (_ : ↑j.down < List.length R)) fun i => -List.nthLe R ↑i.down (_ : ↑i.down < List.length R)) ∧ HEq (fun i => -List.nthLe L ↑i.down (_ : ↑i.down < List.length L)) fun j => -List.nthLe L ↑j.down (_ : ↑j.down < List.length L) constructor case right L R : List PGame ⊢ HEq (fun i => -List.nthLe L ↑i.down (_ : ↑i.down < List.length L)) fun j => -List.nthLe L ↑j.down (_ : ↑j.down < List.length L) apply hfunext case right.hα L R : List PGame ⊢ ULift.{u_1, 0} (Fin (List.length L)) = ULift.{u_1, 0} (Fin (List.length (List.map (fun x => -x) L))) simp case right.h L R : List PGame ⊢ ∀ (a : ULift.{u_1, 0} (Fin (List.length L))) (a' : ULift.{u_1, 0} (Fin (List.length (List.map (fun x => -x) L)))), HEq a a' → HEq (-List.nthLe L ↑a.down (_ : ↑a.down < List.length L)) (-List.nthLe L ↑a'.down (_ : ↑a'.down < List.length L)) intro a a' ha case right.h L R : List PGame a : ULift.{u_1, 0} (Fin (List.length L)) a' : ULift.{u_1, 0} (Fin (List.length (List.map (fun x => -x) L))) ha : HEq a a' ⊢ HEq (-List.nthLe L ↑a.down (_ : ↑a.down < List.length L)) (-List.nthLe L ↑a'.down (_ : ↑a'.down < List.length L)) congr 2 case right.h.h.e_a.e_n L R : List PGame a : ULift.{u_1, 0} (Fin (List.length L)) a' : ULift.{u_1, 0} (Fin (List.length (List.map (fun x => -x) L))) ha : HEq a a' ⊢ ↑a.down = ↑a'.down have : ∀ {m n} (_ : m = n) {b : ULift (Fin m)} {c : ULift (Fin n)} (_ : HEq b c), (b.down : ℕ) = ↑c.down := by rintro m n rfl b c simp only [heq_eq_eq] rintro rfl rfl case right.h.h.e_a.e_n L R : List PGame a : ULift.{u_1, 0} (Fin (List.length L)) a' : ULift.{u_1, 0} (Fin (List.length (List.map (fun x => -x) L))) ha : HEq a a' this : ∀ {m n : ℕ}, m = n → ∀ {b : ULift.{?u.106967, 0} (Fin m)} {c : ULift.{?u.106967, 0} (Fin n)}, HEq b c → ↑b.down = ↑c.down ⊢ ↑a.down = ↑a'.down exact this (List.length_map _ _).symm ha L R : List PGame a : ULift.{u_1, 0} (Fin (List.length L)) a' : ULift.{u_1, 0} (Fin (List.length (List.map (fun x => -x) L))) ha : HEq a a' ⊢ ∀ {m n : ℕ}, m = n → ∀ {b : ULift.{?u.106967, 0} (Fin m)} {c : ULift.{?u.106967, 0} (Fin n)}, HEq b c → ↑b.down = ↑c.down rintro m n rfl b c L R : List PGame a : ULift.{u_1, 0} (Fin (List.length L)) a' : ULift.{u_1, 0} (Fin (List.length (List.map (fun x => -x) L))) ha : HEq a a' m : ℕ b c : ULift.{?u.106967, 0} (Fin m) ⊢ HEq b c → ↑b.down = ↑c.down simp only [heq_eq_eq] L R : List PGame a : ULift.{u_1, 0} (Fin (List.length L)) a' : ULift.{u_1, 0} (Fin (List.length (List.map (fun x => -x) L))) ha : HEq a a' m : ℕ b c : ULift.{?u.106967, 0} (Fin m) ⊢ b = c → ↑b.down = ↑c.down rintro rfl L R : List PGame a : ULift.{u_1, 0} (Fin (List.length L)) a' : ULift.{u_1, 0} (Fin (List.length (List.map (fun x => -x) L))) ha : HEq a a' m : ℕ b : ULift.{?u.106967, 0} (Fin m) ⊢ ↑b.down = ↑b.down rfl ** Qed
SetTheory.PGame.isOption_neg x y : PGame ⊢ IsOption x (-y) ↔ IsOption (-x) y rw [IsOption_iff, IsOption_iff, or_comm] x y : PGame ⊢ ((∃ i, x = moveRight (-y) i) ∨ ∃ i, x = moveLeft (-y) i) ↔ (∃ i, -x = moveLeft y i) ∨ ∃ i, -x = moveRight y i cases y case mk.h₂ x : PGame α✝ β✝ : Type u_1 a✝¹ : α✝ → PGame a✝ : β✝ → PGame ⊢ (∃ i, x = moveLeft (-mk α✝ β✝ a✝¹ a✝) i) ↔ ∃ i, -x = moveRight (mk α✝ β✝ a✝¹ a✝) i apply exists_congr case mk.h₂.h x : PGame α✝ β✝ : Type u_1 a✝¹ : α✝ → PGame a✝ : β✝ → PGame ⊢ ∀ (a : LeftMoves (-mk α✝ β✝ a✝¹ a✝)), x = moveLeft (-mk α✝ β✝ a✝¹ a✝) a ↔ -x = moveRight (mk α✝ β✝ a✝¹ a✝) a intro case mk.h₂.h x : PGame α✝ β✝ : Type u_1 a✝² : α✝ → PGame a✝¹ : β✝ → PGame a✝ : LeftMoves (-mk α✝ β✝ a✝² a✝¹) ⊢ x = moveLeft (-mk α✝ β✝ a✝² a✝¹) a✝ ↔ -x = moveRight (mk α✝ β✝ a✝² a✝¹) a✝ rw [neg_eq_iff_eq_neg] case mk.h₂.h x : PGame α✝ β✝ : Type u_1 a✝² : α✝ → PGame a✝¹ : β✝ → PGame a✝ : LeftMoves (-mk α✝ β✝ a✝² a✝¹) ⊢ x = moveLeft (-mk α✝ β✝ a✝² a✝¹) a✝ ↔ x = -moveRight (mk α✝ β✝ a✝² a✝¹) a✝ rfl ** Qed
SetTheory.PGame.isOption_neg_neg x y : PGame ⊢ IsOption (-x) (-y) ↔ IsOption x y rw [isOption_neg, neg_neg] ** Qed