ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
-- Function.Surjective.bijective_of_nat_card_le
theorem _root_.Function.Surjective.bijective_of_nat_card_le [Finite α] {f : α → β}
    (surj : Surjective f) (hc : Nat.card α ≤ Nat.card β) : Bijective f 
Arguments: {α : Type u_1} {β : Type u_2} [Finite α] {f : α → β} (surj : Function.Surjective f) (hc : Nat.card α ≤ Nat.card β)
Goal: Function.Bijective f
-- Nat.card_eq_of_equiv_fin
theorem card_eq_of_equiv_fin {α : Type*} {n : ℕ} (f : α ≃ Fin n) : Nat.card α = n 
Arguments: {α : Type u_3} {n : ℕ} (f : α ≃ Fin n)
Goal: Nat.card α = n
-- Nat.card_mono
lemma card_mono (ht : t.Finite) (h : s ⊆ t) : Nat.card s ≤ Nat.card t 
Arguments: {α : Type u_1} {s t : Set α} (ht : t.Finite) (h : s ⊆ t)
Goal: Nat.card ↑s ≤ Nat.card ↑t
-- Nat.card_image_le
lemma card_image_le {f : α → β} (hs : s.Finite) : Nat.card (f '' s) ≤ Nat.card s 
Arguments: {α : Type u_1} {β : Type u_2} {s : Set α} {f : α → β} (hs : s.Finite)
Goal: Nat.card ↑(f '' s) ≤ Nat.card ↑s
-- Nat.card_image_of_injOn
lemma card_image_of_injOn {f : α → β} (hf : s.InjOn f) : Nat.card (f '' s) = Nat.card s 
Arguments: {α : Type u_1} {β : Type u_2} {s : Set α} {f : α → β} (hf : Set.InjOn f s)
Goal: Nat.card ↑(f '' s) = Nat.card ↑s
-- Nat.card_image_of_injective
lemma card_image_of_injective {f : α → β} (hf : Injective f) (s : Set α) :
    Nat.card (f '' s) = Nat.card s 
