ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
-- SetTheory.PGame.Domineering.shiftUp_symm_apply
@[simps!]
def shiftUp : ℤ × ℤ ≃ ℤ × ℤ 
Goal: ∀ (a : ℤ × ℤ), SetTheory.PGame.Domineering.shiftUp.symm a = Prod.map id (fun x => x + -1) a
-- SetTheory.PGame.Domineering.shiftRight_symm_apply
@[simps!]
def shiftRight : ℤ × ℤ ≃ ℤ × ℤ 
Goal: ∀ (a : ℤ × ℤ), SetTheory.PGame.Domineering.shiftRight.symm a = Prod.map (fun x => x + -1) id a
-- SetTheory.PGame.Domineering.shiftRight_apply
@[simps!]
def shiftRight : ℤ × ℤ ≃ ℤ × ℤ 
Goal: ∀ (a : ℤ × ℤ), SetTheory.PGame.Domineering.shiftRight a = Prod.map (fun x => x + 1) id a
-- SetTheory.PGame.Domineering.mem_left
theorem mem_left {b : Board} (x : ℤ × ℤ) : x ∈ left b ↔ x ∈ b ∧ (x.1, x.2 - 1) ∈ b 
Arguments: {b : SetTheory.PGame.Domineering.Board} (x : ℤ × ℤ)
Goal: x ∈ SetTheory.PGame.Domineering.left b ↔ x ∈ b ∧ (x.1, x.2 - 1) ∈ b
-- SetTheory.PGame.Domineering.mem_right
theorem mem_right {b : Board} (x : ℤ × ℤ) : x ∈ right b ↔ x ∈ b ∧ (x.1 - 1, x.2) ∈ b 
Arguments: {b : SetTheory.PGame.Domineering.Board} (x : ℤ × ℤ)
Goal: x ∈ SetTheory.PGame.Domineering.right b ↔ x ∈ b ∧ (x.1 - 1, x.2) ∈ b
-- SetTheory.PGame.Domineering.fst_pred_mem_erase_of_mem_right
theorem fst_pred_mem_erase_of_mem_right {b : Board} {m : ℤ × ℤ} (h : m ∈ right b) :
    (m.1 - 1, m.2) ∈ b.erase m 
Arguments: {b : SetTheory.PGame.Domineering.Board} {m : ℤ × ℤ} (h : m ∈ SetTheory.PGame.Domineering.right b)
Goal: (m.1 - 1, m.2) ∈ Finset.erase b m
-- SetTheory.PGame.Domineering.snd_pred_mem_erase_of_mem_left
theorem snd_pred_mem_erase_of_mem_left {b : Board} {m : ℤ × ℤ} (h : m ∈ left b) :
    (m.1, m.2 - 1) ∈ b.erase m 
Arguments: {b : SetTheory.PGame.Domineering.Board} {m : ℤ × ℤ} (h : m ∈ SetTheory.PGame.Domineering.left b)
Goal: (m.1, m.2 - 1) ∈ Finset.erase b m
-- SetTheory.PGame.Domineering.card_of_mem_left
theorem card_of_mem_left {b : Board} {m : ℤ × ℤ} (h : m ∈ left b) : 2 ≤ Finset.card b 
Arguments: {b : SetTheory.PGame.Domineering.Board} {m : ℤ × ℤ} (h : m ∈ SetTheory.PGame.Domineering.left b)
Goal: 2 ≤ Finset.card b
-- SetTheory.PGame.Domineering.card_of_mem_right
theorem card_of_mem_right {b : Board} {m : ℤ × ℤ} (h : m ∈ right b) : 2 ≤ Finset.card b 
Arguments: {b : SetTheory.PGame.Domineering.Board} {m : ℤ × ℤ} (h : m ∈ SetTheory.PGame.Domineering.right b)
Goal: 2 ≤ Finset.card b
-- SetTheory.PGame.Domineering.moveLeft_card
theorem moveLeft_card {b : Board} {m : ℤ × ℤ} (h : m ∈ left b) :
    Finset.card (moveLeft b m) + 2 = Finset.card b 
Arguments: {b : SetTheory.PGame.Domineering.Board} {m : ℤ × ℤ} (h : m ∈ SetTheory.PGame.Domineering.left b)
Goal: Finset.card (SetTheory.PGame.Domineering.moveLeft b m) + 2 = Finset.card b
-- SetTheory.PGame.Domineering.moveRight_card
theorem moveRight_card {b : Board} {m : ℤ × ℤ} (h : m ∈ right b) :
    Finset.card (moveRight b m) + 2 = Finset.card b 
Arguments: {b : SetTheory.PGame.Domineering.Board} {m : ℤ × ℤ} (h : m ∈ SetTheory.PGame.Domineering.right b)
Goal: Finset.card (SetTheory.PGame.Domineering.moveRight b m) + 2 = Finset.card b
-- SetTheory.PGame.Domineering.moveLeft_smaller
theorem moveLeft_smaller {b : Board} {m : ℤ × ℤ} (h : m ∈ left b) :
    Finset.card (moveLeft b m) / 2 < Finset.card b / 2 
Arguments: {b : SetTheory.PGame.Domineering.Board} {m : ℤ × ℤ} (h : m ∈ SetTheory.PGame.Domineering.left b)
Goal: Finset.card (SetTheory.PGame.Domineering.moveLeft b m) / 2 < Finset.card b / 2
-- SetTheory.PGame.Domineering.moveRight_smaller
theorem moveRight_smaller {b : Board} {m : ℤ × ℤ} (h : m ∈ right b) :
    Finset.card (moveRight b m) / 2 < Finset.card b / 2 
