ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
-- Batteries.TotalBLE.total
class TotalBLE (le : α → α → Bool) : Prop where
    total : le a b ∨ le b a
Arguments: {α : Sort u_1} {le : α → α → Bool} [self : Batteries.TotalBLE le] {a b : α}
Goal: le a b = true ∨ le b a = true
-- Batteries.OrientedCmp.symm
class OrientedCmp (cmp : α → α → Ordering) : Prop where
    symm (x y) : (cmp x y).swap = cmp y x
Arguments: {α : Sort u_1} {cmp : α → α → Ordering} [self : Batteries.OrientedCmp cmp] (x y : α)
Goal: (cmp x y).swap = cmp y x
-- Batteries.OrientedCmp.cmp_eq_gt
theorem cmp_eq_gt [OrientedCmp cmp] : cmp x y = .gt ↔ cmp y x = .lt 
Goal: ∀ {α : Sort u_1} {cmp : α → α → Ordering} {x y : α} [inst : Batteries.OrientedCmp cmp],
  cmp x y = Ordering.gt ↔ cmp y x = Ordering.lt
-- Batteries.OrientedCmp.cmp_ne_gt
theorem cmp_ne_gt [OrientedCmp cmp] : cmp x y ≠ .gt ↔ cmp y x ≠ .lt 
Goal: ∀ {α : Sort u_1} {cmp : α → α → Ordering} {x y : α} [inst : Batteries.OrientedCmp cmp],
  cmp x y ≠ Ordering.gt ↔ cmp y x ≠ Ordering.lt
-- Batteries.OrientedCmp.cmp_eq_eq_symm
theorem cmp_eq_eq_symm [OrientedCmp cmp] : cmp x y = .eq ↔ cmp y x = .eq 
Goal: ∀ {α : Sort u_1} {cmp : α → α → Ordering} {x y : α} [inst : Batteries.OrientedCmp cmp],
  cmp x y = Ordering.eq ↔ cmp y x = Ordering.eq
-- Batteries.OrientedCmp.cmp_refl
theorem cmp_refl [OrientedCmp cmp] : cmp x x = .eq 
Goal: ∀ {α : Sort u_1} {cmp : α → α → Ordering} {x : α} [inst : Batteries.OrientedCmp cmp], cmp x x = Ordering.eq
-- Batteries.TransCmp.le_trans
class TransCmp (cmp : α → α → Ordering) extends OrientedCmp cmp : Prop where
    le_trans : cmp x y ≠ .gt → cmp y z ≠ .gt → cmp x z ≠ .gt
Arguments: {α : Sort u_1} {cmp : α → α → Ordering} [self : Batteries.TransCmp cmp] {x y z : α}
Goal: cmp x y ≠ Ordering.gt → cmp y z ≠ Ordering.gt → cmp x z ≠ Ordering.gt
-- Batteries.TransCmp.ge_trans
theorem ge_trans (h₁ : cmp x y ≠ .lt) (h₂ : cmp y z ≠ .lt) : cmp x z ≠ .lt 
Goal: ∀ {x : Sort u_1} {cmp : x → x → Ordering} [inst : Batteries.TransCmp cmp] {x_1 y z : x},
  cmp x_1 y ≠ Ordering.lt → cmp y z ≠ Ordering.lt → cmp x_1 z ≠ Ordering.lt
-- Batteries.TransCmp.lt_asymm
theorem lt_asymm (h : cmp x y = .lt) : cmp y x ≠ .lt 
Goal: ∀ {x : Sort u_1} {cmp : x → x → Ordering} [inst : Batteries.TransCmp cmp] {x_1 y : x},
  cmp x_1 y = Ordering.lt → cmp y x_1 ≠ Ordering.lt
-- Batteries.TransCmp.gt_asymm
theorem gt_asymm (h : cmp x y = .gt) : cmp y x ≠ .gt 
Goal: ∀ {x : Sort u_1} {cmp : x → x → Ordering} [inst : Batteries.TransCmp cmp] {x_1 y : x},
  cmp x_1 y = Ordering.gt → cmp y x_1 ≠ Ordering.gt
-- Batteries.TransCmp.le_lt_trans
theorem le_lt_trans (h₁ : cmp x y ≠ .gt) (h₂ : cmp y z = .lt) : cmp x z = .lt 
Goal: ∀ {x : Sort u_1} {cmp : x → x → Ordering} [inst : Batteries.TransCmp cmp] {x_1 y z : x},
  cmp x_1 y ≠ Ordering.gt → cmp y z = Ordering.lt → cmp x_1 z = Ordering.lt
-- Batteries.TransCmp.lt_le_trans
theorem lt_le_trans (h₁ : cmp x y = .lt) (h₂ : cmp y z ≠ .gt) : cmp x z = .lt 
Goal: ∀ {x : Sort u_1} {cmp : x → x → Ordering} [inst : Batteries.TransCmp cmp] {x_1 y z : x},
  cmp x_1 y = Ordering.lt → cmp y z ≠ Ordering.gt → cmp x_1 z = Ordering.lt
