ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
-- Cardinal.eq
protected theorem eq : #α = #β ↔ Nonempty (α ≃ β) 
Arguments: {α β : Type u}
Goal: Cardinal.mk α = Cardinal.mk β ↔ Nonempty (α ≃ β)
-- Cardinal.mk'_def
@[simp]
theorem mk'_def (α : Type u) : @Eq Cardinal ⟦α⟧ #α 
Arguments: (α : Type u)
Goal: ⟦α⟧ = Cardinal.mk α
-- Cardinal.mk_out
@[simp]
theorem mk_out (c : Cardinal) : #c.out = c 
Arguments: (c : Cardinal.{u_1})
Goal: Cardinal.mk (Quotient.out c) = c
-- Cardinal.mk_congr
theorem mk_congr (e : α ≃ β) : #α = #β 
Arguments: {α β : Type u} (e : α ≃ β)
Goal: Cardinal.mk α = Cardinal.mk β
-- Cardinal.map_mk
@[simp]
theorem map_mk (f : Type u → Type v) (hf : ∀ α β, α ≃ β → f α ≃ f β) (α : Type u) :
    map f hf #α = #(f α) 
Arguments: (f : Type u → Type v) (hf : (α β : Type u) → α ≃ β → f α ≃ f β) (α : Type u)
Goal: Cardinal.map f hf (Cardinal.mk α) = Cardinal.mk (f α)
-- Cardinal.mk_uLift
@[simp]
theorem mk_uLift (α) : #(ULift.{v, u} α) = lift.{v} #α 
Arguments: (α : Type u)
Goal: Cardinal.mk (ULift.{v, u} α) = Cardinal.lift.{v, u} (Cardinal.mk α)
-- Cardinal.lift_umax
@[simp, nolint simpNF]
theorem lift_umax : lift.{max u v, u} = lift.{v, u} 
Goal: Cardinal.lift.{max u v, u} = Cardinal.lift.{v, u}
-- Cardinal.lift_umax'
@[simp, nolint simpNF]
theorem lift_umax' : lift.{max v u, u} = lift.{v, u} 
Goal: Cardinal.lift.{max v u, u} = Cardinal.lift.{v, u}
-- Cardinal.lift_id'
@[simp, nolint simpNF]
theorem lift_id' (a : Cardinal.{max u v}) : lift.{u} a = a 
Arguments: (a : Cardinal.{max u v})
Goal: Cardinal.lift.{u, max u v} a = a
-- Cardinal.lift_id
@[simp]
theorem lift_id (a : Cardinal) : lift.{u, u} a = a 
Arguments: (a : Cardinal.{u})
Goal: Cardinal.lift.{u, u} a = a
-- Cardinal.lift_uzero
-- porting note (#10618): simp can prove this
-- @[simp]
theorem lift_uzero (a : Cardinal.{u}) : lift.{0} a = a 
Arguments: (a : Cardinal.{u})
Goal: Cardinal.lift.{0, u} a = a
-- Cardinal.lift_lift
@[simp]
theorem lift_lift.{u_1} (a : Cardinal.{u_1}) : lift.{w} (lift.{v} a) = lift.{max v w} a 
Arguments: (a : Cardinal.{u_1})
Goal: Cardinal.lift.{w, max v u_1} (Cardinal.lift.{v, u_1} a) = Cardinal.lift.{max v w, u_1} a
-- Cardinal.le_def
theorem le_def (α β : Type u) : #α ≤ #β ↔ Nonempty (α ↪ β) 
Arguments: (α β : Type u)
Goal: Cardinal.mk α ≤ Cardinal.mk β ↔ Nonempty (α ↪ β)
-- Cardinal.mk_le_of_injective
theorem mk_le_of_injective {α β : Type u} {f : α → β} (hf : Injective f) : #α ≤ #β 
Arguments: {α β : Type u} {f : α → β} (hf : Function.Injective f)
Goal: Cardinal.mk α ≤ Cardinal.mk β
-- Function.Embedding.cardinal_le
theorem _root_.Function.Embedding.cardinal_le {α β : Type u} (f : α ↪ β) : #α ≤ #β 
Arguments: {α β : Type u} (f : α ↪ β)
Goal: Cardinal.mk α ≤ Cardinal.mk β
-- Cardinal.mk_le_of_surjective
theorem mk_le_of_surjective {α β : Type u} {f : α → β} (hf : Surjective f) : #β ≤ #α 
Arguments: {α β : Type u} {f : α → β} (hf : Function.Surjective f)
Goal: Cardinal.mk β ≤ Cardinal.mk α
-- Cardinal.le_mk_iff_exists_set
theorem le_mk_iff_exists_set {c : Cardinal} {α : Type u} : c ≤ #α ↔ ∃ p : Set α, #p = c 
Arguments: {c : Cardinal.{u}} {α : Type u}
Goal: c ≤ Cardinal.mk α ↔ ∃ p, Cardinal.mk ↑p = c
-- Cardinal.mk_subtype_le
theorem mk_subtype_le {α : Type u} (p : α → Prop) : #(Subtype p) ≤ #α 
Arguments: {α : Type u} (p : α → Prop)
Goal: Cardinal.mk (Subtype p) ≤ Cardinal.mk α
-- Cardinal.mk_set_le
theorem mk_set_le (s : Set α) : #s ≤ #α 
Arguments: {α : Type u} (s : Set α)
Goal: Cardinal.mk ↑s ≤ Cardinal.mk α
-- Cardinal.mk_preimage_down
@[simp]
lemma mk_preimage_down {s : Set α} : #(ULift.down.{v} ⁻¹' s) = lift.{v} (#s) 
Arguments: {α : Type u} {s : Set α}
Goal: Cardinal.mk ↑(ULift.down ⁻¹' s) = Cardinal.lift.{v, u} (Cardinal.mk ↑s)
-- Cardinal.out_embedding
theorem out_embedding {c c' : Cardinal} : c ≤ c' ↔ Nonempty (c.out ↪ c'.out) 
Arguments: {c c' : Cardinal.{u_1}}
Goal: c ≤ c' ↔ Nonempty (Quotient.out c ↪ Quotient.out c')
-- Cardinal.lift_mk_le
theorem lift_mk_le {α : Type v} {β : Type w} :
    lift.{max u w} #α ≤ lift.{max u v} #β ↔ Nonempty (α ↪ β) 
Arguments: {α : Type v} {β : Type w}
Goal: Cardinal.lift.{max u w, v} (Cardinal.mk α) ≤ Cardinal.lift.{max u v, w} (Cardinal.mk β) ↔ Nonempty (α ↪ β)
-- Cardinal.lift_mk_le'
theorem lift_mk_le' {α : Type u} {β : Type v} : lift.{v} #α ≤ lift.{u} #β ↔ Nonempty (α ↪ β) 
Arguments: {α : Type u} {β : Type v}
Goal: Cardinal.lift.{v, u} (Cardinal.mk α) ≤ Cardinal.lift.{u, v} (Cardinal.mk β) ↔ Nonempty (α ↪ β)
-- Cardinal.lift_mk_eq
theorem lift_mk_eq {α : Type u} {β : Type v} :
    lift.{max v w} #α = lift.{max u w} #β ↔ Nonempty (α ≃ β) 
Arguments: {α : Type u} {β : Type v}
Goal: Cardinal.lift.{max v w, u} (Cardinal.mk α) = Cardinal.lift.{max u w, v} (Cardinal.mk β) ↔ Nonempty (α ≃ β)
-- Cardinal.lift_mk_eq'
theorem lift_mk_eq' {α : Type u} {β : Type v} : lift.{v} #α = lift.{u} #β ↔ Nonempty (α ≃ β) 
Arguments: {α : Type u} {β : Type v}
Goal: Cardinal.lift.{v, u} (Cardinal.mk α) = Cardinal.lift.{u, v} (Cardinal.mk β) ↔ Nonempty (α ≃ β)
-- Cardinal.lift_le
@[simp]
theorem lift_le {a b : Cardinal.{v}} : lift.{u, v} a ≤ lift.{u, v} b ↔ a ≤ b 
Arguments: {a b : Cardinal.{v}}
Goal: Cardinal.lift.{u, v} a ≤ Cardinal.lift.{u, v} b ↔ a ≤ b
-- Cardinal.liftOrderEmbedding_apply
@[simps! (config := .asFn)]
def liftOrderEmbedding : Cardinal.{v} ↪o Cardinal.{max v u} 
Goal: ⇑Cardinal.liftOrderEmbedding = Cardinal.lift.{u, v}
-- Cardinal.lift_injective
theorem lift_injective : Injective lift.{u, v} 
Goal: Function.Injective Cardinal.lift.{u, v}
-- Cardinal.lift_inj
@[simp]
theorem lift_inj {a b : Cardinal.{u}} : lift.{v, u} a = lift.{v, u} b ↔ a = b 
Arguments: {a b : Cardinal.{u}}
Goal: Cardinal.lift.{v, u} a = Cardinal.lift.{v, u} b ↔ a = b
-- Cardinal.lift_lt
@[simp]
theorem lift_lt {a b : Cardinal.{u}} : lift.{v, u} a < lift.{v, u} b ↔ a < b 
Arguments: {a b : Cardinal.{u}}
Goal: Cardinal.lift.{v, u} a < Cardinal.lift.{v, u} b ↔ a < b
-- Cardinal.lift_strictMono
theorem lift_strictMono : StrictMono lift 
Goal: StrictMono Cardinal.lift.{u_2, u_1}
-- Cardinal.lift_monotone
theorem lift_monotone : Monotone lift 
Goal: Monotone Cardinal.lift.{u_2, u_1}
-- Cardinal.mk_eq_zero
@[simp]
theorem mk_eq_zero (α : Type u) [IsEmpty α] : #α = 0 
Arguments: (α : Type u) [IsEmpty α]
Goal: Cardinal.mk α = 0
-- Cardinal.lift_zero
@[simp]
theorem lift_zero : lift 0 = 0 
Goal: Cardinal.lift.{u_2, u_1} 0 = 0
-- Cardinal.lift_eq_zero
@[simp]
theorem lift_eq_zero {a : Cardinal.{v}} : lift.{u} a = 0 ↔ a = 0 
Arguments: {a : Cardinal.{v}}
Goal: Cardinal.lift.{u, v} a = 0 ↔ a = 0
-- Cardinal.mk_eq_zero_iff
theorem mk_eq_zero_iff {α : Type u} : #α = 0 ↔ IsEmpty α 
Arguments: {α : Type u}
Goal: Cardinal.mk α = 0 ↔ IsEmpty α
-- Cardinal.mk_ne_zero_iff
theorem mk_ne_zero_iff {α : Type u} : #α ≠ 0 ↔ Nonempty α 
Arguments: {α : Type u}
Goal: Cardinal.mk α ≠ 0 ↔ Nonempty α
-- Cardinal.mk_ne_zero
@[simp]
theorem mk_ne_zero (α : Type u) [Nonempty α] : #α ≠ 0 
Arguments: (α : Type u) [Nonempty α]
Goal: Cardinal.mk α ≠ 0
-- Cardinal.mk_eq_one
theorem mk_eq_one (α : Type u) [Unique α] : #α = 1 
Arguments: (α : Type u) [Unique α]
Goal: Cardinal.mk α = 1
-- Cardinal.le_one_iff_subsingleton
theorem le_one_iff_subsingleton {α : Type u} : #α ≤ 1 ↔ Subsingleton α 
Arguments: {α : Type u}
Goal: Cardinal.mk α ≤ 1 ↔ Subsingleton α
-- Cardinal.mk_le_one_iff_set_subsingleton
@[simp]
theorem mk_le_one_iff_set_subsingleton {s : Set α} : #s ≤ 1 ↔ s.Subsingleton 
Arguments: {α : Type u} {s : Set α}
Goal: Cardinal.mk ↑s ≤ 1 ↔ s.Subsingleton
-- Cardinal.add_def
theorem add_def (α β : Type u) : #α + #β = #(α ⊕ β) 
Arguments: (α β : Type u)
Goal: Cardinal.mk α + Cardinal.mk β = Cardinal.mk (α ⊕ β)
-- Cardinal.mk_sum
@[simp]
theorem mk_sum (α : Type u) (β : Type v) : #(α ⊕ β) = lift.{v, u} #α + lift.{u, v} #β 
Arguments: (α : Type u) (β : Type v)
Goal: Cardinal.mk (α ⊕ β) = Cardinal.lift.{v, u} (Cardinal.mk α) + Cardinal.lift.{u, v} (Cardinal.mk β)
-- Cardinal.mk_option
@[simp]
theorem mk_option {α : Type u} : #(Option α) = #α + 1 
Arguments: {α : Type u}
Goal: Cardinal.mk (Option α) = Cardinal.mk α + 1
-- Cardinal.mk_psum
@[simp]
theorem mk_psum (α : Type u) (β : Type v) : #(α ⊕' β) = lift.{v} #α + lift.{u} #β 
Arguments: (α : Type u) (β : Type v)
Goal: Cardinal.mk (α ⊕' β) = Cardinal.lift.{v, u} (Cardinal.mk α) + Cardinal.lift.{u, v} (Cardinal.mk β)
-- Cardinal.mk_fintype
@[simp]
theorem mk_fintype (α : Type u) [h : Fintype α] : #α = Fintype.card α 
Arguments: (α : Type u) [h : Fintype α]
Goal: Cardinal.mk α = ↑(Fintype.card α)
-- Cardinal.cast_succ
protected theorem cast_succ (n : ℕ) : ((n + 1 : ℕ) : Cardinal.{u}) = n + 1 
Arguments: (n : ℕ)
Goal: ↑(n + 1) = ↑n + 1
-- Cardinal.mul_def
theorem mul_def (α β : Type u) : #α * #β = #(α × β) 
Arguments: (α β : Type u)
Goal: Cardinal.mk α * Cardinal.mk β = Cardinal.mk (α × β)
-- Cardinal.mk_prod
@[simp]
theorem mk_prod (α : Type u) (β : Type v) : #(α × β) = lift.{v, u} #α * lift.{u, v} #β 
Arguments: (α : Type u) (β : Type v)
Goal: Cardinal.mk (α × β) = Cardinal.lift.{v, u} (Cardinal.mk α) * Cardinal.lift.{u, v} (Cardinal.mk β)
-- _private.Mathlib.SetTheory.Cardinal.Basic.0.Cardinal.mul_comm'
private theorem mul_comm' (a b : Cardinal.{u}) : a * b = b * a 
Arguments: (a b : Cardinal.{u})
Goal: a * b = b * a
-- Cardinal.power_def
theorem power_def (α β : Type u) : #α ^ #β = #(β → α) 
Arguments: (α β : Type u)
Goal: Cardinal.mk α ^ Cardinal.mk β = Cardinal.mk (β → α)
-- Cardinal.mk_arrow
theorem mk_arrow (α : Type u) (β : Type v) : #(α → β) = (lift.{u} #β^lift.{v} #α) 
Arguments: (α : Type u) (β : Type v)
Goal: Cardinal.mk (α → β) = Cardinal.lift.{u, v} (Cardinal.mk β) ^ Cardinal.lift.{v, u} (Cardinal.mk α)
-- Cardinal.lift_power
@[simp]
theorem lift_power (a b : Cardinal.{u}) : lift.{v} (a ^ b) = lift.{v} a ^ lift.{v} b 
Arguments: (a b : Cardinal.{u})
Goal: Cardinal.lift.{v, u} (a ^ b) = Cardinal.lift.{v, u} a ^ Cardinal.lift.{v, u} b
-- Cardinal.power_zero
@[simp]
theorem power_zero {a : Cardinal} : a ^ (0 : Cardinal) = 1 
Arguments: {a : Cardinal.{u_1}}
Goal: a ^ 0 = 1
-- Cardinal.power_one
@[simp]
theorem power_one {a : Cardinal.{u}} : a ^ (1 : Cardinal) = a 
Arguments: {a : Cardinal.{u}}
Goal: a ^ 1 = a
-- Cardinal.power_add
theorem power_add {a b c : Cardinal} : a ^ (b + c) = a ^ b * a ^ c 
Arguments: {a b c : Cardinal.{u_1}}
Goal: a ^ (b + c) = a ^ b * a ^ c
-- Cardinal.one_power
@[simp]
theorem one_power {a : Cardinal} : (1 : Cardinal) ^ a = 1 
Arguments: {a : Cardinal.{u_1}}
Goal: 1 ^ a = 1
-- Cardinal.mk_bool
theorem mk_bool : #Bool = 2 
Goal: Cardinal.mk Bool = 2
-- Cardinal.mk_Prop
theorem mk_Prop : #Prop = 2 
Goal: Cardinal.mk Prop = 2
-- Cardinal.zero_power
@[simp]
theorem zero_power {a : Cardinal} : a ≠ 0 → (0 : Cardinal) ^ a = 0 
Arguments: {a : Cardinal.{u_1}}
Goal: a ≠ 0 → 0 ^ a = 0
-- Cardinal.power_ne_zero
theorem power_ne_zero {a : Cardinal} (b : Cardinal) : a ≠ 0 → a ^ b ≠ 0 
Arguments: {a : Cardinal.{u_1}} (b : Cardinal.{u_1})
Goal: a ≠ 0 → a ^ b ≠ 0
-- Cardinal.mul_power
theorem mul_power {a b c : Cardinal} : (a * b) ^ c = a ^ c * b ^ c 
Arguments: {a b c : Cardinal.{u_1}}
Goal: (a * b) ^ c = a ^ c * b ^ c
-- Cardinal.power_mul
theorem power_mul {a b c : Cardinal} : a ^ (b * c) = (a ^ b) ^ c 
Arguments: {a b c : Cardinal.{u_1}}
Goal: a ^ (b * c) = (a ^ b) ^ c
-- Cardinal.pow_cast_right
@[simp]
theorem pow_cast_right (a : Cardinal.{u}) (n : ℕ) : a ^ (↑n : Cardinal.{u}) = a ^ n 
Arguments: (a : Cardinal.{u}) (n : ℕ)
Goal: a ^ ↑n = a ^ n
-- Cardinal.lift_one
@[simp]
theorem lift_one : lift 1 = 1 
Goal: Cardinal.lift.{u_2, u_1} 1 = 1
-- Cardinal.lift_eq_one
@[simp]
theorem lift_eq_one {a : Cardinal.{v}} : lift.{u} a = 1 ↔ a = 1 
Arguments: {a : Cardinal.{v}}
Goal: Cardinal.lift.{u, v} a = 1 ↔ a = 1
-- Cardinal.lift_add
@[simp]
theorem lift_add (a b : Cardinal.{u}) : lift.{v} (a + b) = lift.{v} a + lift.{v} b 
Arguments: (a b : Cardinal.{u})
Goal: Cardinal.lift.{v, u} (a + b) = Cardinal.lift.{v, u} a + Cardinal.lift.{v, u} b
-- Cardinal.lift_mul
@[simp]
theorem lift_mul (a b : Cardinal.{u}) : lift.{v} (a * b) = lift.{v} a * lift.{v} b 
Arguments: (a b : Cardinal.{u})
Goal: Cardinal.lift.{v, u} (a * b) = Cardinal.lift.{v, u} a * Cardinal.lift.{v, u} b
-- Cardinal.lift_two
theorem lift_two : lift.{u, v} 2 = 2 
Goal: Cardinal.lift.{u, v} 2 = 2
-- Cardinal.mk_set
@[simp]
theorem mk_set {α : Type u} : #(Set α) = 2 ^ #α 
Arguments: {α : Type u}
Goal: Cardinal.mk (Set α) = 2 ^ Cardinal.mk α
-- Cardinal.mk_powerset
@[simp]
theorem mk_powerset {α : Type u} (s : Set α) : #(↥(𝒫 s)) = 2 ^ #(↥s) 
Arguments: {α : Type u} (s : Set α)
Goal: Cardinal.mk ↑(𝒫 s) = 2 ^ Cardinal.mk ↑s
-- Cardinal.lift_two_power
theorem lift_two_power (a : Cardinal) : lift.{v} (2 ^ a) = 2 ^ lift.{v} a 
Arguments: (a : Cardinal.{u_1})
Goal: Cardinal.lift.{v, u_1} (2 ^ a) = 2 ^ Cardinal.lift.{v, u_1} a
-- Cardinal.zero_le
protected theorem zero_le : ∀ a : Cardinal, 0 ≤ a 
Arguments: (a : Cardinal.{u_1})
Goal: 0 ≤ a
-- _private.Mathlib.SetTheory.Cardinal.Basic.0.Cardinal.add_le_add'
private theorem add_le_add' : ∀ {a b c d : Cardinal}, a ≤ b → c ≤ d → a + c ≤ b + d 
Arguments: {a b c d : Cardinal.{u_1}}
Goal: a ≤ b → c ≤ d → a + c ≤ b + d
-- Cardinal.zero_power_le
theorem zero_power_le (c : Cardinal.{u}) : (0 : Cardinal.{u}) ^ c ≤ 1 
Arguments: (c : Cardinal.{u})
Goal: 0 ^ c ≤ 1
-- Cardinal.power_le_power_left
theorem power_le_power_left : ∀ {a b c : Cardinal}, a ≠ 0 → b ≤ c → a ^ b ≤ a ^ c 
Arguments: {a b c : Cardinal.{u_1}}
Goal: a ≠ 0 → b ≤ c → a ^ b ≤ a ^ c
-- Cardinal.self_le_power
theorem self_le_power (a : Cardinal) {b : Cardinal} (hb : 1 ≤ b) : a ≤ a ^ b 
Arguments: (a : Cardinal.{u_1}) {b : Cardinal.{u_1}} (hb : 1 ≤ b)
Goal: a ≤ a ^ b
-- Cardinal.cantor
theorem cantor (a : Cardinal.{u}) : a < 2 ^ a 
Arguments: (a : Cardinal.{u})
Goal: a < 2 ^ a
-- Cardinal.one_lt_iff_nontrivial
theorem one_lt_iff_nontrivial {α : Type u} : 1 < #α ↔ Nontrivial α 
Arguments: {α : Type u}
Goal: 1 < Cardinal.mk α ↔ Nontrivial α
-- Cardinal.power_le_max_power_one
theorem power_le_max_power_one {a b c : Cardinal} (h : b ≤ c) : a ^ b ≤ max (a ^ c) 1 
Arguments: {a b c : Cardinal.{u_1}} (h : b ≤ c)
Goal: a ^ b ≤ max (a ^ c) 1
-- Cardinal.power_le_power_right
theorem power_le_power_right {a b c : Cardinal} : a ≤ b → a ^ c ≤ b ^ c 
Arguments: {a b c : Cardinal.{u_1}}
Goal: a ≤ b → a ^ c ≤ b ^ c
-- Cardinal.power_pos
theorem power_pos {a : Cardinal} (b : Cardinal) (ha : 0 < a) : 0 < a ^ b 
Arguments: {a : Cardinal.{u_1}} (b : Cardinal.{u_1}) (ha : 0 < a)
Goal: 0 < a ^ b
-- Cardinal.lt_wf
protected theorem lt_wf : @WellFounded Cardinal.{u} (· < ·) 
Goal: WellFounded fun x x_1 => x < x_1
-- Cardinal.sInf_empty
@[simp]
theorem sInf_empty : sInf (∅ : Set Cardinal.{u}) = 0 
Goal: sInf ∅ = 0
-- Cardinal.sInf_eq_zero_iff
lemma sInf_eq_zero_iff {s : Set Cardinal} : sInf s = 0 ↔ s = ∅ ∨ ∃ a ∈ s, a = 0 
Arguments: {s : Set Cardinal.{u_1}}
Goal: sInf s = 0 ↔ s = ∅ ∨ ∃ a ∈ s, a = 0
-- Cardinal.iInf_eq_zero_iff
lemma iInf_eq_zero_iff {ι : Sort*} {f : ι → Cardinal} :
    (⨅ i, f i) = 0 ↔ IsEmpty ι ∨ ∃ i, f i = 0 
Arguments: {ι : Sort u_1} {f : ι → Cardinal.{u_2}}
Goal: ⨅ i, f i = 0 ↔ IsEmpty ι ∨ ∃ i, f i = 0
-- Cardinal.succ_def
theorem succ_def (c : Cardinal) : succ c = sInf { c' | c < c' } 
Arguments: (c : Cardinal.{u_1})
Goal: Order.succ c = sInf {c' | c < c'}
-- Cardinal.succ_pos
theorem succ_pos : ∀ c : Cardinal, 0 < succ c 
Arguments: (c : Cardinal.{u_1})
Goal: 0 < Order.succ c
-- Cardinal.succ_ne_zero
theorem succ_ne_zero (c : Cardinal) : succ c ≠ 0 
Arguments: (c : Cardinal.{u_1})
Goal: Order.succ c ≠ 0
-- Cardinal.add_one_le_succ
theorem add_one_le_succ (c : Cardinal.{u}) : c + 1 ≤ succ c 
Arguments: (c : Cardinal.{u})
Goal: c + 1 ≤ Order.succ c
-- Cardinal.IsLimit.ne_zero
protected theorem IsLimit.ne_zero {c} (h : IsLimit c) : c ≠ 0 
Arguments: {c : Cardinal.{u_1}} (h : c.IsLimit)
Goal: c ≠ 0
-- Cardinal.IsLimit.isSuccLimit
protected theorem IsLimit.isSuccLimit {c} (h : IsLimit c) : IsSuccLimit c 
Arguments: {c : Cardinal.{u_1}} (h : c.IsLimit)
Goal: Order.IsSuccLimit c
-- Cardinal.IsLimit.succ_lt
theorem IsLimit.succ_lt {x c} (h : IsLimit c) : x < c → succ x < c 
Arguments: {x c : Cardinal.{u_1}} (h : c.IsLimit)
Goal: x < c → Order.succ x < c
-- Cardinal.isSuccLimit_zero
theorem isSuccLimit_zero : IsSuccLimit (0 : Cardinal) 
Goal: Order.IsSuccLimit 0
-- Cardinal.le_sum
theorem le_sum {ι} (f : ι → Cardinal) (i) : f i ≤ sum f 
Arguments: {ι : Type u_1} (f : ι → Cardinal.{max u_1 u_2}) (i : ι)
Goal: f i ≤ Cardinal.sum f
-- Cardinal.mk_sigma
@[simp]
theorem mk_sigma {ι} (f : ι → Type*) : #(Σ i, f i) = sum fun i => #(f i) 
Arguments: {ι : Type u_2} (f : ι → Type u_1)
Goal: Cardinal.mk ((i : ι) × f i) = Cardinal.sum fun i => Cardinal.mk (f i)
-- Cardinal.sum_const
@[simp]
theorem sum_const (ι : Type u) (a : Cardinal.{v}) :
    (sum fun _ : ι => a) = lift.{v} #ι * lift.{u} a 
Arguments: (ι : Type u) (a : Cardinal.{v})
Goal: (Cardinal.sum fun x => a) = Cardinal.lift.{v, u} (Cardinal.mk ι) * Cardinal.lift.{u, v} a
-- Cardinal.sum_const'
theorem sum_const' (ι : Type u) (a : Cardinal.{u}) : (sum fun _ : ι => a) = #ι * a 
Arguments: (ι : Type u) (a : Cardinal.{u})
Goal: (Cardinal.sum fun x => a) = Cardinal.mk ι * a
-- Cardinal.sum_add_distrib
@[simp]
theorem sum_add_distrib {ι} (f g : ι → Cardinal) : sum (f + g) = sum f + sum g 
Arguments: {ι : Type u_1} (f g : ι → Cardinal.{u_2})
Goal: Cardinal.sum (f + g) = Cardinal.sum f + Cardinal.sum g
-- Cardinal.sum_add_distrib'
@[simp]
theorem sum_add_distrib' {ι} (f g : ι → Cardinal) :
    (Cardinal.sum fun i => f i + g i) = sum f + sum g 
Arguments: {ι : Type u_1} (f g : ι → Cardinal.{u_2})
Goal: (Cardinal.sum fun i => f i + g i) = Cardinal.sum f + Cardinal.sum g
-- Cardinal.lift_sum
@[simp]
theorem lift_sum {ι : Type u} (f : ι → Cardinal.{v}) :
    Cardinal.lift.{w} (Cardinal.sum f) = Cardinal.sum fun i => Cardinal.lift.{w} (f i) 
Arguments: {ι : Type u} (f : ι → Cardinal.{v})
Goal: Cardinal.lift.{w, max v u} (Cardinal.sum f) = Cardinal.sum fun i => Cardinal.lift.{w, v} (f i)
-- Cardinal.sum_le_sum
theorem sum_le_sum {ι} (f g : ι → Cardinal) (H : ∀ i, f i ≤ g i) : sum f ≤ sum g 
Arguments: {ι : Type u_1} (f g : ι → Cardinal.{u_2}) (H : ∀ (i : ι), f i ≤ g i)
Goal: Cardinal.sum f ≤ Cardinal.sum g
-- Cardinal.mk_le_mk_mul_of_mk_preimage_le
theorem mk_le_mk_mul_of_mk_preimage_le {c : Cardinal} (f : α → β) (hf : ∀ b : β, #(f ⁻¹' {b}) ≤ c) :
    #α ≤ #β * c 
Arguments: {α β : Type u} {c : Cardinal.{u}} (f : α → β) (hf : ∀ (b : β), Cardinal.mk ↑(f ⁻¹' {b}) ≤ c)
Goal: Cardinal.mk α ≤ Cardinal.mk β * c
-- Cardinal.lift_mk_le_lift_mk_mul_of_lift_mk_preimage_le
theorem lift_mk_le_lift_mk_mul_of_lift_mk_preimage_le {α : Type u} {β : Type v} {c : Cardinal}
    (f : α → β) (hf : ∀ b : β, lift.{v} #(f ⁻¹' {b}) ≤ c) : lift.{v} #α ≤ lift.{u} #β * c 
Arguments: {α : Type u} {β : Type v} {c : Cardinal.{max u v}} (f : α → β) (hf : ∀ (b : β), Cardinal.lift.{v, u} (Cardinal.mk ↑(f ⁻¹' {b})) ≤ c)
Goal: Cardinal.lift.{v, u} (Cardinal.mk α) ≤ Cardinal.lift.{u, v} (Cardinal.mk β) * c
-- Cardinal.bddAbove_range
theorem bddAbove_range {ι : Type u} (f : ι → Cardinal.{max u v}) : BddAbove (Set.range f) 
Arguments: {ι : Type u} (f : ι → Cardinal.{max u v})
Goal: BddAbove (Set.range f)
-- Cardinal.bddAbove_iff_small
theorem bddAbove_iff_small {s : Set Cardinal.{u}} : BddAbove s ↔ Small.{u} s 
Arguments: {s : Set Cardinal.{u}}
Goal: BddAbove s ↔ Small.{u, u + 1} ↑s
-- Cardinal.bddAbove_of_small
theorem bddAbove_of_small (s : Set Cardinal.{u}) [h : Small.{u} s] : BddAbove s 
Arguments: (s : Set Cardinal.{u}) [h : Small.{u, u + 1} ↑s]
Goal: BddAbove s
-- Cardinal.bddAbove_image
theorem bddAbove_image (f : Cardinal.{u} → Cardinal.{max u v}) {s : Set Cardinal.{u}}
    (hs : BddAbove s) : BddAbove (f '' s) 
Arguments: (f : Cardinal.{u} → Cardinal.{max u v}) {s : Set Cardinal.{u}} (hs : BddAbove s)
Goal: BddAbove (f '' s)
-- Cardinal.bddAbove_range_comp
theorem bddAbove_range_comp {ι : Type u} {f : ι → Cardinal.{v}} (hf : BddAbove (range f))
    (g : Cardinal.{v} → Cardinal.{max v w}) : BddAbove (range (g ∘ f)) 
Arguments: {ι : Type u} {f : ι → Cardinal.{v}} (hf : BddAbove (Set.range f)) (g : Cardinal.{v} → Cardinal.{max v w})
Goal: BddAbove (Set.range (g ∘ f))
-- Cardinal.iSup_le_sum
theorem iSup_le_sum {ι} (f : ι → Cardinal) : iSup f ≤ sum f 
Arguments: {ι : Type u_1} (f : ι → Cardinal.{max u_1 u_2})
Goal: iSup f ≤ Cardinal.sum f
-- Cardinal.sum_le_iSup_lift
theorem sum_le_iSup_lift {ι : Type u}
    (f : ι → Cardinal.{max u v}) : sum f ≤ Cardinal.lift #ι * iSup f 
Arguments: {ι : Type u} (f : ι → Cardinal.{max u v})
Goal: Cardinal.sum f ≤ Cardinal.lift.{v, u} (Cardinal.mk ι) * iSup f
-- Cardinal.sum_le_iSup
theorem sum_le_iSup {ι : Type u} (f : ι → Cardinal.{u}) : sum f ≤ #ι * iSup f 
Arguments: {ι : Type u} (f : ι → Cardinal.{u})
Goal: Cardinal.sum f ≤ Cardinal.mk ι * iSup f
-- Cardinal.sum_nat_eq_add_sum_succ
theorem sum_nat_eq_add_sum_succ (f : ℕ → Cardinal.{u}) :
    Cardinal.sum f = f 0 + Cardinal.sum fun i => f (i + 1) 
Arguments: (f : ℕ → Cardinal.{u})
Goal: Cardinal.sum f = f 0 + Cardinal.sum fun i => f (i + 1)
-- Cardinal.iSup_of_empty
protected theorem iSup_of_empty {ι} (f : ι → Cardinal) [IsEmpty ι] : iSup f = 0 
Arguments: {ι : Sort u_1} (f : ι → Cardinal.{u_2}) [IsEmpty ι]
Goal: iSup f = 0
-- Cardinal.exists_eq_of_iSup_eq_of_not_isSuccLimit
lemma exists_eq_of_iSup_eq_of_not_isSuccLimit
    {ι : Type u} (f : ι → Cardinal.{v}) (ω : Cardinal.{v})
    (hω : ¬ Order.IsSuccLimit ω)
    (h : ⨆ i : ι, f i = ω) : ∃ i, f i = ω 
Arguments: {ι : Type u} (f : ι → Cardinal.{v}) (ω : Cardinal.{v}) (hω : ¬Order.IsSuccLimit ω) (h : ⨆ i, f i = ω)
Goal: ∃ i, f i = ω
-- Cardinal.exists_eq_of_iSup_eq_of_not_isLimit
lemma exists_eq_of_iSup_eq_of_not_isLimit
    {ι : Type u} [hι : Nonempty ι] (f : ι → Cardinal.{v}) (hf : BddAbove (range f))
    (ω : Cardinal.{v}) (hω : ¬ ω.IsLimit)
    (h : ⨆ i : ι, f i = ω) : ∃ i, f i = ω 
Arguments: {ι : Type u} [hι : Nonempty ι] (f : ι → Cardinal.{v}) (hf : BddAbove (Set.range f)) (ω : Cardinal.{v}) (hω : ¬ω.IsLimit) (h : ⨆ i, f i = ω)
Goal: ∃ i, f i = ω
-- Cardinal.lift_mk_shrink
@[simp, nolint simpNF]
theorem lift_mk_shrink (α : Type u) [Small.{v} α] :
    Cardinal.lift.{max u w} #(Shrink.{v} α) = Cardinal.lift.{max v w} #α 
Arguments: (α : Type u) [Small.{v, u} α]
Goal: Cardinal.lift.{max u w, v} (Cardinal.mk (Shrink.{v, u} α)) = Cardinal.lift.{max v w, u} (Cardinal.mk α)
-- Cardinal.lift_mk_shrink'
@[simp]
theorem lift_mk_shrink' (α : Type u) [Small.{v} α] :
    Cardinal.lift.{u} #(Shrink.{v} α) = Cardinal.lift.{v} #α 
Arguments: (α : Type u) [Small.{v, u} α]
Goal: Cardinal.lift.{u, v} (Cardinal.mk (Shrink.{v, u} α)) = Cardinal.lift.{v, u} (Cardinal.mk α)
-- Cardinal.lift_mk_shrink''
@[simp]
theorem lift_mk_shrink'' (α : Type max u v) [Small.{v} α] :
    Cardinal.lift.{u} #(Shrink.{v} α) = #α 
Arguments: (α : Type (max u v)) [Small.{v, max u v} α]
Goal: Cardinal.lift.{u, v} (Cardinal.mk (Shrink.{v, max u v} α)) = Cardinal.mk α
-- Cardinal.mk_pi
@[simp]
theorem mk_pi {ι : Type u} (α : ι → Type v) : #(∀ i, α i) = prod fun i => #(α i) 
Arguments: {ι : Type u} (α : ι → Type v)
Goal: Cardinal.mk ((i : ι) → α i) = Cardinal.prod fun i => Cardinal.mk (α i)
-- Cardinal.prod_const
@[simp]
theorem prod_const (ι : Type u) (a : Cardinal.{v}) :
    (prod fun _ : ι => a) = lift.{u} a ^ lift.{v} #ι 
Arguments: (ι : Type u) (a : Cardinal.{v})
Goal: (Cardinal.prod fun x => a) = Cardinal.lift.{u, v} a ^ Cardinal.lift.{v, u} (Cardinal.mk ι)
-- Cardinal.prod_const'
theorem prod_const' (ι : Type u) (a : Cardinal.{u}) : (prod fun _ : ι => a) = a ^ #ι 
Arguments: (ι : Type u) (a : Cardinal.{u})
Goal: (Cardinal.prod fun x => a) = a ^ Cardinal.mk ι
-- Cardinal.prod_le_prod
theorem prod_le_prod {ι} (f g : ι → Cardinal) (H : ∀ i, f i ≤ g i) : prod f ≤ prod g 
Arguments: {ι : Type u_1} (f g : ι → Cardinal.{u_2}) (H : ∀ (i : ι), f i ≤ g i)
Goal: Cardinal.prod f ≤ Cardinal.prod g
-- Cardinal.prod_eq_zero
@[simp]
theorem prod_eq_zero {ι} (f : ι → Cardinal.{u}) : prod f = 0 ↔ ∃ i, f i = 0 
Arguments: {ι : Type u_1} (f : ι → Cardinal.{u})
Goal: Cardinal.prod f = 0 ↔ ∃ i, f i = 0
-- Cardinal.prod_ne_zero
theorem prod_ne_zero {ι} (f : ι → Cardinal) : prod f ≠ 0 ↔ ∀ i, f i ≠ 0 
Arguments: {ι : Type u_1} (f : ι → Cardinal.{u_2})
Goal: Cardinal.prod f ≠ 0 ↔ ∀ (i : ι), f i ≠ 0
-- Cardinal.lift_prod
@[simp]
theorem lift_prod {ι : Type u} (c : ι → Cardinal.{v}) :
    lift.{w} (prod c) = prod fun i => lift.{w} (c i) 
Arguments: {ι : Type u} (c : ι → Cardinal.{v})
Goal: Cardinal.lift.{w, max v u} (Cardinal.prod c) = Cardinal.prod fun i => Cardinal.lift.{w, v} (c i)