Arguments: {b : SetTheory.PGame.Domineering.Board} {m : ℤ × ℤ} (h : m ∈ SetTheory.PGame.Domineering.right b)
Goal: Finset.card (SetTheory.PGame.Domineering.moveRight b m) / 2 < Finset.card b / 2
-- Cardinal.ofENat_top
@[simp, norm_cast] lemma ofENat_top : ofENat ⊤ = ℵ₀ 
Goal: ↑⊤ = Cardinal.aleph0
-- Cardinal.ofENat_nat
@[simp, norm_cast] lemma ofENat_nat (n : ℕ) : ofENat n = n 
Arguments: (n : ℕ)
Goal: ↑↑n = ↑n
-- Cardinal.ofENat_zero
@[simp, norm_cast] lemma ofENat_zero : ofENat 0 = 0 
Goal: ↑0 = 0
-- Cardinal.ofENat_one
@[simp, norm_cast] lemma ofENat_one : ofENat 1 = 1 
Goal: ↑1 = 1
-- Cardinal.ofENat_ofNat
@[simp, norm_cast] lemma ofENat_ofNat (n : ℕ) [n.AtLeastTwo] :
    ((no_index (OfNat.ofNat n : ℕ∞)) : Cardinal) = OfNat.ofNat n 
Arguments: (n : ℕ) [n.AtLeastTwo]
Goal: ↑(OfNat.ofNat n) = OfNat.ofNat n
-- Cardinal.ofENat_strictMono
lemma ofENat_strictMono : StrictMono ofENat 
Goal: StrictMono Cardinal.ofENat
-- Cardinal.ofENat_lt_ofENat
@[simp, norm_cast]
lemma ofENat_lt_ofENat {m n : ℕ∞} : (m : Cardinal) < n ↔ m < n 
Arguments: {m n : ℕ∞}
Goal: ↑m < ↑n ↔ m < n
-- Cardinal.ofENat_lt_aleph0
@[simp, norm_cast]
lemma ofENat_lt_aleph0 {m : ℕ∞} : (m : Cardinal) < ℵ₀ ↔ m < ⊤ 
Arguments: {m : ℕ∞}
Goal: ↑m < Cardinal.aleph0 ↔ m < ⊤
-- Cardinal.ofENat_lt_nat
@[simp] lemma ofENat_lt_nat {m : ℕ∞} {n : ℕ} : ofENat m < n ↔ m < n 
Arguments: {m : ℕ∞} {n : ℕ}
Goal: ↑m < ↑n ↔ m < ↑n
-- Cardinal.ofENat_lt_ofNat
@[simp] lemma ofENat_lt_ofNat {m : ℕ∞} {n : ℕ} [n.AtLeastTwo] :
    ofENat m < no_index (OfNat.ofNat n) ↔ m < OfNat.ofNat n 
Arguments: {m : ℕ∞} {n : ℕ} [n.AtLeastTwo]
Goal: ↑m < OfNat.ofNat n ↔ m < OfNat.ofNat n
-- Cardinal.nat_lt_ofENat
@[simp] lemma nat_lt_ofENat {m : ℕ} {n : ℕ∞} : (m : Cardinal) < n ↔ m < n 
Arguments: {m : ℕ} {n : ℕ∞}
Goal: ↑m < ↑n ↔ ↑m < n
-- Cardinal.ofENat_pos
@[simp] lemma ofENat_pos {m : ℕ∞} : 0 < (m : Cardinal) ↔ 0 < m 
Arguments: {m : ℕ∞}
Goal: 0 < ↑m ↔ 0 < m
-- Cardinal.one_lt_ofENat
@[simp] lemma one_lt_ofENat {m : ℕ∞} : 1 < (m : Cardinal) ↔ 1 < m 
Arguments: {m : ℕ∞}
Goal: 1 < ↑m ↔ 1 < m
-- Cardinal.ofNat_lt_ofENat
@[simp, norm_cast] lemma ofNat_lt_ofENat {m : ℕ} [m.AtLeastTwo] {n : ℕ∞} :
  no_index (OfNat.ofNat m : Cardinal) < n ↔ OfNat.ofNat m < n 
Arguments: {m : ℕ} [m.AtLeastTwo] {n : ℕ∞}
Goal: OfNat.ofNat m < ↑n ↔ OfNat.ofNat m < n
-- Cardinal.ofENat_mono
lemma ofENat_mono : Monotone ofENat 
Goal: Monotone Cardinal.ofENat
-- Cardinal.ofENat_le_ofENat
@[simp, norm_cast]
lemma ofENat_le_ofENat {m n : ℕ∞} : (m : Cardinal) ≤ n ↔ m ≤ n 
Arguments: {m n : ℕ∞}
Goal: ↑m ≤ ↑n ↔ m ≤ n
-- Cardinal.ofENat_le_aleph0
@[simp] lemma ofENat_le_aleph0 (n : ℕ∞) : ↑n ≤ ℵ₀ 
Arguments: (n : ℕ∞)
Goal: ↑n ≤ Cardinal.aleph0
-- Cardinal.ofENat_le_nat
@[simp] lemma ofENat_le_nat {m : ℕ∞} {n : ℕ} : ofENat m ≤ n ↔ m ≤ n 
Arguments: {m : ℕ∞} {n : ℕ}
Goal: ↑m ≤ ↑n ↔ m ≤ ↑n
-- Cardinal.ofENat_le_one
@[simp] lemma ofENat_le_one {m : ℕ∞} : ofENat m ≤ 1 ↔ m ≤ 1 
Arguments: {m : ℕ∞}
Goal: ↑m ≤ 1 ↔ m ≤ 1
-- Cardinal.ofENat_le_ofNat
@[simp] lemma ofENat_le_ofNat {m : ℕ∞} {n : ℕ} [n.AtLeastTwo] :
    ofENat m ≤ no_index (OfNat.ofNat n) ↔ m ≤ OfNat.ofNat n 
