ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
-- Ordinal.lift.principalSeg_top
@[simp]
theorem lift.principalSeg_top : (lift.principalSeg.{u,v}).top = univ.{u,v} 
Goal: Ordinal.lift.principalSeg.top = Ordinal.univ.{u, v}
-- Ordinal.lift.principalSeg_top'
theorem lift.principalSeg_top' : lift.principalSeg.{u, u + 1}.top = @type Ordinal (· < ·) _ 
Goal: Ordinal.lift.principalSeg.top = Ordinal.type fun x x_1 => x < x_1
-- Cardinal.mk_ordinal_out
@[simp]
theorem mk_ordinal_out (o : Ordinal) : #o.out.α = o.card 
Arguments: (o : Ordinal.{u_3})
Goal: #(Quotient.out o).α = o.card
-- Cardinal.ord_eq_Inf
theorem ord_eq_Inf (α : Type u) : ord #α = ⨅ r : { r // IsWellOrder α r }, @type α r.1 r.2 
Arguments: (α : Type u)
Goal: (#α).ord = ⨅ r, Ordinal.type ↑r
-- Cardinal.ord_eq
theorem ord_eq (α) : ∃ (r : α → α → Prop) (wo : IsWellOrder α r), ord #α = @type α r wo 
Arguments: (α : Type u_3)
Goal: ∃ r, ∃ (wo : IsWellOrder α r), (#α).ord = Ordinal.type r
-- Cardinal.ord_le_type
theorem ord_le_type (r : α → α → Prop) [h : IsWellOrder α r] : ord #α ≤ type r 
Arguments: {α : Type u} (r : α → α → Prop) [h : IsWellOrder α r]
Goal: (#α).ord ≤ Ordinal.type r
-- Cardinal.ord_le
theorem ord_le {c o} : ord c ≤ o ↔ c ≤ o.card 
Arguments: {c : Cardinal.{u_3}} {o : Ordinal.{u_3}}
Goal: c.ord ≤ o ↔ c ≤ o.card
-- Cardinal.gc_ord_card
theorem gc_ord_card : GaloisConnection ord card 
Goal: GaloisConnection Cardinal.ord Ordinal.card
-- Cardinal.lt_ord
theorem lt_ord {c o} : o < ord c ↔ o.card < c 
Arguments: {c : Cardinal.{u_3}} {o : Ordinal.{u_3}}
Goal: o < c.ord ↔ o.card < c
-- Cardinal.card_ord
@[simp]
theorem card_ord (c) : (ord c).card = c 
Arguments: (c : Cardinal.{u_3})
Goal: c.ord.card = c
-- Cardinal.ord_card_le
theorem ord_card_le (o : Ordinal) : o.card.ord ≤ o 
Arguments: (o : Ordinal.{u_3})
Goal: o.card.ord ≤ o
-- Cardinal.lt_ord_succ_card
theorem lt_ord_succ_card (o : Ordinal) : o < (succ o.card).ord 
Arguments: (o : Ordinal.{u_3})
Goal: o < (Order.succ o.card).ord
-- Cardinal.card_le_iff
theorem card_le_iff {o : Ordinal} {c : Cardinal} : o.card ≤ c ↔ o < (succ c).ord 
Arguments: {o : Ordinal.{u_3}} {c : Cardinal.{u_3}}
Goal: o.card ≤ c ↔ o < (Order.succ c).ord
-- Cardinal.card_le_of_le_ord
lemma card_le_of_le_ord {o : Ordinal} {c : Cardinal} (ho : o ≤ c.ord) :
    o.card ≤ c 
Arguments: {o : Ordinal.{u_3}} {c : Cardinal.{u_3}} (ho : o ≤ c.ord)
Goal: o.card ≤ c
-- Cardinal.ord_strictMono
@[mono]
theorem ord_strictMono : StrictMono ord 
Goal: StrictMono Cardinal.ord
-- Cardinal.ord_mono
@[mono]
theorem ord_mono : Monotone ord 
Goal: Monotone Cardinal.ord
-- Cardinal.ord_le_ord
@[simp]
theorem ord_le_ord {c₁ c₂} : ord c₁ ≤ ord c₂ ↔ c₁ ≤ c₂ 
Arguments: {c₁ c₂ : Cardinal.{u_3}}
Goal: c₁.ord ≤ c₂.ord ↔ c₁ ≤ c₂
-- Cardinal.ord_lt_ord
@[simp]
theorem ord_lt_ord {c₁ c₂} : ord c₁ < ord c₂ ↔ c₁ < c₂ 
Arguments: {c₁ c₂ : Cardinal.{u_3}}
Goal: c₁.ord < c₂.ord ↔ c₁ < c₂
-- Cardinal.ord_zero
@[simp]
theorem ord_zero : ord 0 = 0 
Goal: Cardinal.ord 0 = 0
-- Cardinal.ord_nat
@[simp]
theorem ord_nat (n : ℕ) : ord n = n 
Arguments: (n : ℕ)
Goal: (↑n).ord = ↑n
-- Cardinal.ord_one
@[simp]
theorem ord_one : ord 1 = 1 
Goal: Cardinal.ord 1 = 1
-- Cardinal.ord_ofNat
@[simp]
theorem ord_ofNat (n : ℕ) [n.AtLeastTwo] : ord (no_index (OfNat.ofNat n)) = OfNat.ofNat n 
Arguments: (n : ℕ) [n.AtLeastTwo]
Goal: (OfNat.ofNat n).ord = OfNat.ofNat n
-- Cardinal.lift_ord
@[simp]
theorem lift_ord (c) : Ordinal.lift.{u,v} (ord c) = ord (lift.{u,v} c) 
Arguments: (c : Cardinal.{v})
Goal: Ordinal.lift.{u, v} c.ord = (Cardinal.lift.{u, v} c).ord
-- Cardinal.mk_ord_out
theorem mk_ord_out (c : Cardinal) : #c.ord.out.α = c 
Arguments: (c : Cardinal.{u_3})
Goal: #(Quotient.out c.ord).α = c
-- Cardinal.card_typein_lt
theorem card_typein_lt (r : α → α → Prop) [IsWellOrder α r] (x : α) (h : ord #α = type r) :
    card (typein r x) < #α 
Arguments: {α : Type u} (r : α → α → Prop) [IsWellOrder α r] (x : α) (h : (#α).ord = Ordinal.type r)
Goal: (Ordinal.typein r x).card < #α
-- Cardinal.card_typein_out_lt
theorem card_typein_out_lt (c : Cardinal) (x : c.ord.out.α) :
    card (@typein _ (· < ·) (isWellOrder_out_lt _) x) < c 
Arguments: (c : Cardinal.{u_3}) (x : (Quotient.out c.ord).α)
Goal: (Ordinal.typein (fun x x_1 => x < x_1) x).card < c
-- Cardinal.mk_Iio_ord_out_α
theorem mk_Iio_ord_out_α {c : Cardinal} (i : c.ord.out.α) : #(Iio i) < c 
Arguments: {c : Cardinal.{u_3}} (i : (Quotient.out c.ord).α)
Goal: #↑(Set.Iio i) < c
-- Cardinal.ord_injective
theorem ord_injective : Injective ord 
Goal: Function.Injective Cardinal.ord
-- Cardinal.ord.orderEmbedding_coe
@[simp]
theorem ord.orderEmbedding_coe : (ord.orderEmbedding : Cardinal → Ordinal) = ord 
Goal: ⇑Cardinal.ord.orderEmbedding = Cardinal.ord
-- Cardinal.univ_id
theorem univ_id : univ.{u, u + 1} = #Ordinal 
Goal: Cardinal.univ.{u, u + 1} = #Ordinal.{u}
-- Cardinal.lift_univ
@[simp]
theorem lift_univ : lift.{w} univ.{u, v} = univ.{u, max v w} 
Goal: Cardinal.lift.{w, max (u + 1) v} Cardinal.univ.{u, v} = Cardinal.univ.{u, max v w}
-- Cardinal.univ_umax
theorem univ_umax : univ.{u, max (u + 1) v} = univ.{u, v} 
Goal: Cardinal.univ.{u, max (u + 1) v} = Cardinal.univ.{u, v}
-- Cardinal.lift_lt_univ
theorem lift_lt_univ (c : Cardinal) : lift.{u + 1, u} c < univ.{u, u + 1} 
Arguments: (c : Cardinal.{u})
Goal: Cardinal.lift.{u + 1, u} c < Cardinal.univ.{u, u + 1}
-- Cardinal.lift_lt_univ'
theorem lift_lt_univ' (c : Cardinal) : lift.{max (u + 1) v, u} c < univ.{u, v} 
Arguments: (c : Cardinal.{u})
Goal: Cardinal.lift.{max (u + 1) v, u} c < Cardinal.univ.{u, v}
-- Cardinal.ord_univ
@[simp]
theorem ord_univ : ord univ.{u, v} = Ordinal.univ.{u, v} 
Goal: Cardinal.univ.{u, v}.ord = Ordinal.univ.{u, v}
-- Cardinal.lt_univ
theorem lt_univ {c} : c < univ.{u, u + 1} ↔ ∃ c', c = lift.{u + 1, u} c' 
Arguments: {c : Cardinal.{u + 1}}
Goal: c < Cardinal.univ.{u, u + 1} ↔ ∃ c', c = Cardinal.lift.{u + 1, u} c'
-- Cardinal.lt_univ'
theorem lt_univ' {c} : c < univ.{u, v} ↔ ∃ c', c = lift.{max (u + 1) v, u} c' 
Arguments: {c : Cardinal.{max (u + 1) v}}
Goal: c < Cardinal.univ.{u, v} ↔ ∃ c', c = Cardinal.lift.{max (u + 1) v, u} c'
-- Cardinal.small_iff_lift_mk_lt_univ
theorem small_iff_lift_mk_lt_univ {α : Type u} :
    Small.{v} α ↔ Cardinal.lift.{v+1,_} #α < univ.{v, max u (v + 1)} 
Arguments: {α : Type u}
Goal: Small.{v, u} α ↔ Cardinal.lift.{v + 1, u} #α < Cardinal.univ.{v, max u (v + 1)}
-- Ordinal.card_univ
@[simp]
theorem card_univ : card univ.{u,v} = Cardinal.univ.{u,v} 
Goal: Ordinal.univ.{u, v}.card = Cardinal.univ.{u, v}
-- Ordinal.nat_le_card
@[simp]
theorem nat_le_card {o} {n : ℕ} : (n : Cardinal) ≤ card o ↔ (n : Ordinal) ≤ o 
Arguments: {o : Ordinal.{u_3}} {n : ℕ}
Goal: ↑n ≤ o.card ↔ ↑n ≤ o
-- Ordinal.one_le_card
@[simp]
theorem one_le_card {o} : 1 ≤ card o ↔ 1 ≤ o 
Arguments: {o : Ordinal.{u_3}}
Goal: 1 ≤ o.card ↔ 1 ≤ o
-- Ordinal.ofNat_le_card
@[simp]
theorem ofNat_le_card {o} {n : ℕ} [n.AtLeastTwo] :
    (no_index (OfNat.ofNat n : Cardinal)) ≤ card o ↔ (OfNat.ofNat n : Ordinal) ≤ o 
Arguments: {o : Ordinal.{u_3}} {n : ℕ} [n.AtLeastTwo]
Goal: OfNat.ofNat n ≤ o.card ↔ OfNat.ofNat n ≤ o
-- Ordinal.nat_lt_card
@[simp]
theorem nat_lt_card {o} {n : ℕ} : (n : Cardinal) < card o ↔ (n : Ordinal) < o 
Arguments: {o : Ordinal.{u_3}} {n : ℕ}
Goal: ↑n < o.card ↔ ↑n < o
-- Ordinal.zero_lt_card
@[simp]
theorem zero_lt_card {o} : 0 < card o ↔ 0 < o 
Arguments: {o : Ordinal.{u_3}}
Goal: 0 < o.card ↔ 0 < o
-- Ordinal.one_lt_card
@[simp]
theorem one_lt_card {o} : 1 < card o ↔ 1 < o 
Arguments: {o : Ordinal.{u_3}}
Goal: 1 < o.card ↔ 1 < o
-- Ordinal.ofNat_lt_card
@[simp]
theorem ofNat_lt_card {o} {n : ℕ} [n.AtLeastTwo] :
    (no_index (OfNat.ofNat n : Cardinal)) < card o ↔ (OfNat.ofNat n : Ordinal) < o 
Arguments: {o : Ordinal.{u_3}} {n : ℕ} [n.AtLeastTwo]
Goal: OfNat.ofNat n < o.card ↔ OfNat.ofNat n < o
-- Ordinal.card_lt_nat
@[simp]
theorem card_lt_nat {o} {n : ℕ} : card o < n ↔ o < n 
Arguments: {o : Ordinal.{u_3}} {n : ℕ}
Goal: o.card < ↑n ↔ o < ↑n
-- Ordinal.card_lt_ofNat
@[simp]
theorem card_lt_ofNat {o} {n : ℕ} [n.AtLeastTwo] :
    card o < (no_index (OfNat.ofNat n)) ↔ o < OfNat.ofNat n 
Arguments: {o : Ordinal.{u_3}} {n : ℕ} [n.AtLeastTwo]
Goal: o.card < OfNat.ofNat n ↔ o < OfNat.ofNat n
-- Ordinal.card_le_nat
@[simp]
theorem card_le_nat {o} {n : ℕ} : card o ≤ n ↔ o ≤ n 
Arguments: {o : Ordinal.{u_3}} {n : ℕ}
Goal: o.card ≤ ↑n ↔ o ≤ ↑n
-- Ordinal.card_le_one
@[simp]
theorem card_le_one {o} : card o ≤ 1 ↔ o ≤ 1 
Arguments: {o : Ordinal.{u_3}}
Goal: o.card ≤ 1 ↔ o ≤ 1
-- Ordinal.card_le_ofNat
@[simp]
theorem card_le_ofNat {o} {n : ℕ} [n.AtLeastTwo] :
    card o ≤ (no_index (OfNat.ofNat n)) ↔ o ≤ OfNat.ofNat n 
Arguments: {o : Ordinal.{u_3}} {n : ℕ} [n.AtLeastTwo]
Goal: o.card ≤ OfNat.ofNat n ↔ o ≤ OfNat.ofNat n
-- Ordinal.card_eq_nat
@[simp]
theorem card_eq_nat {o} {n : ℕ} : card o = n ↔ o = n 
Arguments: {o : Ordinal.{u_3}} {n : ℕ}
Goal: o.card = ↑n ↔ o = ↑n
-- Ordinal.card_eq_zero
@[simp]
theorem card_eq_zero {o} : card o = 0 ↔ o = 0 
Arguments: {o : Ordinal.{u_3}}
Goal: o.card = 0 ↔ o = 0
-- Ordinal.card_eq_one
@[simp]
theorem card_eq_one {o} : card o = 1 ↔ o = 1 
Arguments: {o : Ordinal.{u_3}}
Goal: o.card = 1 ↔ o = 1
-- Ordinal.card_eq_ofNat
@[simp]
theorem card_eq_ofNat {o} {n : ℕ} [n.AtLeastTwo] :
    card o = (no_index (OfNat.ofNat n)) ↔ o = OfNat.ofNat n 
Arguments: {o : Ordinal.{u_3}} {n : ℕ} [n.AtLeastTwo]
Goal: o.card = OfNat.ofNat n ↔ o = OfNat.ofNat n
-- Ordinal.type_fintype
@[simp]
theorem type_fintype (r : α → α → Prop) [IsWellOrder α r] [Fintype α] :
    type r = Fintype.card α 
Arguments: {α : Type u} (r : α → α → Prop) [IsWellOrder α r] [Fintype α]
Goal: Ordinal.type r = ↑(Fintype.card α)
-- Ordinal.type_fin
theorem type_fin (n : ℕ) : @type (Fin n) (· < ·) _ = n 
Arguments: (n : ℕ)
Goal: (Ordinal.type fun x x_1 => x < x_1) = ↑n
-- List.Sorted.lt_ord_of_lt
theorem List.Sorted.lt_ord_of_lt [LinearOrder α] [IsWellOrder α (· < ·)] {l m : List α}
    {o : Ordinal} (hl : l.Sorted (· > ·)) (hm : m.Sorted (· > ·)) (hmltl : m < l)
    (hlt : ∀ i ∈ l, Ordinal.typein (· < ·) i < o) : ∀ i ∈ m, Ordinal.typein (· < ·) i < o 
Arguments: {α : Type u} [LinearOrder α] [IsWellOrder α fun x x_1 => x < x_1] {l m : List α} {o : Ordinal.{u}} (hl : List.Sorted (fun x x_1 => x > x_1) l) (hm : List.Sorted (fun x x_1 => x > x_1) m) (hmltl : m < l) (hlt : ∀ i ∈ l, Ordinal.typein (fun x x_1 => x < x_1) i < o) (i : α)
Goal: i ∈ m → Ordinal.typein (fun x x_1 => x < x_1) i < o
-- YoungDiagram.isLowerSet
@[ext]
structure YoungDiagram where
    cells : Finset (ℕ × ℕ)
    isLowerSet : IsLowerSet (cells : Set (ℕ × ℕ))
Arguments: (self : YoungDiagram)
Goal: IsLowerSet ↑self.cells
-- YoungDiagram.mem_cells
@[simp]
theorem mem_cells {μ : YoungDiagram} (c : ℕ × ℕ) : c ∈ μ.cells ↔ c ∈ μ 
Arguments: {μ : YoungDiagram} (c : ℕ × ℕ)
Goal: c ∈ μ.cells ↔ c ∈ μ
-- YoungDiagram.mem_mk
@[simp]
theorem mem_mk (c : ℕ × ℕ) (cells) (isLowerSet) :
    c ∈ YoungDiagram.mk cells isLowerSet ↔ c ∈ cells 
Arguments: (c : ℕ × ℕ) (cells : Finset (ℕ × ℕ)) (isLowerSet : IsLowerSet ↑cells)
Goal: c ∈ { cells := cells, isLowerSet := isLowerSet } ↔ c ∈ cells
-- YoungDiagram.up_left_mem
theorem up_left_mem (μ : YoungDiagram) {i1 i2 j1 j2 : ℕ} (hi : i1 ≤ i2) (hj : j1 ≤ j2)
    (hcell : (i2, j2) ∈ μ) : (i1, j1) ∈ μ 
Arguments: (μ : YoungDiagram) {i1 i2 j1 j2 : ℕ} (hi : i1 ≤ i2) (hj : j1 ≤ j2) (hcell : (i2, j2) ∈ μ)
Goal: (i1, j1) ∈ μ
-- YoungDiagram.cells_subset_iff
@[simp]
theorem cells_subset_iff {μ ν : YoungDiagram} : μ.cells ⊆ ν.cells ↔ μ ≤ ν 
Arguments: {μ ν : YoungDiagram}
Goal: μ.cells ⊆ ν.cells ↔ μ ≤ ν
-- YoungDiagram.cells_ssubset_iff
@[simp]
theorem cells_ssubset_iff {μ ν : YoungDiagram} : μ.cells ⊂ ν.cells ↔ μ < ν 
Arguments: {μ ν : YoungDiagram}
Goal: μ.cells ⊂ ν.cells ↔ μ < ν
-- YoungDiagram.cells_sup
@[simp]
theorem cells_sup (μ ν : YoungDiagram) : (μ ⊔ ν).cells = μ.cells ∪ ν.cells 
Arguments: (μ ν : YoungDiagram)
Goal: (μ ⊔ ν).cells = μ.cells ∪ ν.cells
-- YoungDiagram.coe_sup
@[simp, norm_cast]
theorem coe_sup (μ ν : YoungDiagram) : ↑(μ ⊔ ν) = (μ ∪ ν : Set (ℕ × ℕ)) 
Arguments: (μ ν : YoungDiagram)
Goal: ↑(μ ⊔ ν) = ↑μ ∪ ↑ν
-- YoungDiagram.mem_sup
@[simp]
theorem mem_sup {μ ν : YoungDiagram} {x : ℕ × ℕ} : x ∈ μ ⊔ ν ↔ x ∈ μ ∨ x ∈ ν 
Arguments: {μ ν : YoungDiagram} {x : ℕ × ℕ}
Goal: x ∈ μ ⊔ ν ↔ x ∈ μ ∨ x ∈ ν
-- YoungDiagram.cells_inf
@[simp]
theorem cells_inf (μ ν : YoungDiagram) : (μ ⊓ ν).cells = μ.cells ∩ ν.cells 
Arguments: (μ ν : YoungDiagram)
Goal: (μ ⊓ ν).cells = μ.cells ∩ ν.cells
-- YoungDiagram.coe_inf
@[simp, norm_cast]
theorem coe_inf (μ ν : YoungDiagram) : ↑(μ ⊓ ν) = (μ ∩ ν : Set (ℕ × ℕ)) 
Arguments: (μ ν : YoungDiagram)
Goal: ↑(μ ⊓ ν) = ↑μ ∩ ↑ν
-- YoungDiagram.mem_inf
@[simp]
theorem mem_inf {μ ν : YoungDiagram} {x : ℕ × ℕ} : x ∈ μ ⊓ ν ↔ x ∈ μ ∧ x ∈ ν 
Arguments: {μ ν : YoungDiagram} {x : ℕ × ℕ}
Goal: x ∈ μ ⊓ ν ↔ x ∈ μ ∧ x ∈ ν
-- YoungDiagram.cells_bot
@[simp]
theorem cells_bot : (⊥ : YoungDiagram).cells = ∅ 
Goal: ⊥.cells = ∅
-- YoungDiagram.coe_bot
@[norm_cast]
theorem coe_bot : (⊥ : YoungDiagram).cells = (∅ : Set (ℕ × ℕ)) 
Goal: ↑⊥.cells = ∅
-- YoungDiagram.not_mem_bot
@[simp]
theorem not_mem_bot (x : ℕ × ℕ) : x ∉ (⊥ : YoungDiagram) 
Arguments: (x : ℕ × ℕ)
Goal: x ∉ ⊥
-- YoungDiagram.mem_transpose
@[simp]
theorem mem_transpose {μ : YoungDiagram} {c : ℕ × ℕ} : c ∈ μ.transpose ↔ c.swap ∈ μ 
Arguments: {μ : YoungDiagram} {c : ℕ × ℕ}
Goal: c ∈ μ.transpose ↔ c.swap ∈ μ
-- YoungDiagram.transpose_transpose
@[simp]
theorem transpose_transpose (μ : YoungDiagram) : μ.transpose.transpose = μ 
Arguments: (μ : YoungDiagram)
Goal: μ.transpose.transpose = μ
-- YoungDiagram.transpose_eq_iff_eq_transpose
theorem transpose_eq_iff_eq_transpose {μ ν : YoungDiagram} : μ.transpose = ν ↔ μ = ν.transpose 
Arguments: {μ ν : YoungDiagram}
Goal: μ.transpose = ν ↔ μ = ν.transpose
-- YoungDiagram.transpose_eq_iff
@[simp]
theorem transpose_eq_iff {μ ν : YoungDiagram} : μ.transpose = ν.transpose ↔ μ = ν 
Arguments: {μ ν : YoungDiagram}
Goal: μ.transpose = ν.transpose ↔ μ = ν
-- YoungDiagram.le_of_transpose_le
protected theorem le_of_transpose_le {μ ν : YoungDiagram} (h_le : μ.transpose ≤ ν) :
    μ ≤ ν.transpose 
Arguments: {μ ν : YoungDiagram} (h_le : μ.transpose ≤ ν)
Goal: μ ≤ ν.transpose
-- YoungDiagram.transpose_le_iff
@[simp]
theorem transpose_le_iff {μ ν : YoungDiagram} : μ.transpose ≤ ν.transpose ↔ μ ≤ ν 
Arguments: {μ ν : YoungDiagram}
Goal: μ.transpose ≤ ν.transpose ↔ μ ≤ ν
-- YoungDiagram.transpose_mono
@[mono]
protected theorem transpose_mono {μ ν : YoungDiagram} (h_le : μ ≤ ν) : μ.transpose ≤ ν.transpose 
Arguments: {μ ν : YoungDiagram} (h_le : μ ≤ ν)
Goal: μ.transpose ≤ ν.transpose
-- YoungDiagram.transposeOrderIso_symm_apply
@[simps]
def transposeOrderIso : YoungDiagram ≃o YoungDiagram 
Arguments: (μ : YoungDiagram)
Goal: (RelIso.symm YoungDiagram.transposeOrderIso) μ = μ.transpose
-- YoungDiagram.transposeOrderIso_apply
@[simps]
def transposeOrderIso : YoungDiagram ≃o YoungDiagram 
Arguments: (μ : YoungDiagram)
Goal: YoungDiagram.transposeOrderIso μ = μ.transpose
-- YoungDiagram.mem_row_iff
theorem mem_row_iff {μ : YoungDiagram} {i : ℕ} {c : ℕ × ℕ} : c ∈ μ.row i ↔ c ∈ μ ∧ c.fst = i 
Arguments: {μ : YoungDiagram} {i : ℕ} {c : ℕ × ℕ}
Goal: c ∈ μ.row i ↔ c ∈ μ ∧ c.1 = i
-- YoungDiagram.mk_mem_row_iff
theorem mk_mem_row_iff {μ : YoungDiagram} {i j : ℕ} : (i, j) ∈ μ.row i ↔ (i, j) ∈ μ 
Arguments: {μ : YoungDiagram} {i j : ℕ}
Goal: (i, j) ∈ μ.row i ↔ (i, j) ∈ μ
-- YoungDiagram.exists_not_mem_row
protected theorem exists_not_mem_row (μ : YoungDiagram) (i : ℕ) : ∃ j, (i, j) ∉ μ 
Arguments: (μ : YoungDiagram) (i : ℕ)
Goal: ∃ j, (i, j) ∉ μ
-- YoungDiagram.mem_iff_lt_rowLen
theorem mem_iff_lt_rowLen {μ : YoungDiagram} {i j : ℕ} : (i, j) ∈ μ ↔ j < μ.rowLen i 
Arguments: {μ : YoungDiagram} {i j : ℕ}
Goal: (i, j) ∈ μ ↔ j < μ.rowLen i
-- YoungDiagram.row_eq_prod
theorem row_eq_prod {μ : YoungDiagram} {i : ℕ} : μ.row i = {i} ×ˢ Finset.range (μ.rowLen i) 
Arguments: {μ : YoungDiagram} {i : ℕ}
Goal: μ.row i = {i} ×ˢ Finset.range (μ.rowLen i)
-- YoungDiagram.rowLen_eq_card
theorem rowLen_eq_card (μ : YoungDiagram) {i : ℕ} : μ.rowLen i = (μ.row i).card 
Arguments: (μ : YoungDiagram) {i : ℕ}
Goal: μ.rowLen i = (μ.row i).card
-- YoungDiagram.rowLen_anti
@[mono]
theorem rowLen_anti (μ : YoungDiagram) (i1 i2 : ℕ) (hi : i1 ≤ i2) : μ.rowLen i2 ≤ μ.rowLen i1 
Arguments: (μ : YoungDiagram) (i1 i2 : ℕ) (hi : i1 ≤ i2)
Goal: μ.rowLen i2 ≤ μ.rowLen i1
-- YoungDiagram.mem_col_iff
theorem mem_col_iff {μ : YoungDiagram} {j : ℕ} {c : ℕ × ℕ} : c ∈ μ.col j ↔ c ∈ μ ∧ c.snd = j 
Arguments: {μ : YoungDiagram} {j : ℕ} {c : ℕ × ℕ}
Goal: c ∈ μ.col j ↔ c ∈ μ ∧ c.2 = j
-- YoungDiagram.mk_mem_col_iff
theorem mk_mem_col_iff {μ : YoungDiagram} {i j : ℕ} : (i, j) ∈ μ.col j ↔ (i, j) ∈ μ 
Arguments: {μ : YoungDiagram} {i j : ℕ}
Goal: (i, j) ∈ μ.col j ↔ (i, j) ∈ μ
-- YoungDiagram.exists_not_mem_col
protected theorem exists_not_mem_col (μ : YoungDiagram) (j : ℕ) : ∃ i, (i, j) ∉ μ.cells 
Arguments: (μ : YoungDiagram) (j : ℕ)
Goal: ∃ i, (i, j) ∉ μ.cells
-- YoungDiagram.colLen_transpose
@[simp]
theorem colLen_transpose (μ : YoungDiagram) (j : ℕ) : μ.transpose.colLen j = μ.rowLen j 
Arguments: (μ : YoungDiagram) (j : ℕ)
Goal: μ.transpose.colLen j = μ.rowLen j
-- YoungDiagram.rowLen_transpose
@[simp]
theorem rowLen_transpose (μ : YoungDiagram) (i : ℕ) : μ.transpose.rowLen i = μ.colLen i 
Arguments: (μ : YoungDiagram) (i : ℕ)
Goal: μ.transpose.rowLen i = μ.colLen i
-- YoungDiagram.mem_iff_lt_colLen
theorem mem_iff_lt_colLen {μ : YoungDiagram} {i j : ℕ} : (i, j) ∈ μ ↔ i < μ.colLen j 
Arguments: {μ : YoungDiagram} {i j : ℕ}
Goal: (i, j) ∈ μ ↔ i < μ.colLen j
-- YoungDiagram.col_eq_prod
theorem col_eq_prod {μ : YoungDiagram} {j : ℕ} : μ.col j = Finset.range (μ.colLen j) ×ˢ {j} 
Arguments: {μ : YoungDiagram} {j : ℕ}
Goal: μ.col j = Finset.range (μ.colLen j) ×ˢ {j}
-- YoungDiagram.colLen_eq_card
theorem colLen_eq_card (μ : YoungDiagram) {j : ℕ} : μ.colLen j = (μ.col j).card 
Arguments: (μ : YoungDiagram) {j : ℕ}
Goal: μ.colLen j = (μ.col j).card
-- YoungDiagram.colLen_anti
@[mono]
theorem colLen_anti (μ : YoungDiagram) (j1 j2 : ℕ) (hj : j1 ≤ j2) : μ.colLen j2 ≤ μ.colLen j1 
Arguments: (μ : YoungDiagram) (j1 j2 : ℕ) (hj : j1 ≤ j2)
Goal: μ.colLen j2 ≤ μ.colLen j1
-- YoungDiagram.get_rowLens
@[simp]
theorem get_rowLens {μ : YoungDiagram} {i : Nat} {h : i < μ.rowLens.length} :
    μ.rowLens[i] = μ.rowLen i 
Arguments: {μ : YoungDiagram} {i : ℕ} {h : i < μ.rowLens.length}
Goal: μ.rowLens[i] = μ.rowLen i
-- YoungDiagram.length_rowLens
@[simp]
theorem length_rowLens {μ : YoungDiagram} : μ.rowLens.length = μ.colLen 0 
Arguments: {μ : YoungDiagram}
Goal: μ.rowLens.length = μ.colLen 0
-- YoungDiagram.rowLens_sorted
theorem rowLens_sorted (μ : YoungDiagram) : μ.rowLens.Sorted (· ≥ ·) 
Arguments: (μ : YoungDiagram)
Goal: List.Sorted (fun x x_1 => x ≥ x_1) μ.rowLens
-- YoungDiagram.pos_of_mem_rowLens
theorem pos_of_mem_rowLens (μ : YoungDiagram) (x : ℕ) (hx : x ∈ μ.rowLens) : 0 < x 
Arguments: (μ : YoungDiagram) (x : ℕ) (hx : x ∈ μ.rowLens)
Goal: 0 < x
-- YoungDiagram.mem_cellsOfRowLens
protected theorem mem_cellsOfRowLens {w : List ℕ} {c : ℕ × ℕ} :
    c ∈ YoungDiagram.cellsOfRowLens w ↔ ∃ h : c.fst < w.length, c.snd < w.get ⟨c.fst, h⟩  
Arguments: {w : List ℕ} {c : ℕ × ℕ}
Goal: c ∈ YoungDiagram.cellsOfRowLens w ↔ ∃ (h : c.1 < w.length), c.2 < w.get ⟨c.1, h⟩
-- YoungDiagram.mem_ofRowLens
theorem mem_ofRowLens {w : List ℕ} {hw : w.Sorted (· ≥ ·)} {c : ℕ × ℕ} :
    c ∈ ofRowLens w hw ↔ ∃ h : c.fst < w.length, c.snd < w.get ⟨c.fst, h⟩ 
Arguments: {w : List ℕ} {hw : List.Sorted (fun x x_1 => x ≥ x_1) w} {c : ℕ × ℕ}
Goal: c ∈ YoungDiagram.ofRowLens w hw ↔ ∃ (h : c.1 < w.length), c.2 < w.get ⟨c.1, h⟩
-- YoungDiagram.rowLens_length_ofRowLens
theorem rowLens_length_ofRowLens {w : List ℕ} {hw : w.Sorted (· ≥ ·)} (hpos : ∀ x ∈ w, 0 < x) :
    (ofRowLens w hw).rowLens.length = w.length 
Arguments: {w : List ℕ} {hw : List.Sorted (fun x x_1 => x ≥ x_1) w} (hpos : ∀ x ∈ w, 0 < x)
Goal: (YoungDiagram.ofRowLens w hw).rowLens.length = w.length
-- YoungDiagram.rowLen_ofRowLens
theorem rowLen_ofRowLens {w : List ℕ} {hw : w.Sorted (· ≥ ·)} (i : Fin w.length) :
    (ofRowLens w hw).rowLen i = w.get i 
Arguments: {w : List ℕ} {hw : List.Sorted (fun x x_1 => x ≥ x_1) w} (i : Fin w.length)
Goal: (YoungDiagram.ofRowLens w hw).rowLen ↑i = w.get i
-- YoungDiagram.ofRowLens_to_rowLens_eq_self
theorem ofRowLens_to_rowLens_eq_self {μ : YoungDiagram} : ofRowLens _ (rowLens_sorted μ) = μ 
Arguments: {μ : YoungDiagram}
Goal: YoungDiagram.ofRowLens μ.rowLens ⋯ = μ
-- YoungDiagram.rowLens_ofRowLens_eq_self
theorem rowLens_ofRowLens_eq_self {w : List ℕ} {hw : w.Sorted (· ≥ ·)} (hpos : ∀ x ∈ w, 0 < x) :
    (ofRowLens w hw).rowLens = w 
Arguments: {w : List ℕ} {hw : List.Sorted (fun x x_1 => x ≥ x_1) w} (hpos : ∀ x ∈ w, 0 < x)
Goal: (YoungDiagram.ofRowLens w hw).rowLens = w
-- YoungDiagram.equivListRowLens_apply_coe
@[simps]
def equivListRowLens : YoungDiagram ≃ { w : List ℕ // w.Sorted (· ≥ ·) ∧ ∀ x ∈ w, 0 < x } 
Arguments: (μ : YoungDiagram)
Goal: ↑(YoungDiagram.equivListRowLens μ) = μ.rowLens
-- YoungDiagram.equivListRowLens_symm_apply
@[simps]
def equivListRowLens : YoungDiagram ≃ { w : List ℕ // w.Sorted (· ≥ ·) ∧ ∀ x ∈ w, 0 < x } 
Arguments: (ww : { w // List.Sorted (fun x x_1 => x ≥ x_1) w ∧ ∀ x ∈ w, 0 < x })
Goal: YoungDiagram.equivListRowLens.symm ww = YoungDiagram.ofRowLens ↑ww ⋯
-- _private.Mathlib.Combinatorics.SetFamily.CauchyDavenport.0.devosMulRel_iff
@[to_additive]
private lemma devosMulRel_iff :
    DevosMulRel x y ↔
      (x.1 * x.2).card < (y.1 * y.2).card ∨
        (x.1 * x.2).card = (y.1 * y.2).card ∧ y.1.card + y.2.card < x.1.card + x.2.card ∨
          (x.1 * x.2).card = (y.1 * y.2).card ∧
            x.1.card + x.2.card = y.1.card + y.2.card ∧ x.1.card < y.1.card 
Arguments: {α : Type u_1} [Group α] [DecidableEq α] {x y : Finset α × Finset α}
Goal: DevosMulRel x y ↔
  (x.1 * x.2).card < (y.1 * y.2).card ∨
    (x.1 * x.2).card = (y.1 * y.2).card ∧ y.1.card + y.2.card < x.1.card + x.2.card ∨
      (x.1 * x.2).card = (y.1 * y.2).card ∧ x.1.card + x.2.card = y.1.card + y.2.card ∧ x.1.card < y.1.card
-- _private.Mathlib.Combinatorics.SetFamily.CauchyDavenport.0.devosAddRel_iff
@[to_additive]
private lemma devosMulRel_iff :
    DevosMulRel x y ↔
      (x.1 * x.2).card < (y.1 * y.2).card ∨
        (x.1 * x.2).card = (y.1 * y.2).card ∧ y.1.card + y.2.card < x.1.card + x.2.card ∨
          (x.1 * x.2).card = (y.1 * y.2).card ∧
            x.1.card + x.2.card = y.1.card + y.2.card ∧ x.1.card < y.1.card 
Arguments: {α : Type u_1} [AddGroup α] [DecidableEq α] {x y : Finset α × Finset α}
Goal: DevosAddRel x y ↔
  (x.1 + x.2).card < (y.1 + y.2).card ∨
    (x.1 + x.2).card = (y.1 + y.2).card ∧ y.1.card + y.2.card < x.1.card + x.2.card ∨
      (x.1 + x.2).card = (y.1 + y.2).card ∧ x.1.card + x.2.card = y.1.card + y.2.card ∧ x.1.card < y.1.card
-- _private.Mathlib.Combinatorics.SetFamily.CauchyDavenport.0.devosAddRel_of_le
@[to_additive]
private lemma devosMulRel_of_le (mul : (x.1 * x.2).card ≤ (y.1 * y.2).card)
    (hadd : y.1.card + y.2.card < x.1.card + x.2.card) : DevosMulRel x y 
Arguments: {α : Type u_1} [AddGroup α] [DecidableEq α] {x y : Finset α × Finset α} (mul : (x.1 + x.2).card ≤ (y.1 + y.2).card) (hadd : y.1.card + y.2.card < x.1.card + x.2.card)
Goal: DevosAddRel x y
-- _private.Mathlib.Combinatorics.SetFamily.CauchyDavenport.0.devosMulRel_of_le
@[to_additive]
private lemma devosMulRel_of_le (mul : (x.1 * x.2).card ≤ (y.1 * y.2).card)
    (hadd : y.1.card + y.2.card < x.1.card + x.2.card) : DevosMulRel x y 
Arguments: {α : Type u_1} [Group α] [DecidableEq α] {x y : Finset α × Finset α} (mul : (x.1 * x.2).card ≤ (y.1 * y.2).card) (hadd : y.1.card + y.2.card < x.1.card + x.2.card)
Goal: DevosMulRel x y
-- _private.Mathlib.Combinatorics.SetFamily.CauchyDavenport.0.devosMulRel_of_le_of_le
@[to_additive]
private lemma devosMulRel_of_le_of_le (mul : (x.1 * x.2).card ≤ (y.1 * y.2).card)
    (hadd : y.1.card + y.2.card ≤ x.1.card + x.2.card) (hone : x.1.card < y.1.card) :
    DevosMulRel x y 
Arguments: {α : Type u_1} [Group α] [DecidableEq α] {x y : Finset α × Finset α} (mul : (x.1 * x.2).card ≤ (y.1 * y.2).card) (hadd : y.1.card + y.2.card ≤ x.1.card + x.2.card) (hone : x.1.card < y.1.card)
Goal: DevosMulRel x y