Arguments: {α : Type u_1} {β : Type u_2} {f : α → β} (hf : Function.Injective f) (s : Set α)
Goal: Nat.card ↑(f '' s) = Nat.card ↑s
-- Nat.card_image_equiv
lemma card_image_equiv (e : α ≃ β) : Nat.card (e '' s) = Nat.card s 
Arguments: {α : Type u_1} {β : Type u_2} {s : Set α} (e : α ≃ β)
Goal: Nat.card ↑(⇑e '' s) = Nat.card ↑s
-- Nat.card_preimage_of_injOn
lemma card_preimage_of_injOn {f : α → β} {s : Set β} (hf : (f ⁻¹' s).InjOn f) (hsf : s ⊆ range f) :
    Nat.card (f ⁻¹' s) = Nat.card s 
Arguments: {α : Type u_1} {β : Type u_2} {f : α → β} {s : Set β} (hf : Set.InjOn f (f ⁻¹' s)) (hsf : s ⊆ Set.range f)
Goal: Nat.card ↑(f ⁻¹' s) = Nat.card ↑s
-- Nat.card_preimage_of_injective
lemma card_preimage_of_injective {f : α → β} {s : Set β} (hf : Injective f) (hsf : s ⊆ range f) :
    Nat.card (f ⁻¹' s) = Nat.card s 
Arguments: {α : Type u_1} {β : Type u_2} {f : α → β} {s : Set β} (hf : Function.Injective f) (hsf : s ⊆ Set.range f)
Goal: Nat.card ↑(f ⁻¹' s) = Nat.card ↑s
-- Nat.card_of_subsingleton
theorem card_of_subsingleton (a : α) [Subsingleton α] : Nat.card α = 1 
Arguments: {α : Type u_1} (a : α) [Subsingleton α]
Goal: Nat.card α = 1
-- Nat.card_unique
theorem card_unique [Unique α] : Nat.card α = 1 
Arguments: {α : Type u_1} [Unique α]
Goal: Nat.card α = 1
-- Nat.card_eq_one_iff_unique
theorem card_eq_one_iff_unique : Nat.card α = 1 ↔ Subsingleton α ∧ Nonempty α 
Arguments: {α : Type u_1}
Goal: Nat.card α = 1 ↔ Subsingleton α ∧ Nonempty α
-- Nat.card_eq_one_iff_exists
theorem card_eq_one_iff_exists : Nat.card α = 1 ↔ ∃ x : α, ∀ y : α, y = x 
Arguments: {α : Type u_1}
Goal: Nat.card α = 1 ↔ ∃ x, ∀ (y : α), y = x
-- Nat.card_eq_two_iff
theorem card_eq_two_iff : Nat.card α = 2 ↔ ∃ x y : α, x ≠ y ∧ {x, y} = @Set.univ α 
Arguments: {α : Type u_1}
Goal: Nat.card α = 2 ↔ ∃ x y, x ≠ y ∧ {x, y} = Set.univ
-- Nat.card_eq_two_iff'
theorem card_eq_two_iff' (x : α) : Nat.card α = 2 ↔ ∃! y, y ≠ x 
Arguments: {α : Type u_1} (x : α)
Goal: Nat.card α = 2 ↔ ∃! y, y ≠ x
-- Nat.card_sum
@[simp]
theorem card_sum [Finite α] [Finite β] : Nat.card (α ⊕ β) = Nat.card α + Nat.card β 
Arguments: {α : Type u_1} {β : Type u_2} [Finite α] [Finite β]
Goal: Nat.card (α ⊕ β) = Nat.card α + Nat.card β
-- Nat.card_prod
@[simp]
theorem card_prod (α β : Type*) : Nat.card (α × β) = Nat.card α * Nat.card β 
Arguments: (α : Type u_3) (β : Type u_4)
Goal: Nat.card (α × β) = Nat.card α * Nat.card β
-- Nat.card_ulift
@[simp]
theorem card_ulift (α : Type*) : Nat.card (ULift α) = Nat.card α 
Arguments: (α : Type u_3)
Goal: Nat.card (ULift.{u_4, u_3} α) = Nat.card α
-- Nat.card_plift
@[simp]
theorem card_plift (α : Type*) : Nat.card (PLift α) = Nat.card α 
Arguments: (α : Type u_3)
Goal: Nat.card (PLift α) = Nat.card α
-- Nat.card_pi
theorem card_pi {β : α → Type*} [Fintype α] : Nat.card (∀ a, β a) = ∏ a, Nat.card (β a) 
Arguments: {α : Type u_1} {β : α → Type u_3} [Fintype α]
Goal: Nat.card ((a : α) → β a) = ∏ a : α, Nat.card (β a)
-- Nat.card_fun
theorem card_fun [Finite α] : Nat.card (α → β) = Nat.card β ^ Nat.card α 
Arguments: {α : Type u_1} {β : Type u_2} [Finite α]
Goal: Nat.card (α → β) = Nat.card β ^ Nat.card α
-- Nat.card_zmod
@[simp]
theorem card_zmod (n : ℕ) : Nat.card (ZMod n) = n 
Arguments: (n : ℕ)
Goal: Nat.card (ZMod n) = n
-- Set.card_singleton_prod
lemma card_singleton_prod (a : α) (t : Set β) : Nat.card ({a} ×ˢ t) = Nat.card t 
Arguments: {α : Type u_1} {β : Type u_2} (a : α) (t : Set β)
Goal: Nat.card ↑({a} ×ˢ t) = Nat.card ↑t
-- Set.card_prod_singleton
lemma card_prod_singleton (s : Set α) (b : β) : Nat.card (s ×ˢ {b}) = Nat.card s 
Arguments: {α : Type u_1} {β : Type u_2} (s : Set α) (b : β)
Goal: Nat.card ↑(s ×ˢ {b}) = Nat.card ↑s
-- PartENat.card_eq_coe_fintype_card
@[simp]
theorem card_eq_coe_fintype_card [Fintype α] : card α = Fintype.card α 
Arguments: {α : Type u_1} [Fintype α]
Goal: PartENat.card α = ↑(Fintype.card α)
-- PartENat.card_eq_top_of_infinite
@[simp]
theorem card_eq_top_of_infinite [Infinite α] : card α = ⊤ 
Arguments: {α : Type u_1} [Infinite α]
Goal: PartENat.card α = ⊤
-- PartENat.card_sum
@[simp]
theorem card_sum (α β : Type*) :
    PartENat.card (α ⊕ β) = PartENat.card α + PartENat.card β 
Arguments: (α : Type u_3) (β : Type u_4)
Goal: PartENat.card (α ⊕ β) = PartENat.card α + PartENat.card β
-- PartENat.card_congr
theorem card_congr {α : Type*} {β : Type*} (f : α ≃ β) : PartENat.card α = PartENat.card β 
Arguments: {α : Type u_3} {β : Type u_4} (f : α ≃ β)
Goal: PartENat.card α = PartENat.card β
-- PartENat.card_ulift
@[simp] lemma card_ulift (α : Type*) : card (ULift α) = card α 
Arguments: (α : Type u_3)
Goal: PartENat.card (ULift.{u_4, u_3} α) = PartENat.card α
-- PartENat.card_plift
@[simp] lemma card_plift (α : Type*) : card (PLift α) = card α 
Arguments: (α : Type u_3)
Goal: PartENat.card (PLift α) = PartENat.card α
-- PartENat.card_image_of_injOn
theorem card_image_of_injOn {α : Type u} {β : Type v} {f : α → β} {s : Set α} (h : Set.InjOn f s) :
    card (f '' s) = card s 
Arguments: {α : Type u} {β : Type v} {f : α → β} {s : Set α} (h : Set.InjOn f s)
Goal: PartENat.card ↑(f '' s) = PartENat.card ↑s
-- PartENat.card_image_of_injective
theorem card_image_of_injective {α : Type u} {β : Type v} (f : α → β) (s : Set α)
    (h : Function.Injective f) : card (f '' s) = card s 
Arguments: {α : Type u} {β : Type v} (f : α → β) (s : Set α) (h : Function.Injective f)
Goal: PartENat.card ↑(f '' s) = PartENat.card ↑s
-- Cardinal.natCast_le_toPartENat_iff
@[simp]
theorem _root_.Cardinal.natCast_le_toPartENat_iff {n : ℕ} {c : Cardinal} :
    ↑n ≤ toPartENat c ↔ ↑n ≤ c 
Arguments: {n : ℕ} {c : Cardinal.{u_3}}
Goal: ↑n ≤ Cardinal.toPartENat c ↔ ↑n ≤ c
-- Cardinal.toPartENat_le_natCast_iff
@[simp]
theorem _root_.Cardinal.toPartENat_le_natCast_iff {c : Cardinal} {n : ℕ} :
    toPartENat c ≤ n ↔ c ≤ n 
Arguments: {c : Cardinal.{u_3}} {n : ℕ}
Goal: Cardinal.toPartENat c ≤ ↑n ↔ c ≤ ↑n
-- Cardinal.natCast_eq_toPartENat_iff
@[simp]
theorem _root_.Cardinal.natCast_eq_toPartENat_iff {n : ℕ} {c : Cardinal} :
    ↑n = toPartENat c ↔ ↑n = c 
Arguments: {n : ℕ} {c : Cardinal.{u_3}}
Goal: ↑n = Cardinal.toPartENat c ↔ ↑n = c
-- Cardinal.toPartENat_eq_natCast_iff
@[simp]
theorem _root_.Cardinal.toPartENat_eq_natCast_iff {c : Cardinal} {n : ℕ} :
    Cardinal.toPartENat c = n ↔ c = n 
Arguments: {c : Cardinal.{u_3}} {n : ℕ}
Goal: Cardinal.toPartENat c = ↑n ↔ c = ↑n
-- Cardinal.natCast_lt_toPartENat_iff
@[simp]
theorem _root_.Cardinal.natCast_lt_toPartENat_iff {n : ℕ} {c : Cardinal} :
    ↑n < toPartENat c ↔ ↑n < c 
Arguments: {n : ℕ} {c : Cardinal.{u_3}}
Goal: ↑n < Cardinal.toPartENat c ↔ ↑n < c
-- Cardinal.toPartENat_lt_natCast_iff
@[simp]
theorem _root_.Cardinal.toPartENat_lt_natCast_iff {n : ℕ} {c : Cardinal} :
    toPartENat c < ↑n ↔ c < ↑n 
Arguments: {n : ℕ} {c : Cardinal.{u_3}}
Goal: Cardinal.toPartENat c < ↑n ↔ c < ↑n
-- PartENat.card_eq_zero_iff_empty
theorem card_eq_zero_iff_empty (α : Type*) : card α = 0 ↔ IsEmpty α 
Arguments: (α : Type u_3)
Goal: PartENat.card α = 0 ↔ IsEmpty α
-- PartENat.card_le_one_iff_subsingleton
theorem card_le_one_iff_subsingleton (α : Type*) : card α ≤ 1 ↔ Subsingleton α 
Arguments: (α : Type u_3)
Goal: PartENat.card α ≤ 1 ↔ Subsingleton α
-- PartENat.one_lt_card_iff_nontrivial
theorem one_lt_card_iff_nontrivial (α : Type*) : 1 < card α ↔ Nontrivial α 
Arguments: (α : Type u_3)
Goal: 1 < PartENat.card α ↔ Nontrivial α
-- Cardinal.toNat_toENat
@[simp] lemma toNat_toENat (a : Cardinal) : ENat.toNat (toENat a) = toNat a 
Arguments: (a : Cardinal.{u_1})
Goal: (Cardinal.toENat a).toNat = Cardinal.toNat a
-- Cardinal.toNat_ofENat
@[simp]
theorem toNat_ofENat (n : ℕ∞) : toNat n = ENat.toNat n 
Arguments: (n : ℕ∞)
Goal: Cardinal.toNat ↑n = n.toNat
-- Cardinal.toNat_natCast
@[simp, norm_cast] theorem toNat_natCast (n : ℕ) : toNat n = n 
Arguments: (n : ℕ)
Goal: Cardinal.toNat ↑n = n
-- Cardinal.toNat_eq_zero
@[simp]
lemma toNat_eq_zero : toNat c = 0 ↔ c = 0 ∨ ℵ₀ ≤ c 
Arguments: {c : Cardinal.{u}}
Goal: Cardinal.toNat c = 0 ↔ c = 0 ∨ Cardinal.aleph0 ≤ c
-- Cardinal.toNat_ne_zero
lemma toNat_ne_zero : toNat c ≠ 0 ↔ c ≠ 0 ∧ c < ℵ₀ 
Arguments: {c : Cardinal.{u}}
Goal: Cardinal.toNat c ≠ 0 ↔ c ≠ 0 ∧ c < Cardinal.aleph0
-- Cardinal.toNat_pos
@[simp] lemma toNat_pos : 0 < toNat c ↔ c ≠ 0 ∧ c < ℵ₀ 
Arguments: {c : Cardinal.{u}}
Goal: 0 < Cardinal.toNat c ↔ c ≠ 0 ∧ c < Cardinal.aleph0
-- Cardinal.cast_toNat_of_lt_aleph0
theorem cast_toNat_of_lt_aleph0 {c : Cardinal} (h : c < ℵ₀) : ↑(toNat c) = c 
Arguments: {c : Cardinal.{u_1}} (h : c < Cardinal.aleph0)
Goal: ↑(Cardinal.toNat c) = c
-- Cardinal.toNat_apply_of_lt_aleph0
theorem toNat_apply_of_lt_aleph0 {c : Cardinal.{u}} (h : c < ℵ₀) :
    toNat c = Classical.choose (lt_aleph0.1 h) 
Arguments: {c : Cardinal.{u}} (h : c < Cardinal.aleph0)
Goal: Cardinal.toNat c = Classical.choose ⋯
-- Cardinal.toNat_apply_of_aleph0_le
theorem toNat_apply_of_aleph0_le {c : Cardinal} (h : ℵ₀ ≤ c) : toNat c = 0 
Arguments: {c : Cardinal.{u_1}} (h : Cardinal.aleph0 ≤ c)
Goal: Cardinal.toNat c = 0
-- Cardinal.cast_toNat_of_aleph0_le
theorem cast_toNat_of_aleph0_le {c : Cardinal} (h : ℵ₀ ≤ c) : ↑(toNat c) = (0 : Cardinal) 
Arguments: {c : Cardinal.{u_1}} (h : Cardinal.aleph0 ≤ c)
Goal: ↑(Cardinal.toNat c) = 0
-- Cardinal.toNat_strictMonoOn
theorem toNat_strictMonoOn : StrictMonoOn toNat (Iio ℵ₀) 
Goal: StrictMonoOn (⇑Cardinal.toNat) (Set.Iio Cardinal.aleph0)
-- Cardinal.toNat_monotoneOn
theorem toNat_monotoneOn : MonotoneOn toNat (Iio ℵ₀) 
Goal: MonotoneOn (⇑Cardinal.toNat) (Set.Iio Cardinal.aleph0)
-- Cardinal.toNat_injOn
theorem toNat_injOn : InjOn toNat (Iio ℵ₀) 
Goal: Set.InjOn (⇑Cardinal.toNat) (Set.Iio Cardinal.aleph0)
-- Cardinal.toNat_eq_iff_eq_of_lt_aleph0
theorem toNat_eq_iff_eq_of_lt_aleph0 (hc : c < ℵ₀) (hd : d < ℵ₀) :
    toNat c = toNat d ↔ c = d 
Arguments: {c d : Cardinal.{u}} (hc : c < Cardinal.aleph0) (hd : d < Cardinal.aleph0)
Goal: Cardinal.toNat c = Cardinal.toNat d ↔ c = d
-- Cardinal.toNat_le_iff_le_of_lt_aleph0
theorem toNat_le_iff_le_of_lt_aleph0 (hc : c < ℵ₀) (hd : d < ℵ₀) :
    toNat c ≤ toNat d ↔ c ≤ d 
Arguments: {c d : Cardinal.{u}} (hc : c < Cardinal.aleph0) (hd : d < Cardinal.aleph0)
Goal: Cardinal.toNat c ≤ Cardinal.toNat d ↔ c ≤ d
-- Cardinal.toNat_lt_iff_lt_of_lt_aleph0
theorem toNat_lt_iff_lt_of_lt_aleph0 (hc : c < ℵ₀) (hd : d < ℵ₀) :
    toNat c < toNat d ↔ c < d 
Arguments: {c d : Cardinal.{u}} (hc : c < Cardinal.aleph0) (hd : d < Cardinal.aleph0)
Goal: Cardinal.toNat c < Cardinal.toNat d ↔ c < d
-- Cardinal.toNat_le_toNat
@[gcongr]
theorem toNat_le_toNat (hcd : c ≤ d) (hd : d < ℵ₀) : toNat c ≤ toNat d 
Arguments: {c d : Cardinal.{u}} (hcd : c ≤ d) (hd : d < Cardinal.aleph0)
Goal: Cardinal.toNat c ≤ Cardinal.toNat d
-- Cardinal.toNat_le_of_le_of_lt_aleph0
@[deprecated toNat_le_toNat (since := "2024-02-15")]
theorem toNat_le_of_le_of_lt_aleph0 (hd : d < ℵ₀) (hcd : c ≤ d) :
    toNat c ≤ toNat d 
Arguments: {c d : Cardinal.{u}} (hd : d < Cardinal.aleph0) (hcd : c ≤ d)
Goal: Cardinal.toNat c ≤ Cardinal.toNat d
-- Cardinal.toNat_lt_toNat
theorem toNat_lt_toNat (hcd : c < d) (hd : d < ℵ₀) : toNat c < toNat d 
Arguments: {c d : Cardinal.{u}} (hcd : c < d) (hd : d < Cardinal.aleph0)
Goal: Cardinal.toNat c < Cardinal.toNat d
-- Cardinal.toNat_lt_of_lt_of_lt_aleph0
@[deprecated toNat_lt_toNat (since := "2024-02-15")]
theorem toNat_lt_of_lt_of_lt_aleph0 (hd : d < ℵ₀) (hcd : c < d) : toNat c < toNat d 
Arguments: {c d : Cardinal.{u}} (hd : d < Cardinal.aleph0) (hcd : c < d)
Goal: Cardinal.toNat c < Cardinal.toNat d
-- Cardinal.toNat_ofNat
@[simp]
theorem toNat_ofNat (n : ℕ) [n.AtLeastTwo] :
    Cardinal.toNat (no_index (OfNat.ofNat n)) = OfNat.ofNat n 
Arguments: (n : ℕ) [n.AtLeastTwo]
Goal: Cardinal.toNat (OfNat.ofNat n) = OfNat.ofNat n
-- Cardinal.toNat_rightInverse
theorem toNat_rightInverse : Function.RightInverse ((↑) : ℕ → Cardinal) toNat 
Goal: Function.RightInverse Nat.cast ⇑Cardinal.toNat
-- Cardinal.toNat_surjective
theorem toNat_surjective : Surjective toNat 
Goal: Function.Surjective ⇑Cardinal.toNat
-- Cardinal.mk_toNat_of_infinite
@[simp]
theorem mk_toNat_of_infinite [h : Infinite α] : toNat #α = 0 
Arguments: {α : Type u} [h : Infinite α]
Goal: Cardinal.toNat (Cardinal.mk α) = 0
-- Cardinal.aleph0_toNat
@[simp]
theorem aleph0_toNat : toNat ℵ₀ = 0 
Goal: Cardinal.toNat Cardinal.aleph0 = 0
-- Cardinal.mk_toNat_eq_card
theorem mk_toNat_eq_card [Fintype α] : toNat #α = Fintype.card α 
Arguments: {α : Type u} [Fintype α]
Goal: Cardinal.toNat (Cardinal.mk α) = Fintype.card α
-- Cardinal.zero_toNat
theorem zero_toNat : toNat 0 = 0 
Goal: Cardinal.toNat 0 = 0
-- Cardinal.one_toNat
theorem one_toNat : toNat 1 = 1 
Goal: Cardinal.toNat 1 = 1
-- Cardinal.toNat_eq_iff
theorem toNat_eq_iff {n : ℕ} (hn : n ≠ 0) : toNat c = n ↔ c = n 
Arguments: {c : Cardinal.{u}} {n : ℕ} (hn : n ≠ 0)
Goal: Cardinal.toNat c = n ↔ c = ↑n
-- Cardinal.toNat_eq_ofNat
theorem toNat_eq_ofNat {n : ℕ} [Nat.AtLeastTwo n] :
    toNat c = OfNat.ofNat n ↔ c = OfNat.ofNat n 
Arguments: {c : Cardinal.{u}} {n : ℕ} [n.AtLeastTwo]
Goal: Cardinal.toNat c = OfNat.ofNat n ↔ c = OfNat.ofNat n
-- Cardinal.toNat_eq_one
@[simp]
theorem toNat_eq_one : toNat c = 1 ↔ c = 1 
Arguments: {c : Cardinal.{u}}
Goal: Cardinal.toNat c = 1 ↔ c = 1
-- Cardinal.toNat_eq_one_iff_unique
theorem toNat_eq_one_iff_unique : toNat #α = 1 ↔ Subsingleton α ∧ Nonempty α 
Arguments: {α : Type u}
Goal: Cardinal.toNat (Cardinal.mk α) = 1 ↔ Subsingleton α ∧ Nonempty α
-- Cardinal.toNat_lift
@[simp]
theorem toNat_lift (c : Cardinal.{v}) : toNat (lift.{u, v} c) = toNat c 
Arguments: (c : Cardinal.{v})
Goal: Cardinal.toNat (Cardinal.lift.{u, v} c) = Cardinal.toNat c
-- Cardinal.toNat_congr
theorem toNat_congr {β : Type v} (e : α ≃ β) : toNat #α = toNat #β 
Arguments: {α : Type u} {β : Type v} (e : α ≃ β)
Goal: Cardinal.toNat (Cardinal.mk α) = Cardinal.toNat (Cardinal.mk β)
-- Cardinal.toNat_mul
theorem toNat_mul (x y : Cardinal) : toNat (x * y) = toNat x * toNat y 
Arguments: (x y : Cardinal.{u_1})
Goal: Cardinal.toNat (x * y) = Cardinal.toNat x * Cardinal.toNat y
-- Cardinal.toNat_finset_prod
@[deprecated map_prod (since := "2024-02-15")]
theorem toNat_finset_prod (s : Finset α) (f : α → Cardinal) :
    toNat (∏ i ∈ s, f i) = ∏ i ∈ s, toNat (f i) 
Arguments: {α : Type u} (s : Finset α) (f : α → Cardinal.{u_1})
Goal: Cardinal.toNat (∏ i ∈ s, f i) = ∏ i ∈ s, Cardinal.toNat (f i)
-- Cardinal.toNat_add
@[simp]
theorem toNat_add (hc : c < ℵ₀) (hd : d < ℵ₀) : toNat (c + d) = toNat c + toNat d 
Arguments: {c d : Cardinal.{u}} (hc : c < Cardinal.aleph0) (hd : d < Cardinal.aleph0)
Goal: Cardinal.toNat (c + d) = Cardinal.toNat c + Cardinal.toNat d
-- Cardinal.toNat_lift_add_lift
@[simp]
theorem toNat_lift_add_lift {a : Cardinal.{u}} {b : Cardinal.{v}} (ha : a < ℵ₀) (hb : b < ℵ₀) :
    toNat (lift.{v} a + lift.{u} b) = toNat a + toNat b 
Arguments: {a : Cardinal.{u}} {b : Cardinal.{v}} (ha : a < Cardinal.aleph0) (hb : b < Cardinal.aleph0)
Goal: Cardinal.toNat (Cardinal.lift.{v, u} a + Cardinal.lift.{u, v} b) = Cardinal.toNat a + Cardinal.toNat b
-- Path.Homotopy.continuous_reflTransSymmAux
@[continuity]
theorem continuous_reflTransSymmAux : Continuous reflTransSymmAux 
Goal: Continuous Path.Homotopy.reflTransSymmAux
-- Path.Homotopy.reflTransSymmAux_mem_I
theorem reflTransSymmAux_mem_I (x : I × I) : reflTransSymmAux x ∈ I 
Arguments: (x : ↑I × ↑I)
Goal: Path.Homotopy.reflTransSymmAux x ∈ I
-- Path.Homotopy.continuous_transReflReparamAux
@[continuity]
theorem continuous_transReflReparamAux : Continuous transReflReparamAux 
Goal: Continuous Path.Homotopy.transReflReparamAux
-- Path.Homotopy.transReflReparamAux_mem_I
theorem transReflReparamAux_mem_I (t : I) : transReflReparamAux t ∈ I 
Arguments: (t : ↑I)
Goal: Path.Homotopy.transReflReparamAux t ∈ I
-- Path.Homotopy.transReflReparamAux_zero
theorem transReflReparamAux_zero : transReflReparamAux 0 = 0 
Goal: Path.Homotopy.transReflReparamAux 0 = 0
-- Path.Homotopy.transReflReparamAux_one
theorem transReflReparamAux_one : transReflReparamAux 1 = 1 
Goal: Path.Homotopy.transReflReparamAux 1 = 1
-- Path.Homotopy.trans_refl_reparam
theorem trans_refl_reparam (p : Path x₀ x₁) :
    p.trans (Path.refl x₁) =
      p.reparam (fun t => ⟨transReflReparamAux t, transReflReparamAux_mem_I t⟩) (by continuity)
        (Subtype.ext transReflReparamAux_zero) (Subtype.ext transReflReparamAux_one) 
Arguments: {X : Type u} [TopologicalSpace X] {x₀ x₁ : X} (p : Path x₀ x₁)
Goal: p.trans (Path.refl x₁) = p.reparam (fun t => ⟨Path.Homotopy.transReflReparamAux t, ⋯⟩) ⋯ ⋯ ⋯
-- Path.Homotopy.continuous_transAssocReparamAux
@[continuity]
theorem continuous_transAssocReparamAux : Continuous transAssocReparamAux 
Goal: Continuous Path.Homotopy.transAssocReparamAux
-- Path.Homotopy.transAssocReparamAux_mem_I
theorem transAssocReparamAux_mem_I (t : I) : transAssocReparamAux t ∈ I 
Arguments: (t : ↑I)
Goal: Path.Homotopy.transAssocReparamAux t ∈ I
-- Path.Homotopy.transAssocReparamAux_zero
theorem transAssocReparamAux_zero : transAssocReparamAux 0 = 0 
Goal: Path.Homotopy.transAssocReparamAux 0 = 0
-- Path.Homotopy.transAssocReparamAux_one
theorem transAssocReparamAux_one : transAssocReparamAux 1 = 1 
Goal: Path.Homotopy.transAssocReparamAux 1 = 1
-- Path.Homotopy.trans_assoc_reparam
theorem trans_assoc_reparam {x₀ x₁ x₂ x₃ : X} (p : Path x₀ x₁) (q : Path x₁ x₂) (r : Path x₂ x₃) :
    (p.trans q).trans r =
      (p.trans (q.trans r)).reparam
        (fun t => ⟨transAssocReparamAux t, transAssocReparamAux_mem_I t⟩) (by continuity)
        (Subtype.ext transAssocReparamAux_zero) (Subtype.ext transAssocReparamAux_one) 
Arguments: {X : Type u} [TopologicalSpace X] {x₀ x₁ x₂ x₃ : X} (p : Path x₀ x₁) (q : Path x₁ x₂) (r : Path x₂ x₃)
Goal: (p.trans q).trans r = (p.trans (q.trans r)).reparam (fun t => ⟨Path.Homotopy.transAssocReparamAux t, ⋯⟩) ⋯ ⋯ ⋯
-- FundamentalGroupoid.equiv_apply
@[simps]
def equiv (X : Type*) : FundamentalGroupoid X ≃ X 
Arguments: (X : Type u_1) (x : FundamentalGroupoid X)
Goal: (FundamentalGroupoid.equiv X) x = x.as
-- FundamentalGroupoid.equiv_symm_apply_as
@[simps]
def equiv (X : Type*) : FundamentalGroupoid X ≃ X 
Arguments: (X : Type u_1) (x : X)
Goal: ((FundamentalGroupoid.equiv X).symm x).as = x
-- FundamentalGroupoid.isEmpty_iff
@[simp]
lemma isEmpty_iff (X : Type*) :
    IsEmpty (FundamentalGroupoid X) ↔ IsEmpty X 
Arguments: (X : Type u_1)
Goal: IsEmpty (FundamentalGroupoid X) ↔ IsEmpty X
-- FundamentalGroupoid.nonempty_iff
@[simp]
lemma nonempty_iff (X : Type*) :
    Nonempty (FundamentalGroupoid X) ↔ Nonempty X 
Arguments: (X : Type u_1)
Goal: Nonempty (FundamentalGroupoid X) ↔ Nonempty X
-- FundamentalGroupoid.subsingleton_iff
@[simp]
lemma subsingleton_iff (X : Type*) :
    Subsingleton (FundamentalGroupoid X) ↔ Subsingleton X 
Arguments: (X : Type u_1)
Goal: Subsingleton (FundamentalGroupoid X) ↔ Subsingleton X
-- FundamentalGroupoid.comp_eq
theorem comp_eq (x y z : FundamentalGroupoid X) (p : x ⟶ y) (q : y ⟶ z) : p ≫ q = p.comp q 
Arguments: {X : Type u} [TopologicalSpace X] (x y z : FundamentalGroupoid X) (p : x ⟶ y) (q : y ⟶ z)
Goal: p ≫ q = Path.Homotopic.Quotient.comp p q
-- FundamentalGroupoid.id_eq_path_refl
theorem id_eq_path_refl (x : FundamentalGroupoid X) : 𝟙 x = ⟦Path.refl x.as⟧ 
Arguments: {X : Type u} [TopologicalSpace X] (x : FundamentalGroupoid X)
Goal: 𝟙 x = ⟦Path.refl x.as⟧
-- FundamentalGroupoid.map_eq
theorem map_eq {X Y : TopCat} {x₀ x₁ : X} (f : C(X, Y)) (p : Path.Homotopic.Quotient x₀ x₁) :
    (πₘ f).map p = p.mapFn f 
Arguments: {X Y : TopCat} {x₀ x₁ : ↑X} (f : C(↑X, ↑Y)) (p : Path.Homotopic.Quotient x₀ x₁)
Goal: (FundamentalGroupoid.fundamentalGroupoidFunctor.map f).map p = p.mapFn f
-- AlgebraicTopology.DoldKan.HigherFacesVanish.comp_δ_eq_zero
@[reassoc]
theorem comp_δ_eq_zero {Y : C} {n : ℕ} {q : ℕ} {φ : Y ⟶ X _[n + 1]} (v : HigherFacesVanish q φ)
    (j : Fin (n + 2)) (hj₁ : j ≠ 0) (hj₂ : n + 2 ≤ (j : ℕ) + q) : φ ≫ X.δ j = 0 
Arguments: {C : Type u_1} [CategoryTheory.Category.{u_2, u_1} C] [CategoryTheory.Preadditive C] {X : CategoryTheory.SimplicialObject C} {Y : C} {n q : ℕ} {φ : Y ⟶ X _[n + 1]} (v : AlgebraicTopology.DoldKan.HigherFacesVanish q φ) (j : Fin (n + 2)) (hj₁ : j ≠ 0) (hj₂ : n + 2 ≤ ↑j + q)
Goal: φ ≫ X.δ j = 0
-- AlgebraicTopology.DoldKan.HigherFacesVanish.of_succ
theorem of_succ {Y : C} {n q : ℕ} {φ : Y ⟶ X _[n + 1]} (v : HigherFacesVanish (q + 1) φ) :
    HigherFacesVanish q φ 
Arguments: {C : Type u_1} [CategoryTheory.Category.{u_2, u_1} C] [CategoryTheory.Preadditive C] {X : CategoryTheory.SimplicialObject C} {Y : C} {n q : ℕ} {φ : Y ⟶ X _[n + 1]} (v : AlgebraicTopology.DoldKan.HigherFacesVanish (q + 1) φ)
Goal: AlgebraicTopology.DoldKan.HigherFacesVanish q φ
-- AlgebraicTopology.DoldKan.HigherFacesVanish.of_comp
theorem of_comp {Y Z : C} {q n : ℕ} {φ : Y ⟶ X _[n + 1]} (v : HigherFacesVanish q φ) (f : Z ⟶ Y) :
    HigherFacesVanish q (f ≫ φ) 
Arguments: {C : Type u_1} [CategoryTheory.Category.{u_2, u_1} C] [CategoryTheory.Preadditive C] {X : CategoryTheory.SimplicialObject C} {Y Z : C} {q n : ℕ} {φ : Y ⟶ X _[n + 1]} (v : AlgebraicTopology.DoldKan.HigherFacesVanish q φ) (f : Z ⟶ Y)
Goal: AlgebraicTopology.DoldKan.HigherFacesVanish q (f ≫ φ)
-- AlgebraicTopology.DoldKan.HigherFacesVanish.comp_Hσ_eq
theorem comp_Hσ_eq {Y : C} {n a q : ℕ} {φ : Y ⟶ X _[n + 1]} (v : HigherFacesVanish q φ)
    (hnaq : n = a + q) :
    φ ≫ (Hσ q).f (n + 1) =
      -φ ≫ X.δ ⟨a + 1, Nat.succ_lt_succ (Nat.lt_succ_iff.mpr (Nat.le.intro hnaq.symm))⟩ ≫
        X.σ ⟨a, Nat.lt_succ_iff.mpr (Nat.le.intro hnaq.symm)⟩ 
Arguments: {C : Type u_1} [CategoryTheory.Category.{u_2, u_1} C] [CategoryTheory.Preadditive C] {X : CategoryTheory.SimplicialObject C} {Y : C} {n a q : ℕ} {φ : Y ⟶ X _[n + 1]} (v : AlgebraicTopology.DoldKan.HigherFacesVanish q φ) (hnaq : n = a + q)
Goal: φ ≫ (AlgebraicTopology.DoldKan.Hσ q).f (n + 1) = -φ ≫ X.δ ⟨a + 1, ⋯⟩ ≫ X.σ ⟨a, ⋯⟩
-- AlgebraicTopology.DoldKan.HigherFacesVanish.comp_Hσ_eq_zero
theorem comp_Hσ_eq_zero {Y : C} {n q : ℕ} {φ : Y ⟶ X _[n + 1]} (v : HigherFacesVanish q φ)
    (hqn : n < q) : φ ≫ (Hσ q).f (n + 1) = 0 
Arguments: {C : Type u_1} [CategoryTheory.Category.{u_2, u_1} C] [CategoryTheory.Preadditive C] {X : CategoryTheory.SimplicialObject C} {Y : C} {n q : ℕ} {φ : Y ⟶ X _[n + 1]} (v : AlgebraicTopology.DoldKan.HigherFacesVanish q φ) (hqn : n < q)
Goal: φ ≫ (AlgebraicTopology.DoldKan.Hσ q).f (n + 1) = 0
-- AlgebraicTopology.DoldKan.HigherFacesVanish.induction
theorem induction {Y : C} {n q : ℕ} {φ : Y ⟶ X _[n + 1]} (v : HigherFacesVanish q φ) :
    HigherFacesVanish (q + 1) (φ ≫ (𝟙 _ + Hσ q).f (n + 1)) 
Arguments: {C : Type u_1} [CategoryTheory.Category.{u_2, u_1} C] [CategoryTheory.Preadditive C] {X : CategoryTheory.SimplicialObject C} {Y : C} {n q : ℕ} {φ : Y ⟶ X _[n + 1]} (v : AlgebraicTopology.DoldKan.HigherFacesVanish q φ)
Goal: AlgebraicTopology.DoldKan.HigherFacesVanish (q + 1)
  (φ ≫ (𝟙 (AlgebraicTopology.AlternatingFaceMapComplex.obj X) + AlgebraicTopology.DoldKan.Hσ q).f (n + 1))
-- SetTheory.PGame.Domineering.shiftUp_apply
@[simps!]
def shiftUp : ℤ × ℤ ≃ ℤ × ℤ 
Goal: ∀ (a : ℤ × ℤ), SetTheory.PGame.Domineering.shiftUp a = Prod.map id (fun x => x + 1) a