Arguments: {m : ℕ∞} {n : ℕ} [n.AtLeastTwo]
Goal: ↑m ≤ OfNat.ofNat n ↔ m ≤ OfNat.ofNat n
-- Cardinal.nat_le_ofENat
@[simp] lemma nat_le_ofENat {m : ℕ} {n : ℕ∞} : (m : Cardinal) ≤ n ↔ m ≤ n 
Arguments: {m : ℕ} {n : ℕ∞}
Goal: ↑m ≤ ↑n ↔ ↑m ≤ n
-- Cardinal.one_le_ofENat
@[simp] lemma one_le_ofENat {n : ℕ∞} : 1 ≤ (n : Cardinal) ↔ 1 ≤ n 
Arguments: {n : ℕ∞}
Goal: 1 ≤ ↑n ↔ 1 ≤ n
-- Cardinal.ofNat_le_ofENat
@[simp]
lemma ofNat_le_ofENat {m : ℕ} [m.AtLeastTwo] {n : ℕ∞} :
    no_index (OfNat.ofNat m : Cardinal) ≤ n ↔ OfNat.ofNat m ≤ n 
Arguments: {m : ℕ} [m.AtLeastTwo] {n : ℕ∞}
Goal: OfNat.ofNat m ≤ ↑n ↔ OfNat.ofNat m ≤ n
-- Cardinal.ofENat_injective
lemma ofENat_injective : Injective ofENat 
Goal: Function.Injective Cardinal.ofENat
-- Cardinal.ofENat_inj
@[simp, norm_cast]
lemma ofENat_inj {m n : ℕ∞} : (m : Cardinal) = n ↔ m = n 
Arguments: {m n : ℕ∞}
Goal: ↑m = ↑n ↔ m = n
-- Cardinal.ofENat_eq_nat
@[simp] lemma ofENat_eq_nat {m : ℕ∞} {n : ℕ} : (m : Cardinal) = n ↔ m = n 
Arguments: {m : ℕ∞} {n : ℕ}
Goal: ↑m = ↑n ↔ m = ↑n
-- Cardinal.nat_eq_ofENat
@[simp] lemma nat_eq_ofENat {m : ℕ} {n : ℕ∞} : (m : Cardinal) = n ↔ m = n 
Arguments: {m : ℕ} {n : ℕ∞}
Goal: ↑m = ↑n ↔ ↑m = n
-- Cardinal.ofENat_eq_zero
@[simp] lemma ofENat_eq_zero {m : ℕ∞} : (m : Cardinal) = 0 ↔ m = 0 
Arguments: {m : ℕ∞}
Goal: ↑m = 0 ↔ m = 0
-- Cardinal.zero_eq_ofENat
@[simp] lemma zero_eq_ofENat {m : ℕ∞} : 0 = (m : Cardinal) ↔ m = 0 
Arguments: {m : ℕ∞}
Goal: 0 = ↑m ↔ m = 0
-- Cardinal.ofENat_eq_one
@[simp] lemma ofENat_eq_one {m : ℕ∞} : (m : Cardinal) = 1 ↔ m = 1 
Arguments: {m : ℕ∞}
Goal: ↑m = 1 ↔ m = 1
-- Cardinal.one_eq_ofENat
@[simp] lemma one_eq_ofENat {m : ℕ∞} : 1 = (m : Cardinal) ↔ m = 1 
Arguments: {m : ℕ∞}
Goal: 1 = ↑m ↔ m = 1
-- Cardinal.ofENat_eq_ofNat
@[simp] lemma ofENat_eq_ofNat {m : ℕ∞} {n : ℕ} [n.AtLeastTwo] :
    (m : Cardinal) = no_index (OfNat.ofNat n) ↔ m = OfNat.ofNat n 
Arguments: {m : ℕ∞} {n : ℕ} [n.AtLeastTwo]
Goal: ↑m = OfNat.ofNat n ↔ m = OfNat.ofNat n
-- Cardinal.ofNat_eq_ofENat
@[simp] lemma ofNat_eq_ofENat {m : ℕ} {n : ℕ∞} [m.AtLeastTwo] :
    no_index (OfNat.ofNat m) = (n : Cardinal) ↔ OfNat.ofNat m = n 
Arguments: {m : ℕ} {n : ℕ∞} [m.AtLeastTwo]
Goal: OfNat.ofNat m = ↑n ↔ OfNat.ofNat m = n
-- Cardinal.lift_ofENat
@[simp, norm_cast] lemma lift_ofENat : ∀ m : ℕ∞, lift.{u, v} m = m
  