-- Batteries.TransCmp.lt_trans
theorem lt_trans (h₁ : cmp x y = .lt) (h₂ : cmp y z = .lt) : cmp x z = .lt 
Goal: ∀ {x : Sort u_1} {cmp : x → x → Ordering} [inst : Batteries.TransCmp cmp] {x_1 y z : x},
  cmp x_1 y = Ordering.lt → cmp y z = Ordering.lt → cmp x_1 z = Ordering.lt
-- Batteries.TransCmp.gt_trans
theorem gt_trans (h₁ : cmp x y = .gt) (h₂ : cmp y z = .gt) : cmp x z = .gt 
Goal: ∀ {x : Sort u_1} {cmp : x → x → Ordering} [inst : Batteries.TransCmp cmp] {x_1 y z : x},
  cmp x_1 y = Ordering.gt → cmp y z = Ordering.gt → cmp x_1 z = Ordering.gt
-- Batteries.TransCmp.cmp_congr_left
theorem cmp_congr_left (xy : cmp x y = .eq) : cmp x z = cmp y z 
Goal: ∀ {x : Sort u_1} {cmp : x → x → Ordering} [inst : Batteries.TransCmp cmp] {x_1 y z : x},
  cmp x_1 y = Ordering.eq → cmp x_1 z = cmp y z
-- Batteries.TransCmp.cmp_congr_left'
theorem cmp_congr_left' (xy : cmp x y = .eq) : cmp x = cmp y 
Goal: ∀ {x : Sort u_1} {cmp : x → x → Ordering} [inst : Batteries.TransCmp cmp] {x_1 y : x},
  cmp x_1 y = Ordering.eq → cmp x_1 = cmp y
-- Batteries.TransCmp.cmp_congr_right
theorem cmp_congr_right (yz : cmp y z = .eq) : cmp x y = cmp x z 
Goal: ∀ {x : Sort u_1} {cmp : x → x → Ordering} [inst : Batteries.TransCmp cmp] {y z x : x},
  cmp y z = Ordering.eq → cmp x y = cmp x z
-- Batteries.BEqCmp.cmp_iff_beq
class BEqCmp [BEq α] (cmp : α → α → Ordering) : Prop where
    cmp_iff_beq : cmp x y = .eq ↔ x == y
Arguments: {α : Type u_1} [BEq α] {cmp : α → α → Ordering} [self : Batteries.BEqCmp cmp] {x y : α}
Goal: cmp x y = Ordering.eq ↔ (x == y) = true
-- Batteries.BEqCmp.cmp_iff_eq
theorem BEqCmp.cmp_iff_eq [BEq α] [LawfulBEq α] [BEqCmp (α := α) cmp] : cmp x y = .eq ↔ x = y 
Arguments: {α : Type u_1} {cmp : α → α → Ordering} {x y : α} [BEq α] [LawfulBEq α] [Batteries.BEqCmp cmp]
Goal: cmp x y = Ordering.eq ↔ x = y
-- Batteries.LTCmp.cmp_iff_lt
class LTCmp [LT α] (cmp : α → α → Ordering) extends OrientedCmp cmp : Prop where
    cmp_iff_lt : cmp x y = .lt ↔ x < y
Arguments: {α : Type u_1} [LT α] {cmp : α → α → Ordering} [self : Batteries.LTCmp cmp] {x y : α}
Goal: cmp x y = Ordering.lt ↔ x < y
-- Batteries.LTCmp.cmp_iff_gt
theorem LTCmp.cmp_iff_gt [LT α] [LTCmp (α := α) cmp] : cmp x y = .gt ↔ y < x 
Arguments: {α : Type u_1} {cmp : α → α → Ordering} {x y : α} [LT α] [Batteries.LTCmp cmp]
Goal: cmp x y = Ordering.gt ↔ y < x
-- Batteries.LECmp.cmp_iff_le
class LECmp [LE α] (cmp : α → α → Ordering) extends OrientedCmp cmp : Prop where
    cmp_iff_le : cmp x y ≠ .gt ↔ x ≤ y
Arguments: {α : Type u_1} [LE α] {cmp : α → α → Ordering} [self : Batteries.LECmp cmp] {x y : α}
Goal: cmp x y ≠ Ordering.gt ↔ x ≤ y
-- Batteries.LECmp.cmp_iff_ge
theorem LECmp.cmp_iff_ge [LE α] [LECmp (α := α) cmp] : cmp x y ≠ .lt ↔ y ≤ x 
Arguments: {α : Type u_1} {cmp : α → α → Ordering} {x y : α} [LE α] [Batteries.LECmp cmp]
Goal: cmp x y ≠ Ordering.lt ↔ y ≤ x
-- Batteries.compareOfLessAndEq_eq_lt
theorem compareOfLessAndEq_eq_lt {x y : α} [LT α] [Decidable (x < y)] [DecidableEq α] :
    compareOfLessAndEq x y = .lt ↔ x < y 