Arguments: (m : ℕ∞)
Goal: Cardinal.lift.{u, v} ↑m = ↑m
-- Cardinal.lift_lt_ofENat
@[simp] lemma lift_lt_ofENat {x : Cardinal.{v}} {m : ℕ∞} : lift.{u} x < m ↔ x < m 
Arguments: {x : Cardinal.{v}} {m : ℕ∞}
Goal: Cardinal.lift.{u, v} x < ↑m ↔ x < ↑m
-- Cardinal.lift_le_ofENat
@[simp] lemma lift_le_ofENat {x : Cardinal.{v}} {m : ℕ∞} : lift.{u} x ≤ m ↔ x ≤ m 
Arguments: {x : Cardinal.{v}} {m : ℕ∞}
Goal: Cardinal.lift.{u, v} x ≤ ↑m ↔ x ≤ ↑m
-- Cardinal.lift_eq_ofENat
@[simp] lemma lift_eq_ofENat {x : Cardinal.{v}} {m : ℕ∞} : lift.{u} x = m ↔ x = m 
Arguments: {x : Cardinal.{v}} {m : ℕ∞}
Goal: Cardinal.lift.{u, v} x = ↑m ↔ x = ↑m
-- Cardinal.ofENat_lt_lift
@[simp] lemma ofENat_lt_lift {x : Cardinal.{v}} {m : ℕ∞} : m < lift.{u} x ↔ m < x 
Arguments: {x : Cardinal.{v}} {m : ℕ∞}
Goal: ↑m < Cardinal.lift.{u, v} x ↔ ↑m < x
-- Cardinal.ofENat_le_lift
@[simp] lemma ofENat_le_lift {x : Cardinal.{v}} {m : ℕ∞} : m ≤ lift.{u} x ↔ m ≤ x 
Arguments: {x : Cardinal.{v}} {m : ℕ∞}
Goal: ↑m ≤ Cardinal.lift.{u, v} x ↔ ↑m ≤ x
-- Cardinal.ofENat_eq_lift
@[simp] lemma ofENat_eq_lift {x : Cardinal.{v}} {m : ℕ∞} : m = lift.{u} x ↔ m = x 
Arguments: {x : Cardinal.{v}} {m : ℕ∞}
Goal: ↑m = Cardinal.lift.{u, v} x ↔ ↑m = x
-- Cardinal.range_ofENat
@[simp]
lemma range_ofENat : range ofENat = Iic ℵ₀ 
Goal: Set.range Cardinal.ofENat = Set.Iic Cardinal.aleph0
-- Cardinal.toENatAux_nat
lemma toENatAux_nat (n : ℕ) : toENatAux n = n 
Arguments: (n : ℕ)
Goal: (↑n).toENatAux = ↑n
-- Cardinal.toENatAux_zero
lemma toENatAux_zero : toENatAux 0 = 0 
Goal: Cardinal.toENatAux 0 = 0
-- Cardinal.toENatAux_eq_top
lemma toENatAux_eq_top {a : Cardinal} (ha : ℵ₀ ≤ a) : toENatAux a = ⊤ 
Arguments: {a : Cardinal.{u_1}} (ha : Cardinal.aleph0 ≤ a)
Goal: a.toENatAux = ⊤
-- Cardinal.toENatAux_ofENat
lemma toENatAux_ofENat : ∀ n : ℕ∞, toENatAux n = n
  
Arguments: (n : ℕ∞)
Goal: (↑n).toENatAux = n
-- Cardinal.toENatAux_gc
lemma toENatAux_gc : GaloisConnection (↑) toENatAux 
Goal: GaloisConnection Cardinal.ofENat Cardinal.toENatAux
-- Cardinal.toENatAux_le_nat
theorem toENatAux_le_nat {x : Cardinal} {n : ℕ} : toENatAux x ≤ n ↔ x ≤ n 
Arguments: {x : Cardinal.{u_1}} {n : ℕ}
Goal: x.toENatAux ≤ ↑n ↔ x ≤ ↑n
-- Cardinal.toENatAux_eq_nat
lemma toENatAux_eq_nat {x : Cardinal} {n : ℕ} : toENatAux x = n ↔ x = n 
Arguments: {x : Cardinal.{u_1}} {n : ℕ}
Goal: x.toENatAux = ↑n ↔ x = ↑n
-- Cardinal.toENatAux_eq_zero
lemma toENatAux_eq_zero {x : Cardinal} : toENatAux x = 0 ↔ x = 0 
Arguments: {x : Cardinal.{u_1}}
Goal: x.toENatAux = 0 ↔ x = 0
-- Cardinal.enat_gc
lemma enat_gc : GaloisConnection (↑) toENat 
Goal: GaloisConnection Cardinal.ofENat ⇑Cardinal.toENat
-- Cardinal.toENat_ofENat
@[simp] lemma toENat_ofENat (n : ℕ∞) : toENat n = n 
Arguments: (n : ℕ∞)
Goal: Cardinal.toENat ↑n = n
-- Cardinal.toENat_comp_ofENat
@[simp] lemma toENat_comp_ofENat : toENat ∘ (↑) = id 
Goal: ⇑Cardinal.toENat ∘ Cardinal.ofENat = id
-- Cardinal.toENat_strictMonoOn
lemma toENat_strictMonoOn : StrictMonoOn toENat (Iic ℵ₀) 
Goal: StrictMonoOn (⇑Cardinal.toENat) (Set.Iic Cardinal.aleph0)
-- Cardinal.toENat_injOn
lemma toENat_injOn : InjOn toENat (Iic ℵ₀) 
Goal: Set.InjOn (⇑Cardinal.toENat) (Set.Iic Cardinal.aleph0)
-- Cardinal.ofENat_toENat_le
lemma ofENat_toENat_le (a : Cardinal) : ↑(toENat a) ≤ a 
Arguments: (a : Cardinal.{u_1})
Goal: ↑(Cardinal.toENat a) ≤ a
-- Cardinal.ofENat_toENat_eq_self
@[simp]
lemma ofENat_toENat_eq_self {a : Cardinal} : toENat a = a ↔ a ≤ ℵ₀ 
Arguments: {a : Cardinal.{u_1}}
Goal: ↑(Cardinal.toENat a) = a ↔ a ≤ Cardinal.aleph0
-- Cardinal.toENat_nat
lemma toENat_nat (n : ℕ) : toENat n = n 
Arguments: (n : ℕ)
Goal: Cardinal.toENat ↑n = ↑n
-- Cardinal.toENat_le_nat
@[simp] lemma toENat_le_nat {a : Cardinal} {n : ℕ} : toENat a ≤ n ↔ a ≤ n 
Arguments: {a : Cardinal.{u_1}} {n : ℕ}
Goal: Cardinal.toENat a ≤ ↑n ↔ a ≤ ↑n
-- Cardinal.toENat_eq_nat
@[simp] lemma toENat_eq_nat {a : Cardinal} {n : ℕ} : toENat a = n ↔ a = n 
Arguments: {a : Cardinal.{u_1}} {n : ℕ}
Goal: Cardinal.toENat a = ↑n ↔ a = ↑n
-- Cardinal.toENat_eq_zero
@[simp] lemma toENat_eq_zero {a : Cardinal} : toENat a = 0 ↔ a = 0 
Arguments: {a : Cardinal.{u_1}}
Goal: Cardinal.toENat a = 0 ↔ a = 0
-- Cardinal.toENat_le_one
@[simp] lemma toENat_le_one {a : Cardinal} : toENat a ≤ 1 ↔ a ≤ 1 
Arguments: {a : Cardinal.{u_1}}
Goal: Cardinal.toENat a ≤ 1 ↔ a ≤ 1
-- Cardinal.toENat_eq_one
@[simp] lemma toENat_eq_one {a : Cardinal} : toENat a = 1 ↔ a = 1 
Arguments: {a : Cardinal.{u_1}}
Goal: Cardinal.toENat a = 1 ↔ a = 1
-- Cardinal.toENat_le_ofNat
@[simp] lemma toENat_le_ofNat {a : Cardinal} {n : ℕ} [n.AtLeastTwo] :
    toENat a ≤ no_index (OfNat.ofNat n) ↔ a ≤ OfNat.ofNat n 
Arguments: {a : Cardinal.{u_1}} {n : ℕ} [n.AtLeastTwo]
Goal: Cardinal.toENat a ≤ OfNat.ofNat n ↔ a ≤ OfNat.ofNat n
-- Cardinal.toENat_eq_ofNat
@[simp] lemma toENat_eq_ofNat {a : Cardinal} {n : ℕ} [n.AtLeastTwo] :
    toENat a = no_index (OfNat.ofNat n) ↔ a = OfNat.ofNat n 
Arguments: {a : Cardinal.{u_1}} {n : ℕ} [n.AtLeastTwo]
Goal: Cardinal.toENat a = OfNat.ofNat n ↔ a = OfNat.ofNat n
-- Cardinal.toENat_eq_top
@[simp] lemma toENat_eq_top {a : Cardinal} : toENat a = ⊤ ↔ ℵ₀ ≤ a 
Arguments: {a : Cardinal.{u_1}}
Goal: Cardinal.toENat a = ⊤ ↔ Cardinal.aleph0 ≤ a
-- Cardinal.toENat_lift
@[simp]
theorem toENat_lift {a : Cardinal.{v}} : toENat (lift.{u} a) = toENat a 
Arguments: {a : Cardinal.{v}}
Goal: Cardinal.toENat (Cardinal.lift.{u, v} a) = Cardinal.toENat a
-- Cardinal.ofENat_add
@[simp, norm_cast]
lemma ofENat_add (m n : ℕ∞) : ofENat (m + n) = m + n 
Arguments: (m n : ℕ∞)
Goal: ↑(m + n) = ↑m + ↑n
-- Cardinal.aleph0_add_ofENat
@[simp] lemma aleph0_add_ofENat (m : ℕ∞) : ℵ₀ + m = ℵ₀ 
Arguments: (m : ℕ∞)
Goal: Cardinal.aleph0 + ↑m = Cardinal.aleph0
-- Cardinal.ofENat_add_aleph0
@[simp] lemma ofENat_add_aleph0 (m : ℕ∞) : m + ℵ₀ = ℵ₀ 
Arguments: (m : ℕ∞)
Goal: ↑m + Cardinal.aleph0 = Cardinal.aleph0
-- Cardinal.ofENat_mul_aleph0
@[simp] lemma ofENat_mul_aleph0 {m : ℕ∞} (hm : m ≠ 0) : ↑m * ℵ₀ = ℵ₀ 
Arguments: {m : ℕ∞} (hm : m ≠ 0)
Goal: ↑m * Cardinal.aleph0 = Cardinal.aleph0
-- Cardinal.aleph0_mul_ofENat
@[simp] lemma aleph0_mul_ofENat {m : ℕ∞} (hm : m ≠ 0) : ℵ₀ * m = ℵ₀ 
Arguments: {m : ℕ∞} (hm : m ≠ 0)
Goal: Cardinal.aleph0 * ↑m = Cardinal.aleph0
-- Cardinal.ofENat_mul
@[simp] lemma ofENat_mul (m n : ℕ∞) : ofENat (m * n) = m * n 
Arguments: (m n : ℕ∞)
Goal: ↑(m * n) = ↑m * ↑n
-- Cardinal.isUnit_iff
@[simp]
theorem isUnit_iff : IsUnit a ↔ a = 1 
Arguments: {a : Cardinal.{u}}
Goal: IsUnit a ↔ a = 1
-- Cardinal.le_of_dvd
theorem le_of_dvd : ∀ {a b : Cardinal}, b ≠ 0 → a ∣ b → a ≤ b
  