Arguments: {α : Type u_1} {x y : α} [LT α] [Decidable (x < y)] [DecidableEq α]
Goal: compareOfLessAndEq x y = Ordering.lt ↔ x < y
-- Batteries.TransCmp.compareOfLessAndEq
protected theorem TransCmp.compareOfLessAndEq
    [LT α] [DecidableRel (LT.lt (α := α))] [DecidableEq α]
    (lt_irrefl : ∀ x : α, ¬x < x)
    (lt_trans : ∀ {x y z : α}, x < y → y < z → x < z)
    (lt_antisymm : ∀ {x y : α}, ¬x < y → ¬y < x → x = y) :
    TransCmp (α := α) (compareOfLessAndEq · ·) 
Arguments: {α : Type u_1} [LT α] [DecidableRel LT.lt] [DecidableEq α] (lt_irrefl : ∀ (x : α), ¬x < x) (lt_trans : ∀ {x y z : α}, x < y → y < z → x < z) (lt_antisymm : ∀ {x y : α}, ¬x < y → ¬y < x → x = y)
Goal: Batteries.TransCmp fun x x_1 => compareOfLessAndEq x x_1
-- Batteries.TransCmp.compareOfLessAndEq_of_le
protected theorem TransCmp.compareOfLessAndEq_of_le
    [LT α] [LE α] [DecidableRel (LT.lt (α := α))] [DecidableEq α]
    (lt_irrefl : ∀ x : α, ¬x < x)
    (lt_trans : ∀ {x y z : α}, x < y → y < z → x < z)
    (not_lt : ∀ {x y : α}, ¬x < y → y ≤ x)
    (le_antisymm : ∀ {x y : α}, x ≤ y → y ≤ x → x = y) :
    TransCmp (α := α) (compareOfLessAndEq · ·) 
Arguments: {α : Type u_1} [LT α] [LE α] [DecidableRel LT.lt] [DecidableEq α] (lt_irrefl : ∀ (x : α), ¬x < x) (lt_trans : ∀ {x y z : α}, x < y → y < z → x < z) (not_lt : ∀ {x y : α}, ¬x < y → y ≤ x) (le_antisymm : ∀ {x y : α}, x ≤ y → y ≤ x → x = y)
Goal: Batteries.TransCmp fun x x_1 => compareOfLessAndEq x x_1
-- Batteries.BEqCmp.compareOfLessAndEq
protected theorem BEqCmp.compareOfLessAndEq
    [LT α] [DecidableRel (LT.lt (α := α))] [DecidableEq α] [BEq α] [LawfulBEq α]
    (lt_irrefl : ∀ x : α, ¬x < x) :
    BEqCmp (α := α) (compareOfLessAndEq · ·) 
Arguments: {α : Type u_1} [LT α] [DecidableRel LT.lt] [DecidableEq α] [BEq α] [LawfulBEq α] (lt_irrefl : ∀ (x : α), ¬x < x)
Goal: Batteries.BEqCmp fun x x_1 => compareOfLessAndEq x x_1
-- Batteries.LTCmp.compareOfLessAndEq
protected theorem LTCmp.compareOfLessAndEq
    [LT α] [DecidableRel (LT.lt (α := α))] [DecidableEq α]
    (lt_irrefl : ∀ x : α, ¬x < x)
    (lt_trans : ∀ {x y z : α}, x < y → y < z → x < z)
    (lt_antisymm : ∀ {x y : α}, ¬x < y → ¬y < x → x = y) :
    LTCmp (α := α) (compareOfLessAndEq · ·) 
Arguments: {α : Type u_1} [LT α] [DecidableRel LT.lt] [DecidableEq α] (lt_irrefl : ∀ (x : α), ¬x < x) (lt_trans : ∀ {x y z : α}, x < y → y < z → x < z) (lt_antisymm : ∀ {x y : α}, ¬x < y → ¬y < x → x = y)
Goal: Batteries.LTCmp fun x x_1 => compareOfLessAndEq x x_1
-- Batteries.LTCmp.compareOfLessAndEq_of_le
protected theorem LTCmp.compareOfLessAndEq_of_le
    [LT α] [DecidableRel (LT.lt (α := α))] [DecidableEq α] [LE α]
    (lt_irrefl : ∀ x : α, ¬x < x)
    (lt_trans : ∀ {x y z : α}, x < y → y < z → x < z)
    (not_lt : ∀ {x y : α}, ¬x < y → y ≤ x)
    (le_antisymm : ∀ {x y : α}, x ≤ y → y ≤ x → x = y) :
    LTCmp (α := α) (compareOfLessAndEq · ·) 