Arguments: {a b : Cardinal.{u_1}}
Goal: b ≠ 0 → a ∣ b → a ≤ b
-- Cardinal.dvd_of_le_of_aleph0_le
theorem dvd_of_le_of_aleph0_le (ha : a ≠ 0) (h : a ≤ b) (hb : ℵ₀ ≤ b) : a ∣ b 
Arguments: {a b : Cardinal.{u}} (ha : a ≠ 0) (h : a ≤ b) (hb : Cardinal.aleph0 ≤ b)
Goal: a ∣ b
-- Cardinal.prime_of_aleph0_le
@[simp]
theorem prime_of_aleph0_le (ha : ℵ₀ ≤ a) : Prime a 
Arguments: {a : Cardinal.{u}} (ha : Cardinal.aleph0 ≤ a)
Goal: Prime a
-- Cardinal.not_irreducible_of_aleph0_le
theorem not_irreducible_of_aleph0_le (ha : ℵ₀ ≤ a) : ¬Irreducible a 
Arguments: {a : Cardinal.{u}} (ha : Cardinal.aleph0 ≤ a)
Goal: ¬Irreducible a
-- Cardinal.nat_coe_dvd_iff
@[simp, norm_cast]
theorem nat_coe_dvd_iff : (n : Cardinal) ∣ m ↔ n ∣ m 
Arguments: {n m : ℕ}
Goal: ↑n ∣ ↑m ↔ n ∣ m
-- Cardinal.nat_is_prime_iff
@[simp]
theorem nat_is_prime_iff : Prime (n : Cardinal) ↔ n.Prime 
Arguments: {n : ℕ}
Goal: Prime ↑n ↔ Nat.Prime n
-- Cardinal.is_prime_iff
theorem is_prime_iff {a : Cardinal} : Prime a ↔ ℵ₀ ≤ a ∨ ∃ p : ℕ, a = p ∧ p.Prime 
Arguments: {a : Cardinal.{u_1}}
Goal: Prime a ↔ Cardinal.aleph0 ≤ a ∨ ∃ p, a = ↑p ∧ Nat.Prime p
-- Cardinal.isPrimePow_iff
theorem isPrimePow_iff {a : Cardinal} : IsPrimePow a ↔ ℵ₀ ≤ a ∨ ∃ n : ℕ, a = n ∧ IsPrimePow n 
Arguments: {a : Cardinal.{u_1}}
Goal: IsPrimePow a ↔ Cardinal.aleph0 ≤ a ∨ ∃ n, a = ↑n ∧ IsPrimePow n
-- PSet.mk_type
@[simp]
theorem mk_type (α A) : «Type» ⟨α, A⟩ = α 
Arguments: (α : Type u_1) (A : α → PSet)
Goal: (PSet.mk α A).Type = α
-- PSet.mk_func
@[simp]
theorem mk_func (α A) : Func ⟨α, A⟩ = A 
Arguments: (α : Type u_1) (A : α → PSet)
Goal: (PSet.mk α A).Func = A
-- PSet.eta
@[simp]
theorem eta : ∀ x : PSet, mk x.Type x.Func = x
  
Arguments: (x : PSet)
Goal: PSet.mk x.Type x.Func = x
-- PSet.equiv_iff
theorem equiv_iff :
    ∀ {x y : PSet},
      Equiv x y ↔ (∀ i, ∃ j, Equiv (x.Func i) (y.Func j)) ∧ ∀ j, ∃ i, Equiv (x.Func i) (y.Func j)
  
Arguments: {x : PSet} {y : PSet}
Goal: x.Equiv y ↔ (∀ (i : x.Type), ∃ j, (x.Func i).Equiv (y.Func j)) ∧ ∀ (j : y.Type), ∃ i, (x.Func i).Equiv (y.Func j)
-- PSet.Equiv.exists_left
theorem Equiv.exists_left {x y : PSet} (h : Equiv x y) : ∀ i, ∃ j, Equiv (x.Func i) (y.Func j) 
Arguments: {x : PSet} {y : PSet} (h : x.Equiv y) (i : x.Type)
Goal: ∃ j, (x.Func i).Equiv (y.Func j)
-- PSet.Equiv.exists_right
theorem Equiv.exists_right {x y : PSet} (h : Equiv x y) : ∀ j, ∃ i, Equiv (x.Func i) (y.Func j) 
Arguments: {x : PSet} {y : PSet} (h : x.Equiv y) (j : y.Type)
Goal: ∃ i, (x.Func i).Equiv (y.Func j)
-- PSet.Equiv.refl
@[refl]
protected theorem Equiv.refl : ∀ x, Equiv x x
  
Arguments: (x : PSet)
Goal: x.Equiv x
-- PSet.Equiv.rfl
protected theorem Equiv.rfl {x} : Equiv x x 
Arguments: {x : PSet}
Goal: x.Equiv x
-- PSet.Equiv.euc
protected theorem Equiv.euc : ∀ {x y z}, Equiv x y → Equiv z y → Equiv x z
  
Arguments: {x : PSet} {y : PSet} {z : PSet}
Goal: x.Equiv y → z.Equiv y → x.Equiv z
-- PSet.Equiv.symm
@[symm]
protected theorem Equiv.symm {x y} : Equiv x y → Equiv y x 
Arguments: {x : PSet} {y : PSet}
Goal: x.Equiv y → y.Equiv x
-- PSet.Equiv.comm
protected theorem Equiv.comm {x y} : Equiv x y ↔ Equiv y x 
Arguments: {x : PSet} {y : PSet}
Goal: x.Equiv y ↔ y.Equiv x
-- PSet.Equiv.trans
@[trans]
protected theorem Equiv.trans {x y z} (h1 : Equiv x y) (h2 : Equiv y z) : Equiv x z 
Arguments: {x : PSet} {y : PSet} {z : PSet} (h1 : x.Equiv y) (h2 : y.Equiv z)
Goal: x.Equiv z
-- PSet.equiv_of_isEmpty
protected theorem equiv_of_isEmpty (x y : PSet) [IsEmpty x.Type] [IsEmpty y.Type] : Equiv x y 
Arguments: (x : PSet) (y : PSet) [IsEmpty x.Type] [IsEmpty y.Type]
Goal: x.Equiv y
-- PSet.Equiv.ext
theorem Equiv.ext : ∀ x y : PSet, Equiv x y ↔ x ⊆ y ∧ y ⊆ x
  
Arguments: (x y : PSet)
Goal: x.Equiv y ↔ x ⊆ y ∧ y ⊆ x
-- PSet.Subset.congr_left
theorem Subset.congr_left : ∀ {x y z : PSet}, Equiv x y → (x ⊆ z ↔ y ⊆ z)
  
Arguments: {x y z : PSet}
Goal: x.Equiv y → (x ⊆ z ↔ y ⊆ z)
-- PSet.Subset.congr_right
theorem Subset.congr_right : ∀ {x y z : PSet}, Equiv x y → (z ⊆ x ↔ z ⊆ y)
  
Arguments: {x y z : PSet}
Goal: x.Equiv y → (z ⊆ x ↔ z ⊆ y)
-- PSet.Mem.mk
theorem Mem.mk {α : Type u} (A : α → PSet) (a : α) : A a ∈ mk α A 
Arguments: {α : Type u} (A : α → PSet) (a : α)
Goal: A a ∈ PSet.mk α A
-- PSet.func_mem
theorem func_mem (x : PSet) (i : x.Type) : x.Func i ∈ x 
Arguments: (x : PSet) (i : x.Type)
Goal: x.Func i ∈ x
-- PSet.Mem.ext
theorem Mem.ext : ∀ {x y : PSet.{u}}, (∀ w : PSet.{u}, w ∈ x ↔ w ∈ y) → Equiv x y
  
Arguments: {x y : PSet}
Goal: (∀ (w : PSet), w ∈ x ↔ w ∈ y) → x.Equiv y
-- PSet.Mem.congr_right
theorem Mem.congr_right : ∀ {x y : PSet.{u}}, Equiv x y → ∀ {w : PSet.{u}}, w ∈ x ↔ w ∈ y
  
Arguments: {x y : PSet}
Goal: x.Equiv y → ∀ {w : PSet}, w ∈ x ↔ w ∈ y
-- PSet.equiv_iff_mem
theorem equiv_iff_mem {x y : PSet.{u}} : Equiv x y ↔ ∀ {w : PSet.{u}}, w ∈ x ↔ w ∈ y 
Arguments: {x y : PSet}
Goal: x.Equiv y ↔ ∀ {w : PSet}, w ∈ x ↔ w ∈ y
-- PSet.Mem.congr_left
theorem Mem.congr_left : ∀ {x y : PSet.{u}}, Equiv x y → ∀ {w : PSet.{u}}, x ∈ w ↔ y ∈ w
  
Arguments: {x y : PSet}
Goal: x.Equiv y → ∀ {w : PSet}, x ∈ w ↔ y ∈ w
-- _private.Mathlib.SetTheory.ZFC.Basic.0.PSet.mem_wf_aux
private theorem mem_wf_aux : ∀ {x y : PSet.{u}}, Equiv x y → Acc (· ∈ ·) y
  