Arguments: {α : Type u_1} [LT α] [DecidableRel LT.lt] [DecidableEq α] [LE α] (lt_irrefl : ∀ (x : α), ¬x < x) (lt_trans : ∀ {x y z : α}, x < y → y < z → x < z) (not_lt : ∀ {x y : α}, ¬x < y → y ≤ x) (le_antisymm : ∀ {x y : α}, x ≤ y → y ≤ x → x = y)
Goal: Batteries.LTCmp fun x x_1 => compareOfLessAndEq x x_1
-- Batteries.LECmp.compareOfLessAndEq
protected theorem LECmp.compareOfLessAndEq
    [LT α] [DecidableRel (LT.lt (α := α))] [DecidableEq α] [LE α]
    (lt_irrefl : ∀ x : α, ¬x < x)
    (lt_trans : ∀ {x y z : α}, x < y → y < z → x < z)
    (not_lt : ∀ {x y : α}, ¬x < y ↔ y ≤ x)
    (le_antisymm : ∀ {x y : α}, x ≤ y → y ≤ x → x = y) :
    LECmp (α := α) (compareOfLessAndEq · ·) 
Arguments: {α : Type u_1} [LT α] [DecidableRel LT.lt] [DecidableEq α] [LE α] (lt_irrefl : ∀ (x : α), ¬x < x) (lt_trans : ∀ {x y z : α}, x < y → y < z → x < z) (not_lt : ∀ {x y : α}, ¬x < y ↔ y ≤ x) (le_antisymm : ∀ {x y : α}, x ≤ y → y ≤ x → x = y)
Goal: Batteries.LECmp fun x x_1 => compareOfLessAndEq x x_1
-- Batteries.LawfulCmp.compareOfLessAndEq
protected theorem LawfulCmp.compareOfLessAndEq
    [LT α] [DecidableRel (LT.lt (α := α))] [DecidableEq α] [BEq α] [LawfulBEq α] [LE α]
    (lt_irrefl : ∀ x : α, ¬x < x)
    (lt_trans : ∀ {x y z : α}, x < y → y < z → x < z)
    (not_lt : ∀ {x y : α}, ¬x < y ↔ y ≤ x)
    (le_antisymm : ∀ {x y : α}, x ≤ y → y ≤ x → x = y) :
    LawfulCmp (α := α) (compareOfLessAndEq · ·) 
Arguments: {α : Type u_1} [LT α] [DecidableRel LT.lt] [DecidableEq α] [BEq α] [LawfulBEq α] [LE α] (lt_irrefl : ∀ (x : α), ¬x < x) (lt_trans : ∀ {x y z : α}, x < y → y < z → x < z) (not_lt : ∀ {x y : α}, ¬x < y ↔ y ≤ x) (le_antisymm : ∀ {x y : α}, x ≤ y → y ≤ x → x = y)
Goal: Batteries.LawfulCmp fun x x_1 => compareOfLessAndEq x x_1
-- Batteries.LTCmp.eq_compareOfLessAndEq
theorem LTCmp.eq_compareOfLessAndEq
    [LT α] [DecidableEq α] [BEq α] [LawfulBEq α] [BEqCmp cmp] [LTCmp cmp]
    (x y : α) [Decidable (x < y)] : cmp x y = compareOfLessAndEq x y 
Arguments: {α : Type u_1} {cmp : α → α → Ordering} [LT α] [DecidableEq α] [BEq α] [LawfulBEq α] [Batteries.BEqCmp cmp] [Batteries.LTCmp cmp] (x y : α) [Decidable (x < y)]
Goal: cmp x y = compareOfLessAndEq x y
-- lexOrd_def
theorem _root_.lexOrd_def [Ord α] [Ord β] :
    (lexOrd : Ord (α × β)).compare = compareLex (compareOn (·.1)) (compareOn (·.2)) 
Arguments: {α : Type u_1} {β : Type u_2} [Ord α] [Ord β]
Goal: compare = compareLex (compareOn fun x => x.fst) (compareOn fun x => x.snd)
-- Batteries.OrientedOrd.instLexOrd
theorem OrientedOrd.instLexOrd [Ord α] [Ord β]
    [OrientedOrd α] [OrientedOrd β] : @OrientedOrd (α × β) lexOrd 
Arguments: {α : Type u_1} {β : Type u_2} [Ord α] [Ord β] [Batteries.OrientedOrd α] [Batteries.OrientedOrd β]
Goal: Batteries.OrientedOrd (α × β)
-- Batteries.TransOrd.instLexOrd
theorem TransOrd.instLexOrd [Ord α] [Ord β]
    [TransOrd α] [TransOrd β] : @TransOrd (α × β) lexOrd 
Arguments: {α : Type u_1} {β : Type u_2} [Ord α] [Ord β] [Batteries.TransOrd α] [Batteries.TransOrd β]
Goal: Batteries.TransOrd (α × β)
-- Batteries.OrientedOrd.instOpposite
theorem OrientedOrd.instOpposite [ord : Ord α] [inst : OrientedOrd α] :
    @OrientedOrd _ ord.opposite 