Arguments: {x y : PSet}
Goal: x.Equiv y → Acc (fun x x_1 => x ∈ x_1) y
-- PSet.mem_wf
theorem mem_wf : @WellFounded PSet (· ∈ ·) 
Goal: WellFounded fun x x_1 => x ∈ x_1
-- PSet.mem_asymm
theorem mem_asymm {x y : PSet} : x ∈ y → y ∉ x 
Arguments: {x y : PSet}
Goal: x ∈ y → y ∉ x
-- PSet.mem_irrefl
theorem mem_irrefl (x : PSet) : x ∉ x 
Arguments: (x : PSet)
Goal: x ∉ x
-- PSet.mem_toSet
@[simp]
theorem mem_toSet (a u : PSet.{u}) : a ∈ u.toSet ↔ a ∈ u 
Arguments: (a u : PSet)
Goal: a ∈ u.toSet ↔ a ∈ u
-- PSet.nonempty_def
theorem nonempty_def (u : PSet) : u.Nonempty ↔ ∃ x, x ∈ u 
Arguments: (u : PSet)
Goal: u.Nonempty ↔ ∃ x, x ∈ u
-- PSet.nonempty_of_mem
theorem nonempty_of_mem {x u : PSet} (h : x ∈ u) : u.Nonempty 
Arguments: {x u : PSet} (h : x ∈ u)
Goal: u.Nonempty
-- PSet.nonempty_toSet_iff
@[simp]
theorem nonempty_toSet_iff {u : PSet} : u.toSet.Nonempty ↔ u.Nonempty 
Arguments: {u : PSet}
Goal: u.toSet.Nonempty ↔ u.Nonempty
-- PSet.nonempty_type_iff_nonempty
theorem nonempty_type_iff_nonempty {x : PSet} : Nonempty x.Type ↔ PSet.Nonempty x 
Arguments: {x : PSet}
Goal: Nonempty x.Type ↔ x.Nonempty
-- PSet.nonempty_of_nonempty_type
theorem nonempty_of_nonempty_type (x : PSet) [h : Nonempty x.Type] : PSet.Nonempty x 
Arguments: (x : PSet) [h : Nonempty x.Type]
Goal: x.Nonempty
-- PSet.Equiv.eq
theorem Equiv.eq {x y : PSet} : Equiv x y ↔ toSet x = toSet y 
Arguments: {x y : PSet}
Goal: x.Equiv y ↔ x.toSet = y.toSet
-- PSet.not_mem_empty
@[simp]
theorem not_mem_empty (x : PSet.{u}) : x ∉ (∅ : PSet.{u}) 
Arguments: (x : PSet)
Goal: x ∉ ∅
-- PSet.toSet_empty
@[simp]
theorem toSet_empty : toSet ∅ = ∅ 
Goal: ∅.toSet = ∅
-- PSet.empty_subset
@[simp]
theorem empty_subset (x : PSet.{u}) : (∅ : PSet) ⊆ x 
Arguments: (x : PSet)
Goal: ∅ ⊆ x
-- PSet.not_nonempty_empty
@[simp]
theorem not_nonempty_empty : ¬PSet.Nonempty ∅ 
Goal: ¬∅.Nonempty
-- PSet.equiv_empty
protected theorem equiv_empty (x : PSet) [IsEmpty x.Type] : Equiv x ∅ 
Arguments: (x : PSet) [IsEmpty x.Type]
Goal: x.Equiv ∅
-- PSet.mem_powerset
@[simp]
theorem mem_powerset : ∀ {x y : PSet}, y ∈ powerset x ↔ y ⊆ x
  
Arguments: {x y : PSet}
Goal: y ∈ x.powerset ↔ y ⊆ x
-- PSet.mem_sUnion
@[simp]
theorem mem_sUnion : ∀ {x y : PSet.{u}}, y ∈ ⋃₀ x ↔ ∃ z ∈ x, y ∈ z
  
Arguments: {x y : PSet}
Goal: y ∈ ⋃₀ x ↔ ∃ z ∈ x, y ∈ z
-- PSet.toSet_sUnion
@[simp]
theorem toSet_sUnion (x : PSet.{u}) : (⋃₀ x).toSet = ⋃₀ (toSet '' x.toSet) 
Arguments: (x : PSet)
Goal: (⋃₀ x).toSet = ⋃₀ (PSet.toSet '' x.toSet)
-- PSet.mem_image
theorem mem_image {f : PSet.{u} → PSet.{u}} (H : ∀ x y, Equiv x y → Equiv (f x) (f y)) :
    ∀ {x y : PSet.{u}}, y ∈ image f x ↔ ∃ z ∈ x, Equiv y (f z)
  
Arguments: {f : PSet → PSet} (H : ∀ (x y : PSet), x.Equiv y → (f x).Equiv (f y)) {x y : PSet}
Goal: y ∈ PSet.image f x ↔ ∃ z ∈ x, y.Equiv (f z)
-- PSet.lift_mem_embed
theorem lift_mem_embed : ∀ x : PSet.{u}, PSet.Lift.{u, max (u + 1) v} x ∈ embed.{u, v} 
Arguments: (x : PSet)
Goal: x.Lift ∈ PSet.embed
-- PSet.Arity.equiv_const
theorem Arity.equiv_const {a : PSet.{u}} :
    ∀ n, Arity.Equiv (OfArity.const PSet.{u} a n) (OfArity.const PSet.{u} a n)
  
Arguments: {a : PSet} (n : ℕ)
Goal: PSet.Arity.Equiv (Function.OfArity.const PSet a n) (Function.OfArity.const PSet a n)
-- PSet.Resp.Equiv.refl
@[refl]
protected theorem Resp.Equiv.refl {n} (a : Resp n) : Resp.Equiv a a 
Arguments: {n : ℕ} (a : PSet.Resp n)
Goal: a.Equiv a
-- PSet.Resp.Equiv.euc
protected theorem Resp.Equiv.euc :
    ∀ {n} {a b c : Resp n}, Resp.Equiv a b → Resp.Equiv c b → Resp.Equiv a c
  
Arguments: {n : ℕ} {a b c : PSet.Resp n}
Goal: a.Equiv b → c.Equiv b → a.Equiv c