Arguments: {α : Type u_1} [ord : Ord α] [inst : Batteries.OrientedOrd α]
Goal: Batteries.OrientedOrd α
-- Batteries.TransOrd.instOpposite
theorem TransOrd.instOpposite [ord : Ord α] [inst : TransOrd α] : @TransOrd _ ord.opposite 
Arguments: {α : Type u_1} [ord : Ord α] [inst : Batteries.TransOrd α]
Goal: Batteries.TransOrd α
-- Batteries.OrientedOrd.instOn
theorem OrientedOrd.instOn [ord : Ord β] [OrientedOrd β] (f : α → β) : @OrientedOrd _ (ord.on f) 
Arguments: {β : Type u_1} {α : Type u_2} [ord : Ord β] [Batteries.OrientedOrd β] (f : α → β)
Goal: Batteries.OrientedOrd α
-- Batteries.TransOrd.instOn
theorem TransOrd.instOn [ord : Ord β] [TransOrd β] (f : α → β) : @TransOrd _ (ord.on f) 
Arguments: {β : Type u_1} {α : Type u_2} [ord : Ord β] [Batteries.TransOrd β] (f : α → β)
Goal: Batteries.TransOrd α
-- Batteries.OrientedOrd.instOrdLex
theorem OrientedOrd.instOrdLex [oα : Ord α] [oβ : Ord β] [OrientedOrd α] [OrientedOrd β] :
    @OrientedOrd _ (oα.lex oβ) 
Arguments: {α : Type u_1} {β : Type u_2} [oα : Ord α] [oβ : Ord β] [Batteries.OrientedOrd α] [Batteries.OrientedOrd β]
Goal: Batteries.OrientedOrd (α × β)
-- Batteries.TransOrd.instOrdLex
theorem TransOrd.instOrdLex [oα : Ord α] [oβ : Ord β] [TransOrd α] [TransOrd β] :
    @TransOrd _ (oα.lex oβ) 
Arguments: {α : Type u_1} {β : Type u_2} [oα : Ord α] [oβ : Ord β] [Batteries.TransOrd α] [Batteries.TransOrd β]
Goal: Batteries.TransOrd (α × β)
-- Batteries.OrientedOrd.instOrdLex'
theorem OrientedOrd.instOrdLex' (ord₁ ord₂ : Ord α) [@OrientedOrd _ ord₁] [@OrientedOrd _ ord₂] :
    @OrientedOrd _ (ord₁.lex' ord₂) 
Arguments: {α : Type u_1} (ord₁ ord₂ : Ord α) [Batteries.OrientedOrd α] [Batteries.OrientedOrd α]
Goal: Batteries.OrientedOrd α
-- Batteries.TransOrd.instOrdLex'
theorem TransOrd.instOrdLex' (ord₁ ord₂ : Ord α) [@TransOrd _ ord₁] [@TransOrd _ ord₂] :
    @TransOrd _ (ord₁.lex' ord₂) 
Arguments: {α : Type u_1} (ord₁ ord₂ : Ord α) [Batteries.TransOrd α] [Batteries.TransOrd α]
Goal: Batteries.TransOrd α
-- Sum.isLeft_inl
@[simp] theorem isLeft_inl : (inl x : α ⊕ β).isLeft = true 
Arguments: {α : Type u_1} {β : Type u_2} {x : α}
Goal: (Sum.inl x).isLeft = true
-- Sum.isLeft_inr
@[simp] theorem isLeft_inr : (inr x : α ⊕ β).isLeft = false 
Arguments: {α : Type u_1} {β : Type u_2} {x : β}
Goal: (Sum.inr x).isLeft = false
-- Sum.isRight_inl
@[simp] theorem isRight_inl : (inl x : α ⊕ β).isRight = false 
Arguments: {α : Type u_1} {β : Type u_2} {x : α}
Goal: (Sum.inl x).isRight = false
-- Sum.isRight_inr
@[simp] theorem isRight_inr : (inr x : α ⊕ β).isRight = true 
Arguments: {α : Type u_1} {β : Type u_2} {x : β}
Goal: (Sum.inr x).isRight = true
-- Sum.getLeft_inl
@[simp] theorem getLeft_inl (h : (inl x : α ⊕ β).isLeft) : (inl x).getLeft h = x 
Arguments: {α : Type u_1} {β : Type u_2} {x : α} (h : (Sum.inl x).isLeft = true)
Goal: (Sum.inl x).getLeft h = x
-- Sum.getRight_inr
@[simp] theorem getRight_inr (h : (inr x : α ⊕ β).isRight) : (inr x).getRight h = x 
Arguments: {α : Type u_1} {β : Type u_2} {x : β} (h : (Sum.inr x).isRight = true)
Goal: (Sum.inr x).getRight h = x
-- Sum.getLeft?_inl
@[simp] theorem getLeft?_inl : (inl x : α ⊕ β).getLeft? = some x 
Arguments: {α : Type u_1} {β : Type u_2} {x : α}
Goal: (Sum.inl x).getLeft? = some x
-- Sum.getLeft?_inr
@[simp] theorem getLeft?_inr : (inr x : α ⊕ β).getLeft? = none 
Arguments: {α : Type u_1} {β : Type u_2} {x : β}
Goal: (Sum.inr x).getLeft? = none
-- Sum.getRight?_inl
@[simp] theorem getRight?_inl : (inl x : α ⊕ β).getRight? = none 
Arguments: {α : Type u_1} {β : Type u_2} {x : α}
Goal: (Sum.inl x).getRight? = none
-- Sum.getRight?_inr
@[simp] theorem getRight?_inr : (inr x : α ⊕ β).getRight? = some x 
Arguments: {α : Type u_1} {β : Type u_2} {x : β}
Goal: (Sum.inr x).getRight? = some x
-- Sum.elim_inl
@[simp] theorem elim_inl (f : α → γ) (g : β → γ) (x : α) :
    Sum.elim f g (inl x) = f x 
Arguments: {α : Type u_1} {γ : Sort u_2} {β : Type u_3} (f : α → γ) (g : β → γ) (x : α)
Goal: Sum.elim f g (Sum.inl x) = f x
-- Sum.elim_inr
@[simp] theorem elim_inr (f : α → γ) (g : β → γ) (x : β) :
    Sum.elim f g (inr x) = g x 
Arguments: {α : Type u_1} {γ : Sort u_2} {β : Type u_3} (f : α → γ) (g : β → γ) (x : β)
Goal: Sum.elim f g (Sum.inr x) = g x
-- Sum.map_inl
@[simp] theorem map_inl (f : α → α') (g : β → β') (x : α) : (inl x).map f g = inl (f x) 
Arguments: {α : Type u_1} {α' : Type u_2} {β : Type u_3} {β' : Type u_4} (f : α → α') (g : β → β') (x : α)
Goal: Sum.map f g (Sum.inl x) = Sum.inl (f x)
-- Sum.map_inr
@[simp] theorem map_inr (f : α → α') (g : β → β') (x : β) : (inr x).map f g = inr (g x) 
Arguments: {α : Type u_1} {α' : Type u_2} {β : Type u_3} {β' : Type u_4} (f : α → α') (g : β → β') (x : β)
Goal: Sum.map f g (Sum.inr x) = Sum.inr (g x)
-- Sum.swap_inl
@[simp] theorem swap_inl : swap (inl x : α ⊕ β) = inr x 
Arguments: {α : Type u_1} {β : Type u_2} {x : α}
Goal: (Sum.inl x).swap = Sum.inr x
-- Sum.swap_inr
@[simp] theorem swap_inr : swap (inr x : α ⊕ β) = inl x 
Arguments: {α : Type u_1} {β : Type u_2} {x : β}
Goal: (Sum.inr x).swap = Sum.inl x
-- Sum.liftRel_inl_inl
@[simp] theorem liftRel_inl_inl : LiftRel r s (inl a) (inl c) ↔ r a c 
Goal: ∀ {α : Type u_1} {γ : Type u_2} {r : α → γ → Prop} {β : Type u_3} {δ : Type u_4} {s : β → δ → Prop} {a : α} {c : γ},
  Sum.LiftRel r s (Sum.inl a) (Sum.inl c) ↔ r a c
-- Sum.not_liftRel_inl_inr
@[simp] theorem not_liftRel_inl_inr : ¬LiftRel r s (inl a) (inr d) 
Goal: ∀ {α : Type u_1} {γ : Type u_2} {r : α → γ → Prop} {β : Type u_3} {δ : Type u_4} {s : β → δ → Prop} {a : α} {d : δ},
  ¬Sum.LiftRel r s (Sum.inl a) (Sum.inr d)
-- Sum.not_liftRel_inr_inl
@[simp] theorem not_liftRel_inr_inl : ¬LiftRel r s (inr b) (inl c) 
Goal: ∀ {α : Type u_1} {γ : Type u_2} {r : α → γ → Prop} {β : Type u_3} {δ : Type u_4} {s : β → δ → Prop} {b : β} {c : γ},
  ¬Sum.LiftRel r s (Sum.inr b) (Sum.inl c)
-- Sum.liftRel_inr_inr
@[simp] theorem liftRel_inr_inr : LiftRel r s (inr b) (inr d) ↔ s b d 
Goal: ∀ {α : Type u_1} {γ : Type u_2} {r : α → γ → Prop} {β : Type u_3} {δ : Type u_4} {s : β → δ → Prop} {b : β} {d : δ},
  Sum.LiftRel r s (Sum.inr b) (Sum.inr d) ↔ s b d
-- Sum.lex_inl_inl
@[simp] theorem lex_inl_inl : Lex r s (inl a₁) (inl a₂) ↔ r a₁ a₂ 
Goal: ∀ {α : Type u_1} {r : α → α → Prop} {β : Type u_2} {s : β → β → Prop} {a₁ a₂ : α},
  Sum.Lex r s (Sum.inl a₁) (Sum.inl a₂) ↔ r a₁ a₂
-- Sum.lex_inr_inr
@[simp] theorem lex_inr_inr : Lex r s (inr b₁) (inr b₂) ↔ s b₁ b₂ 
Goal: ∀ {α : Type u_1} {r : α → α → Prop} {β : Type u_2} {s : β → β → Prop} {b₁ b₂ : β},
  Sum.Lex r s (Sum.inr b₁) (Sum.inr b₂) ↔ s b₁ b₂
-- Sum.lex_inr_inl
@[simp] theorem lex_inr_inl : ¬Lex r s (inr b) (inl a) 
Goal: ∀ {α : Type u_1} {r : α → α → Prop} {β : Type u_2} {s : β → β → Prop} {b : β} {a : α},
  ¬Sum.Lex r s (Sum.inr b) (Sum.inl a)
-- _private.«.lake».packages.batteries.Batteries.Data.List.Init.Attach.0.List.pmap_eq_pmapImpl.go
@[csimp] private theorem pmap_eq_pmapImpl : @pmap = @pmapImpl 
Arguments: (α : Type u_2) (β : Type u_1) (p : α → Prop) (f : (a : α) → p a → β) (L' : List α) (hL' : ∀ ⦃x : α⦄, x ∈ L' → p x)
Goal: List.pmap f L' hL' =
  List.map
    (fun x =>
      match x with
      | ⟨x, hx⟩ => f x hx)
    (List.pmap Subtype.mk L' hL')
-- _private.«.lake».packages.batteries.Batteries.Data.List.Init.Attach.0.List.pmap_eq_pmapImpl
@[csimp] private theorem pmap_eq_pmapImpl : @pmap = @pmapImpl 
Goal: @List.pmap = @List.pmapImpl
-- List.eraseIdx_zero
@[simp] theorem eraseIdx_zero (l : List α) : eraseIdx l 0 = tail l 
Arguments: {α : Type u} (l : List α)
Goal: l.eraseIdx 0 = l.tail
-- List.eraseIdx_eq_take_drop_succ
theorem eraseIdx_eq_take_drop_succ :
    ∀ (l : List α) (i : Nat), l.eraseIdx i = l.take i ++ l.drop (i + 1)
  
Arguments: {α : Type u} (l : List α) (i : Nat)
Goal: l.eraseIdx i = List.take i l ++ List.drop (i + 1) l
-- List.eraseIdx_sublist
theorem eraseIdx_sublist : ∀ (l : List α) (k : Nat), eraseIdx l k <+ l
  
Arguments: {α : Type u} (l : List α) (k : Nat)
Goal: (l.eraseIdx k).Sublist l
-- List.eraseIdx_subset
theorem eraseIdx_subset (l : List α) (k : Nat) : eraseIdx l k ⊆ l 
Arguments: {α : Type u} (l : List α) (k : Nat)
Goal: l.eraseIdx k ⊆ l
-- List.eraseIdx_eq_self
@[simp]
theorem eraseIdx_eq_self : ∀ {l : List α} {k : Nat}, eraseIdx l k = l ↔ length l ≤ k
  
Arguments: {α : Type u} {l : List α} {k : Nat}
Goal: l.eraseIdx k = l ↔ l.length ≤ k
-- List.eraseIdx_append_of_lt_length
theorem eraseIdx_append_of_lt_length {l : List α} {k : Nat} (hk : k < length l) (l' : List α) :
    eraseIdx (l ++ l') k = eraseIdx l k ++ l' 
Arguments: {α : Type u} {l : List α} {k : Nat} (hk : k < l.length) (l' : List α)
Goal: (l ++ l').eraseIdx k = l.eraseIdx k ++ l'
-- List.eraseIdx_append_of_length_le
theorem eraseIdx_append_of_length_le {l : List α} {k : Nat} (hk : length l ≤ k) (l' : List α) :
    eraseIdx (l ++ l') k = l ++ eraseIdx l' (k - length l) 
Arguments: {α : Type u} {l : List α} {k : Nat} (hk : l.length ≤ k) (l' : List α)
Goal: (l ++ l').eraseIdx k = l ++ l'.eraseIdx (k - l.length)
-- List.IsPrefix.eraseIdx
protected theorem IsPrefix.eraseIdx {l l' : List α} (h : l <+: l') (k : Nat) :
    eraseIdx l k <+: eraseIdx l' k 
Arguments: {α : Type u} {l l' : List α} (h : l <+: l') (k : Nat)
Goal: l.eraseIdx k <+: l'.eraseIdx k
-- List.mem_eraseIdx_iff_getElem
theorem mem_eraseIdx_iff_getElem {x : α} :
    ∀ {l} {k}, x ∈ eraseIdx l k ↔ ∃ i : Fin l.length, ↑i ≠ k ∧ l[i.1] = x
  
Arguments: {α : Type u} {x : α} {l : List α} {k : Nat}
Goal: x ∈ l.eraseIdx k ↔ ∃ i, ↑i ≠ k ∧ l[↑i] = x
-- List.mem_eraseIdx_iff_get
@[deprecated mem_eraseIdx_iff_getElem (since := "2024-06-12")]
theorem mem_eraseIdx_iff_get {x : α} {l} {k} :
    x ∈ eraseIdx l k ↔ ∃ i : Fin l.length, ↑i ≠ k ∧ l.get i = x 
Arguments: {α : Type u} {x : α} {l : List α} {k : Nat}
Goal: x ∈ l.eraseIdx k ↔ ∃ i, ↑i ≠ k ∧ l.get i = x
-- List.mem_eraseIdx_iff_getElem?
theorem mem_eraseIdx_iff_getElem? {x : α} {l} {k} : x ∈ eraseIdx l k ↔ ∃ i ≠ k, l[i]? = some x 
Arguments: {α : Type u} {x : α} {l : List α} {k : Nat}
Goal: x ∈ l.eraseIdx k ↔ ∃ i, i ≠ k ∧ l[i]? = some x
-- List.mem_eraseIdx_iff_get?
@[deprecated mem_eraseIdx_iff_getElem? (since := "2024-06-12")]
theorem mem_eraseIdx_iff_get? {x : α} {l} {k} : x ∈ eraseIdx l k ↔ ∃ i ≠ k, l.get? i = x 
Arguments: {α : Type u} {x : α} {l : List α} {k : Nat}
Goal: x ∈ l.eraseIdx k ↔ ∃ i, i ≠ k ∧ l.get? i = some x
-- Sum.forall
@[simp] protected theorem «forall» {p : α ⊕ β → Prop} :
    (∀ x, p x) ↔ (∀ a, p (inl a)) ∧ ∀ b, p (inr b) 
Arguments: {α : Type u_1} {β : Type u_2} {p : α ⊕ β → Prop}
Goal: (∀ (x : α ⊕ β), p x) ↔ (∀ (a : α), p (Sum.inl a)) ∧ ∀ (b : β), p (Sum.inr b)
-- Sum.exists
@[simp] protected theorem «exists» {p : α ⊕ β → Prop} :
    (∃ x, p x) ↔ (∃ a, p (inl a)) ∨ ∃ b, p (inr b) 
Arguments: {α : Type u_1} {β : Type u_2} {p : α ⊕ β → Prop}
Goal: (∃ x, p x) ↔ (∃ a, p (Sum.inl a)) ∨ ∃ b, p (Sum.inr b)
-- Sum.forall_sum
theorem forall_sum {γ : α ⊕ β → Sort _} (p : (∀ ab, γ ab) → Prop) :
    (∀ fab, p fab) ↔ (∀ fa fb, p (Sum.rec fa fb)) 
Arguments: {α : Type u_1} {β : Type u_2} {γ : α ⊕ β → Sort u_3} (p : ((ab : α ⊕ β) → γ ab) → Prop)
Goal: (∀ (fab : (ab : α ⊕ β) → γ ab), p fab) ↔
  ∀ (fa : (val : α) → γ (Sum.inl val)) (fb : (val : β) → γ (Sum.inr val)), p fun t => Sum.rec fa fb t
-- Sum.inl_getLeft
@[simp] theorem inl_getLeft : ∀ (x : α ⊕ β) (h : x.isLeft), inl (x.getLeft h) = x
  
Arguments: {α : Type u_1} {β : Type u_2} (x : α ⊕ β) (h : x.isLeft = true)
Goal: Sum.inl (x.getLeft h) = x
-- Sum.inr_getRight
@[simp] theorem inr_getRight : ∀ (x : α ⊕ β) (h : x.isRight), inr (x.getRight h) = x
  
Arguments: {α : Type u_1} {β : Type u_2} (x : α ⊕ β) (h : x.isRight = true)
Goal: Sum.inr (x.getRight h) = x
-- Sum.getLeft?_eq_none_iff
@[simp] theorem getLeft?_eq_none_iff {x : α ⊕ β} : x.getLeft? = none ↔ x.isRight 
Arguments: {α : Type u_1} {β : Type u_2} {x : α ⊕ β}
Goal: x.getLeft? = none ↔ x.isRight = true
-- Sum.getRight?_eq_none_iff
@[simp] theorem getRight?_eq_none_iff {x : α ⊕ β} : x.getRight? = none ↔ x.isLeft 
Arguments: {α : Type u_1} {β : Type u_2} {x : α ⊕ β}
Goal: x.getRight? = none ↔ x.isLeft = true
-- Sum.eq_left_getLeft_of_isLeft
theorem eq_left_getLeft_of_isLeft : ∀ {x : α ⊕ β} (h : x.isLeft), x = inl (x.getLeft h)
  
Arguments: {α : Type u_1} {β : Type u_2} {x : α ⊕ β} (h : x.isLeft = true)
Goal: x = Sum.inl (x.getLeft h)