ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
-- EReal.induction₂_neg_left
@[elab_as_elim]
lemma induction₂_neg_left {P : EReal → EReal → Prop} (neg_left : ∀ {x y}, P x y → P (-x) y)
    (top_top : P ⊤ ⊤) (top_pos : ∀ x : ℝ, 0 < x → P ⊤ x)
    (top_zero : P ⊤ 0) (top_neg : ∀ x : ℝ, x < 0 → P ⊤ x) (top_bot : P ⊤ ⊥)
    (zero_top : P 0 ⊤) (zero_bot : P 0 ⊥)
    (pos_top : ∀ x : ℝ, 0 < x → P x ⊤) (pos_bot : ∀ x : ℝ, 0 < x → P x ⊥)
    (coe_coe : ∀ x y : ℝ, P x y) : ∀ x y, P x y 
Arguments: {P : EReal → EReal → Prop} (neg_left : ∀ {x y : EReal}, P x y → P (-x) y) (top_top : P ⊤ ⊤) (top_pos : ∀ (x : ℝ), 0 < x → P ⊤ ↑x) (top_zero : P ⊤ 0) (top_neg : ∀ x < 0, P ⊤ ↑x) (top_bot : P ⊤ ⊥) (zero_top : P 0 ⊤) (zero_bot : P 0 ⊥) (pos_top : ∀ (x : ℝ), 0 < x → P ↑x ⊤) (pos_bot : ∀ (x : ℝ), 0 < x → P ↑x ⊥) (coe_coe : ∀ (x y : ℝ), P ↑x ↑y) (x y : EReal)
Goal: P x y
-- EReal.induction₂_symm_neg
@[elab_as_elim]
lemma induction₂_symm_neg {P : EReal → EReal → Prop}
    (symm : ∀ {x y}, P x y → P y x)
    (neg_left : ∀ {x y}, P x y → P (-x) y) (top_top : P ⊤ ⊤)
    (top_pos : ∀ x : ℝ, 0 < x → P ⊤ x) (top_zero : P ⊤ 0) (coe_coe : ∀ x y : ℝ, P x y) :
    ∀ x y, P x y 
Arguments: {P : EReal → EReal → Prop} (symm : ∀ {x y : EReal}, P x y → P y x) (neg_left : ∀ {x y : EReal}, P x y → P (-x) y) (top_top : P ⊤ ⊤) (top_pos : ∀ (x : ℝ), 0 < x → P ⊤ ↑x) (top_zero : P ⊤ 0) (coe_coe : ∀ (x y : ℝ), P ↑x ↑y) (x y : EReal)
Goal: P x y
-- EReal.neg_mul
protected lemma neg_mul (x y : EReal) : -x * y = -(x * y) 
Arguments: (x y : EReal)
Goal: -x * y = -(x * y)
-- EReal.right_distrib_of_nonneg
lemma right_distrib_of_nonneg {a b c : EReal} (ha : 0 ≤ a) (hb : 0 ≤ b) :
    (a + b) * c = a * c + b * c 
Arguments: {a b c : EReal} (ha : 0 ≤ a) (hb : 0 ≤ b)
Goal: (a + b) * c = a * c + b * c
-- EReal.left_distrib_of_nonneg
lemma left_distrib_of_nonneg {a b c : EReal} (ha : 0 ≤ a) (hb : 0 ≤ b) :
    c * (a + b) = c * a + c * b 
Arguments: {a b c : EReal} (ha : 0 ≤ a) (hb : 0 ≤ b)
Goal: c * (a + b) = c * a + c * b
-- EReal.le_iff_le_forall_real_gt
lemma le_iff_le_forall_real_gt (x y : EReal) : (∀ z : ℝ, x < z → y ≤ z) ↔ y ≤ x 
Arguments: (x y : EReal)
Goal: (∀ (z : ℝ), x < ↑z → y ≤ ↑z) ↔ y ≤ x
-- EReal.ge_iff_le_forall_real_lt
lemma ge_iff_le_forall_real_lt (x y : EReal) : (∀ z : ℝ, z < y → z ≤ x) ↔ y ≤ x 
Arguments: (x y : EReal)
Goal: (∀ (z : ℝ), ↑z < y → ↑z ≤ x) ↔ y ≤ x
-- EReal.abs_top
@[simp] theorem abs_top : (⊤ : EReal).abs = ⊤ 
Goal: ⊤.abs = ⊤
-- EReal.abs_bot
@[simp] theorem abs_bot : (⊥ : EReal).abs = ⊤ 
Goal: ⊥.abs = ⊤
-- EReal.abs_def
theorem abs_def (x : ℝ) : (x : EReal).abs = ENNReal.ofReal |x| 
Arguments: (x : ℝ)
Goal: (↑x).abs = ENNReal.ofReal |x|
-- EReal.abs_coe_lt_top
theorem abs_coe_lt_top (x : ℝ) : (x : EReal).abs < ⊤ 
Arguments: (x : ℝ)
Goal: (↑x).abs < ⊤
-- EReal.abs_eq_zero_iff
@[simp]
theorem abs_eq_zero_iff {x : EReal} : x.abs = 0 ↔ x = 0 
Arguments: {x : EReal}
Goal: x.abs = 0 ↔ x = 0
-- EReal.abs_zero
@[simp]
theorem abs_zero : (0 : EReal).abs = 0 
Goal: EReal.abs 0 = 0
-- EReal.coe_abs
@[simp]
theorem coe_abs (x : ℝ) : ((x : EReal).abs : EReal) = (|x| : ℝ) 
Arguments: (x : ℝ)
Goal: ↑(↑x).abs = ↑|x|
-- EReal.abs_neg
@[simp]
protected theorem abs_neg : ∀ x : EReal, (-x).abs = x.abs
  
Arguments: (x : EReal)
Goal: (-x).abs = x.abs
-- EReal.abs_mul
@[simp]
theorem abs_mul (x y : EReal) : (x * y).abs = x.abs * y.abs 
Arguments: (x y : EReal)
Goal: (x * y).abs = x.abs * y.abs
-- EReal.sign_top
theorem sign_top : sign (⊤ : EReal) = 1 
Goal: SignType.sign ⊤ = 1
-- EReal.sign_bot
theorem sign_bot : sign (⊥ : EReal) = -1 
Goal: SignType.sign ⊥ = -1
-- EReal.sign_coe
@[simp]
theorem sign_coe (x : ℝ) : sign (x : EReal) = sign x 
Arguments: (x : ℝ)
Goal: SignType.sign ↑x = SignType.sign x
-- EReal.coe_coe_sign
@[simp, norm_cast]
theorem coe_coe_sign (x : SignType) : ((x : ℝ) : EReal) = x 
Arguments: (x : SignType)
Goal: ↑↑x = ↑x
-- EReal.sign_neg
@[simp] theorem sign_neg : ∀ x : EReal, sign (-x) = -sign x
  
Arguments: (x : EReal)
Goal: SignType.sign (-x) = -SignType.sign x
-- EReal.sign_mul
@[simp]
theorem sign_mul (x y : EReal) : sign (x * y) = sign x * sign y 
Arguments: (x y : EReal)
Goal: SignType.sign (x * y) = SignType.sign x * SignType.sign y
-- EReal.sign_mul_abs
@[simp] protected theorem sign_mul_abs : ∀ x : EReal, (sign x * x.abs : EReal) = x
  
Arguments: (x : EReal)
Goal: ↑(SignType.sign x) * ↑x.abs = x
-- EReal.abs_mul_sign
@[simp] protected theorem abs_mul_sign (x : EReal) : (x.abs * sign x : EReal) = x 
Arguments: (x : EReal)
Goal: ↑x.abs * ↑(SignType.sign x) = x
-- EReal.sign_eq_and_abs_eq_iff_eq
theorem sign_eq_and_abs_eq_iff_eq {x y : EReal} :
    x.abs = y.abs ∧ sign x = sign y ↔ x = y 
Arguments: {x y : EReal}
Goal: x.abs = y.abs ∧ SignType.sign x = SignType.sign y ↔ x = y
-- EReal.le_iff_sign
theorem le_iff_sign {x y : EReal} :
    x ≤ y ↔ sign x < sign y ∨
      sign x = SignType.neg ∧ sign y = SignType.neg ∧ y.abs ≤ x.abs ∨
        sign x = SignType.zero ∧ sign y = SignType.zero ∨
          sign x = SignType.pos ∧ sign y = SignType.pos ∧ x.abs ≤ y.abs 
Arguments: {x y : EReal}
Goal: x ≤ y ↔
  SignType.sign x < SignType.sign y ∨
    SignType.sign x = SignType.neg ∧ SignType.sign y = SignType.neg ∧ y.abs ≤ x.abs ∨
      SignType.sign x = SignType.zero ∧ SignType.sign y = SignType.zero ∨
        SignType.sign x = SignType.pos ∧ SignType.sign y = SignType.pos ∧ x.abs ≤ y.abs
-- EReal.coe_pow
@[simp, norm_cast]
theorem coe_pow (x : ℝ) (n : ℕ) : (↑(x ^ n) : EReal) = (x : EReal) ^ n 
Arguments: (x : ℝ) (n : ℕ)
Goal: ↑(x ^ n) = ↑x ^ n
-- EReal.coe_ennreal_pow
@[simp, norm_cast]
theorem coe_ennreal_pow (x : ℝ≥0∞) (n : ℕ) : (↑(x ^ n) : EReal) = (x : EReal) ^ n 
Arguments: (x : ℝ≥0∞) (n : ℕ)
Goal: ↑(x ^ n) = ↑x ^ n
-- EReal.min_neg_neg
lemma min_neg_neg (x y : EReal) : min (-x) (-y) = -max x y 
Arguments: (x y : EReal)
Goal: min (-x) (-y) = -max x y
-- EReal.max_neg_neg
lemma max_neg_neg (x y : EReal) : max (-x) (-y) = -min x y 
Arguments: (x y : EReal)
Goal: max (-x) (-y) = -min x y
-- EReal.inv_bot
@[simp]
lemma inv_bot : (⊥ : EReal)⁻¹ = 0 
Goal: ⊥⁻¹ = 0
-- EReal.inv_top
@[simp]
lemma inv_top : (⊤ : EReal)⁻¹ = 0 
Goal: ⊤⁻¹ = 0
-- EReal.coe_inv
lemma coe_inv (x : ℝ) : (x⁻¹ : ℝ) = (x : EReal)⁻¹ 
Arguments: (x : ℝ)
Goal: ↑x⁻¹ = (↑x)⁻¹
-- EReal.inv_zero
@[simp]
lemma inv_zero : (0 : EReal)⁻¹ = 0 
Goal: 0⁻¹ = 0
-- EReal.inv_neg
lemma inv_neg (a : EReal) : (-a)⁻¹ = -a⁻¹ 
Arguments: (a : EReal)
Goal: (-a)⁻¹ = -a⁻¹
-- EReal.inv_inv
lemma inv_inv {a : EReal} (h : a ≠ ⊥) (h' : a ≠ ⊤) : (a⁻¹)⁻¹ = a 
Arguments: {a : EReal} (h : a ≠ ⊥) (h' : a ≠ ⊤)
Goal: a⁻¹⁻¹ = a
-- EReal.mul_inv
lemma mul_inv (a b : EReal) : (a * b)⁻¹ = a⁻¹ * b⁻¹ 
Arguments: (a b : EReal)
Goal: (a * b)⁻¹ = a⁻¹ * b⁻¹
-- EReal.sign_mul_inv_abs
lemma sign_mul_inv_abs (a : EReal) : (sign a) * (a.abs : EReal)⁻¹ = a⁻¹ 
Arguments: (a : EReal)
Goal: ↑(SignType.sign a) * (↑a.abs)⁻¹ = a⁻¹
-- EReal.sign_mul_inv_abs'
lemma sign_mul_inv_abs' (a : EReal) : (sign a) * ((a.abs⁻¹ : ℝ≥0∞) : EReal) = a⁻¹ 
Arguments: (a : EReal)
Goal: ↑(SignType.sign a) * ↑a.abs⁻¹ = a⁻¹
-- EReal.inv_nonneg_of_nonneg
lemma inv_nonneg_of_nonneg {a : EReal} (h : 0 ≤ a) : 0 ≤ a⁻¹ 
Arguments: {a : EReal} (h : 0 ≤ a)
Goal: 0 ≤ a⁻¹
-- EReal.inv_nonpos_of_nonpos
lemma inv_nonpos_of_nonpos {a : EReal} (h : a ≤ 0) : a⁻¹ ≤ 0 
Arguments: {a : EReal} (h : a ≤ 0)
Goal: a⁻¹ ≤ 0
-- EReal.inv_pos_of_pos_ne_top
lemma inv_pos_of_pos_ne_top {a : EReal} (h : 0 < a) (h' : a ≠ ⊤) : 0 < a⁻¹ 
Arguments: {a : EReal} (h : 0 < a) (h' : a ≠ ⊤)
Goal: 0 < a⁻¹
-- EReal.inv_neg_of_neg_ne_bot
lemma inv_neg_of_neg_ne_bot {a : EReal} (h : a < 0) (h' : a ≠ ⊥) : a⁻¹ < 0 
Arguments: {a : EReal} (h : a < 0) (h' : a ≠ ⊥)
Goal: a⁻¹ < 0
-- EReal.div_eq_inv_mul
lemma div_eq_inv_mul (a b : EReal) : a / b = b⁻¹ * a 
Arguments: (a b : EReal)
Goal: a / b = b⁻¹ * a
-- EReal.coe_div
lemma coe_div (a b : ℝ) : (a / b : ℝ) = (a : EReal) / (b : EReal) 
Arguments: (a b : ℝ)
Goal: ↑(a / b) = ↑a / ↑b
-- EReal.natCast_div_le
theorem natCast_div_le (m n : ℕ) :
    (m / n : ℕ) ≤ (m : EReal) / (n : EReal) 
Arguments: (m n : ℕ)
Goal: ↑(m / n) ≤ ↑m / ↑n
-- EReal.div_bot
@[simp]
lemma div_bot {a : EReal} : a / ⊥ = 0 
Arguments: {a : EReal}
Goal: a / ⊥ = 0
-- EReal.div_top
@[simp]
lemma div_top {a : EReal} : a / ⊤ = 0 
Arguments: {a : EReal}
Goal: a / ⊤ = 0
-- EReal.div_zero
@[simp]
lemma div_zero {a : EReal} : a / 0 = 0 
Arguments: {a : EReal}
Goal: a / 0 = 0
-- EReal.zero_div
@[simp]
lemma zero_div {a : EReal} : 0 / a = 0 
Arguments: {a : EReal}
Goal: 0 / a = 0
-- EReal.top_div_of_pos_ne_top
lemma top_div_of_pos_ne_top {a : EReal} (h : 0 < a) (h' : a ≠ ⊤) : ⊤ / a = ⊤ 
Arguments: {a : EReal} (h : 0 < a) (h' : a ≠ ⊤)
Goal: ⊤ / a = ⊤
-- EReal.top_div_of_neg_ne_bot
lemma top_div_of_neg_ne_bot {a : EReal} (h : a < 0) (h' : a ≠ ⊥) : ⊤ / a = ⊥ 
Arguments: {a : EReal} (h : a < 0) (h' : a ≠ ⊥)
Goal: ⊤ / a = ⊥
-- EReal.bot_div_of_pos_ne_top
lemma bot_div_of_pos_ne_top {a : EReal} (h : 0 < a) (h' : a ≠ ⊤) : ⊥ / a = ⊥ 
Arguments: {a : EReal} (h : 0 < a) (h' : a ≠ ⊤)
Goal: ⊥ / a = ⊥
-- EReal.bot_div_of_neg_ne_bot
lemma bot_div_of_neg_ne_bot {a : EReal} (h : a < 0) (h' : a ≠ ⊥) : ⊥ / a = ⊤ 
Arguments: {a : EReal} (h : a < 0) (h' : a ≠ ⊥)
Goal: ⊥ / a = ⊤
-- EReal.div_self
lemma div_self {a : EReal} (h₁ : a ≠ ⊥) (h₂ : a ≠ ⊤) (h₃ : a ≠ 0) : a / a = 1 
Arguments: {a : EReal} (h₁ : a ≠ ⊥) (h₂ : a ≠ ⊤) (h₃ : a ≠ 0)
Goal: a / a = 1
-- EReal.mul_div
lemma mul_div (a b c : EReal) : a * (b / c) = (a * b) / c 
Arguments: (a b c : EReal)
Goal: a * (b / c) = a * b / c
-- EReal.mul_div_right
lemma mul_div_right (a b c : EReal) : (a / b) * c = (a * c) / b 
Arguments: (a b c : EReal)
Goal: a / b * c = a * c / b
-- EReal.div_div
lemma div_div (a b c : EReal) : a / b / c = a / (b * c) 
Arguments: (a b c : EReal)
Goal: a / b / c = a / (b * c)
-- EReal.div_mul_cancel
lemma div_mul_cancel {a b : EReal} (h₁ : b ≠ ⊥) (h₂ : b ≠ ⊤) (h₃ : b ≠ 0) : (a / b) * b = a 
Arguments: {a b : EReal} (h₁ : b ≠ ⊥) (h₂ : b ≠ ⊤) (h₃ : b ≠ 0)
Goal: a / b * b = a
-- EReal.mul_div_cancel
lemma mul_div_cancel {a b : EReal} (h₁ : b ≠ ⊥) (h₂ : b ≠ ⊤) (h₃ : b ≠ 0) : b * (a / b) = a 
Arguments: {a b : EReal} (h₁ : b ≠ ⊥) (h₂ : b ≠ ⊤) (h₃ : b ≠ 0)
Goal: b * (a / b) = a
-- EReal.mul_div_mul_cancel
lemma mul_div_mul_cancel {a b c : EReal} (h₁ : c ≠ ⊥) (h₂ : c ≠ ⊤) (h₃ : c ≠ 0) :
    (a * c) / (b * c) = a / b 
Arguments: {a b c : EReal} (h₁ : c ≠ ⊥) (h₂ : c ≠ ⊤) (h₃ : c ≠ 0)
Goal: a * c / (b * c) = a / b
-- EReal.div_right_distrib_of_nonneg
lemma div_right_distrib_of_nonneg {a b c : EReal} (h : 0 ≤ a) (h' : 0 ≤ b) :
    (a + b) / c = (a / c) + (b / c) 
Arguments: {a b c : EReal} (h : 0 ≤ a) (h' : 0 ≤ b)
Goal: (a + b) / c = a / c + b / c
-- EReal.monotone_div_right_of_nonneg
lemma monotone_div_right_of_nonneg {b : EReal} (h : 0 ≤ b) : Monotone fun a ↦ a / b 
Arguments: {b : EReal} (h : 0 ≤ b)
Goal: Monotone fun a => a / b
-- EReal.div_le_div_right_of_nonneg
lemma div_le_div_right_of_nonneg {a a' b : EReal} (h : 0 ≤ b) (h' : a ≤ a') :
    a / b ≤ a' / b 
Arguments: {a a' b : EReal} (h : 0 ≤ b) (h' : a ≤ a')
Goal: a / b ≤ a' / b
-- EReal.strictMono_div_right_of_pos
lemma strictMono_div_right_of_pos {b : EReal} (h : 0 < b) (h' : b ≠ ⊤) :
    StrictMono fun a ↦ a / b 
Arguments: {b : EReal} (h : 0 < b) (h' : b ≠ ⊤)
Goal: StrictMono fun a => a / b
-- EReal.div_lt_div_right_of_pos
lemma div_lt_div_right_of_pos {a a' b : EReal} (h₁ : 0 < b) (h₂ : b ≠ ⊤)
    (h₃ : a < a') : a / b < a' / b 
Arguments: {a a' b : EReal} (h₁ : 0 < b) (h₂ : b ≠ ⊤) (h₃ : a < a')
Goal: a / b < a' / b
-- EReal.antitone_div_right_of_nonpos
lemma antitone_div_right_of_nonpos {b : EReal} (h : b ≤ 0) : Antitone fun a ↦ a / b 
Arguments: {b : EReal} (h : b ≤ 0)
Goal: Antitone fun a => a / b
-- EReal.div_le_div_right_of_nonpos
lemma div_le_div_right_of_nonpos {a a' b : EReal} (h : b ≤ 0) (h' : a ≤ a') :
    a' / b ≤ a / b 
Arguments: {a a' b : EReal} (h : b ≤ 0) (h' : a ≤ a')
Goal: a' / b ≤ a / b
-- EReal.strictAnti_div_right_of_neg
lemma strictAnti_div_right_of_neg {b : EReal} (h : b < 0) (h' : b ≠ ⊥) :
    StrictAnti fun a ↦ a / b 
Arguments: {b : EReal} (h : b < 0) (h' : b ≠ ⊥)
Goal: StrictAnti fun a => a / b
-- EReal.div_lt_div_right_of_neg
lemma div_lt_div_right_of_neg {a a' b : EReal} (h₁ : b < 0) (h₂ : b ≠ ⊥)
    (h₃ : a < a') : a' / b < a / b 
Arguments: {a a' b : EReal} (h₁ : b < 0) (h₂ : b ≠ ⊥) (h₃ : a < a')
Goal: a' / b < a / b
-- EReal.le_div_iff_mul_le
lemma le_div_iff_mul_le {a b c : EReal} (h : b > 0) (h' : b ≠ ⊤) :
    a ≤ c / b ↔ a * b ≤ c 
Arguments: {a b c : EReal} (h : b > 0) (h' : b ≠ ⊤)
Goal: a ≤ c / b ↔ a * b ≤ c
-- EReal.div_le_iff_le_mul
lemma div_le_iff_le_mul {a b c : EReal} (h : 0 < b) (h' : b ≠ ⊤) :
    a / b ≤ c ↔ a ≤ b * c 
Arguments: {a b c : EReal} (h : 0 < b) (h' : b ≠ ⊤)
Goal: a / b ≤ c ↔ a ≤ b * c
-- EReal.div_nonneg
lemma div_nonneg {a b : EReal} (h : 0 ≤ a) (h' : 0 ≤ b) : 0 ≤ a / b 
Arguments: {a b : EReal} (h : 0 ≤ a) (h' : 0 ≤ b)
Goal: 0 ≤ a / b
-- EReal.div_nonpos_of_nonpos_of_nonneg
lemma div_nonpos_of_nonpos_of_nonneg {a b : EReal} (h : a ≤ 0) (h' : 0 ≤ b) : a / b ≤ 0 
Arguments: {a b : EReal} (h : a ≤ 0) (h' : 0 ≤ b)
Goal: a / b ≤ 0
-- EReal.div_nonpos_of_nonneg_of_nonpos
lemma div_nonpos_of_nonneg_of_nonpos {a b : EReal} (h : 0 ≤ a) (h' : b ≤ 0) : a / b ≤ 0 
Arguments: {a b : EReal} (h : 0 ≤ a) (h' : b ≤ 0)
Goal: a / b ≤ 0
-- EReal.div_nonneg_of_nonpos_of_nonpos
lemma div_nonneg_of_nonpos_of_nonpos {a b : EReal} (h : a ≤ 0) (h' : b ≤ 0) : 0 ≤ a / b 
Arguments: {a b : EReal} (h : a ≤ 0) (h' : b ≤ 0)
Goal: 0 ≤ a / b
-- DFinsupp.lex_fibration
theorem lex_fibration [∀ (i) (s : Set ι), Decidable (i ∈ s)] :
    Fibration (InvImage (GameAdd (DFinsupp.Lex r s) (DFinsupp.Lex r s)) snd) (DFinsupp.Lex r s)
      fun x => piecewise x.2.1 x.2.2 x.1 
Arguments: {ι : Type u_1} {α : ι → Type u_2} [(i : ι) → Zero (α i)] (r : ι → ι → Prop) (s : (i : ι) → α i → α i → Prop) [(i : ι) → (s : Set ι) → Decidable (i ∈ s)]
Goal: Relation.Fibration (InvImage (Prod.GameAdd (DFinsupp.Lex r s) (DFinsupp.Lex r s)) Prod.snd) (DFinsupp.Lex r s) fun x =>
  x.2.1.piecewise x.2.2 x.1
-- DFinsupp.Lex.acc_of_single_erase
theorem Lex.acc_of_single_erase [DecidableEq ι] {x : Π₀ i, α i} (i : ι)
    (hs : Acc (DFinsupp.Lex r s) <| single i (x i)) (hu : Acc (DFinsupp.Lex r s) <| x.erase i) :
    Acc (DFinsupp.Lex r s) x 
Arguments: {ι : Type u_1} {α : ι → Type u_2} [(i : ι) → Zero (α i)] {r : ι → ι → Prop} {s : (i : ι) → α i → α i → Prop} [DecidableEq ι] {x : Π₀ (i : ι), α i} (i : ι) (hs : Acc (DFinsupp.Lex r s) (DFinsupp.single i (x i))) (hu : Acc (DFinsupp.Lex r s) (DFinsupp.erase i x))
Goal: Acc (DFinsupp.Lex r s) x
-- DFinsupp.Lex.acc_zero
theorem Lex.acc_zero (hbot : ∀ ⦃i a⦄, ¬s i a 0) : Acc (DFinsupp.Lex r s) 0 
Arguments: {ι : Type u_1} {α : ι → Type u_2} [(i : ι) → Zero (α i)] {r : ι → ι → Prop} {s : (i : ι) → α i → α i → Prop} (hbot : ∀ ⦃i : ι⦄ ⦃a : α i⦄, ¬s i a 0)
Goal: Acc (DFinsupp.Lex r s) 0
-- DFinsupp.Lex.acc_of_single
theorem Lex.acc_of_single (hbot : ∀ ⦃i a⦄, ¬s i a 0) [DecidableEq ι]
    [∀ (i) (x : α i), Decidable (x ≠ 0)] (x : Π₀ i, α i) :
    (∀ i ∈ x.support, Acc (DFinsupp.Lex r s) <| single i (x i)) → Acc (DFinsupp.Lex r s) x 
Arguments: {ι : Type u_1} {α : ι → Type u_2} [(i : ι) → Zero (α i)] {r : ι → ι → Prop} {s : (i : ι) → α i → α i → Prop} (hbot : ∀ ⦃i : ι⦄ ⦃a : α i⦄, ¬s i a 0) [DecidableEq ι] [(i : ι) → (x : α i) → Decidable (x ≠ 0)] (x : Π₀ (i : ι), α i)
Goal: (∀ i ∈ x.support, Acc (DFinsupp.Lex r s) (DFinsupp.single i (x i))) → Acc (DFinsupp.Lex r s) x
-- DFinsupp.Lex.acc_single
theorem Lex.acc_single (hbot : ∀ ⦃i a⦄, ¬s i a 0) (hs : ∀ i, WellFounded (s i))
    [DecidableEq ι] {i : ι} (hi : Acc (rᶜ ⊓ (· ≠ ·)) i) :
    ∀ a, Acc (DFinsupp.Lex r s) (single i a) 
Arguments: {ι : Type u_1} {α : ι → Type u_2} [(i : ι) → Zero (α i)] {r : ι → ι → Prop} {s : (i : ι) → α i → α i → Prop} (hbot : ∀ ⦃i : ι⦄ ⦃a : α i⦄, ¬s i a 0) (hs : ∀ (i : ι), WellFounded (s i)) [DecidableEq ι] {i : ι} (hi : Acc (rᶜ ⊓ fun x x_1 => x ≠ x_1) i) (a : α i)
Goal: Acc (DFinsupp.Lex r s) (DFinsupp.single i a)
-- DFinsupp.Lex.acc
theorem Lex.acc (hbot : ∀ ⦃i a⦄, ¬s i a 0) (hs : ∀ i, WellFounded (s i))
    [DecidableEq ι] [∀ (i) (x : α i), Decidable (x ≠ 0)] (x : Π₀ i, α i)
    (h : ∀ i ∈ x.support, Acc (rᶜ ⊓ (· ≠ ·)) i) : Acc (DFinsupp.Lex r s) x 
Arguments: {ι : Type u_1} {α : ι → Type u_2} [(i : ι) → Zero (α i)] {r : ι → ι → Prop} {s : (i : ι) → α i → α i → Prop} (hbot : ∀ ⦃i : ι⦄ ⦃a : α i⦄, ¬s i a 0) (hs : ∀ (i : ι), WellFounded (s i)) [DecidableEq ι] [(i : ι) → (x : α i) → Decidable (x ≠ 0)] (x : Π₀ (i : ι), α i) (h : ∀ i ∈ x.support, Acc (rᶜ ⊓ fun x x_1 => x ≠ x_1) i)
Goal: Acc (DFinsupp.Lex r s) x
-- DFinsupp.Lex.wellFounded
theorem Lex.wellFounded (hbot : ∀ ⦃i a⦄, ¬s i a 0) (hs : ∀ i, WellFounded (s i))
    (hr : WellFounded <| rᶜ ⊓ (· ≠ ·)) : WellFounded (DFinsupp.Lex r s) 
Arguments: {ι : Type u_1} {α : ι → Type u_2} [(i : ι) → Zero (α i)] {r : ι → ι → Prop} {s : (i : ι) → α i → α i → Prop} (hbot : ∀ ⦃i : ι⦄ ⦃a : α i⦄, ¬s i a 0) (hs : ∀ (i : ι), WellFounded (s i)) (hr : WellFounded (rᶜ ⊓ fun x x_1 => x ≠ x_1))
Goal: WellFounded (DFinsupp.Lex r s)
-- DFinsupp.Lex.wellFounded'
theorem Lex.wellFounded' (hbot : ∀ ⦃i a⦄, ¬s i a 0) (hs : ∀ i, WellFounded (s i))
    [IsTrichotomous ι r] (hr : WellFounded (Function.swap r)) :
    WellFounded (DFinsupp.Lex r s) 
Arguments: {ι : Type u_1} {α : ι → Type u_2} [(i : ι) → Zero (α i)] {r : ι → ι → Prop} {s : (i : ι) → α i → α i → Prop} (hbot : ∀ ⦃i : ι⦄ ⦃a : α i⦄, ¬s i a 0) (hs : ∀ (i : ι), WellFounded (s i)) [IsTrichotomous ι r] (hr : WellFounded (Function.swap r))
Goal: WellFounded (DFinsupp.Lex r s)
-- Pi.Lex.wellFounded
theorem Pi.Lex.wellFounded [IsStrictTotalOrder ι r] [Finite ι] (hs : ∀ i, WellFounded (s i)) :
    WellFounded (Pi.Lex r (fun {i} ↦ s i)) 
Arguments: {ι : Type u_1} {α : ι → Type u_2} (r : ι → ι → Prop) {s : (i : ι) → α i → α i → Prop} [IsStrictTotalOrder ι r] [Finite ι] (hs : ∀ (i : ι), WellFounded (s i))
Goal: WellFounded (Pi.Lex r fun {i} => s i)
-- DFinsupp.Lex.wellFounded_of_finite
theorem DFinsupp.Lex.wellFounded_of_finite [IsStrictTotalOrder ι r] [Finite ι] [∀ i, Zero (α i)]
    (hs : ∀ i, WellFounded (s i)) : WellFounded (DFinsupp.Lex r s) 
Arguments: {ι : Type u_1} {α : ι → Type u_2} (r : ι → ι → Prop) {s : (i : ι) → α i → α i → Prop} [IsStrictTotalOrder ι r] [Finite ι] [(i : ι) → Zero (α i)] (hs : ∀ (i : ι), WellFounded (s i))
Goal: WellFounded (DFinsupp.Lex r s)
-- DFinsupp.wellFoundedLT
protected theorem DFinsupp.wellFoundedLT [∀ i, Zero (α i)] [∀ i, Preorder (α i)]
    [∀ i, WellFoundedLT (α i)] (hbot : ∀ ⦃i⦄ ⦃a : α i⦄, ¬a < 0) : WellFoundedLT (Π₀ i, α i) 
Arguments: {ι : Type u_1} {α : ι → Type u_2} [(i : ι) → Zero (α i)] [(i : ι) → Preorder (α i)] [∀ (i : ι), WellFoundedLT (α i)] (hbot : ∀ ⦃i : ι⦄ ⦃a : α i⦄, ¬a < 0)
Goal: WellFoundedLT (Π₀ (i : ι), α i)
-- HolorIndex.cast_type
theorem cast_type (is : List ℕ) (eq : ds₁ = ds₂) (h : Forall₂ (· < ·) is ds₁) :
    (cast (congr_arg HolorIndex eq) ⟨is, h⟩).val = is 
Arguments: {ds₁ ds₂ : List ℕ} (is : List ℕ) (eq : ds₁ = ds₂) (h : List.Forall₂ (fun x x_1 => x < x_1) is ds₁)
Goal: ↑(cast ⋯ ⟨is, h⟩) = is
-- HolorIndex.take_take
theorem take_take : ∀ t : HolorIndex (ds₁ ++ ds₂ ++ ds₃), t.assocRight.take = t.take.take
  
Arguments: {ds₁ ds₂ ds₃ : List ℕ} (t : HolorIndex (ds₁ ++ ds₂ ++ ds₃))
Goal: t.assocRight.take = t.take.take
-- HolorIndex.drop_take
theorem drop_take : ∀ t : HolorIndex (ds₁ ++ ds₂ ++ ds₃), t.assocRight.drop.take = t.take.drop
  
Arguments: {ds₁ ds₂ ds₃ : List ℕ} (t : HolorIndex (ds₁ ++ ds₂ ++ ds₃))
Goal: t.assocRight.drop.take = t.take.drop
-- HolorIndex.drop_drop
theorem drop_drop : ∀ t : HolorIndex (ds₁ ++ ds₂ ++ ds₃), t.assocRight.drop.drop = t.drop
  
Arguments: {ds₁ ds₂ ds₃ : List ℕ} (t : HolorIndex (ds₁ ++ ds₂ ++ ds₃))
Goal: t.assocRight.drop.drop = t.drop
-- Holor.cast_type
theorem cast_type (eq : ds₁ = ds₂) (a : Holor α ds₁) :
    cast (congr_arg (Holor α) eq) a = fun t => a (cast (congr_arg HolorIndex eq.symm) t) 
Arguments: {α : Type} {ds₁ ds₂ : List ℕ} (eq : ds₁ = ds₂) (a : Holor α ds₁)
Goal: cast ⋯ a = fun t => a (cast ⋯ t)
-- Holor.mul_assoc0
theorem mul_assoc0 [Semigroup α] (x : Holor α ds₁) (y : Holor α ds₂) (z : Holor α ds₃) :
    x ⊗ y ⊗ z = (x ⊗ (y ⊗ z)).assocLeft 
Arguments: {α : Type} {ds₁ ds₂ ds₃ : List ℕ} [Semigroup α] (x : Holor α ds₁) (y : Holor α ds₂) (z : Holor α ds₃)
Goal: (x.mul y).mul z = (x.mul (y.mul z)).assocLeft
-- Holor.mul_assoc
theorem mul_assoc [Semigroup α] (x : Holor α ds₁) (y : Holor α ds₂) (z : Holor α ds₃) :
    HEq (mul (mul x y) z) (mul x (mul y z)) 
Arguments: {α : Type} {ds₁ ds₂ ds₃ : List ℕ} [Semigroup α] (x : Holor α ds₁) (y : Holor α ds₂) (z : Holor α ds₃)
Goal: HEq ((x.mul y).mul z) (x.mul (y.mul z))
-- Holor.mul_left_distrib
theorem mul_left_distrib [Distrib α] (x : Holor α ds₁) (y : Holor α ds₂) (z : Holor α ds₂) :
    x ⊗ (y + z) = x ⊗ y + x ⊗ z 
Arguments: {α : Type} {ds₁ ds₂ : List ℕ} [Distrib α] (x : Holor α ds₁) (y z : Holor α ds₂)
Goal: x.mul (y + z) = x.mul y + x.mul z
-- Holor.mul_right_distrib
theorem mul_right_distrib [Distrib α] (x : Holor α ds₁) (y : Holor α ds₁) (z : Holor α ds₂) :
    (x + y) ⊗ z = x ⊗ z + y ⊗ z 
Arguments: {α : Type} {ds₁ ds₂ : List ℕ} [Distrib α] (x y : Holor α ds₁) (z : Holor α ds₂)
Goal: (x + y).mul z = x.mul z + y.mul z
-- Holor.zero_mul
@[simp]
nonrec theorem zero_mul {α : Type} [Ring α] (x : Holor α ds₂) : (0 : Holor α ds₁) ⊗ x = 0 
Arguments: {ds₁ ds₂ : List ℕ} {α : Type} [Ring α] (x : Holor α ds₂)
Goal: Holor.mul 0 x = 0
-- Holor.mul_zero
@[simp]
nonrec theorem mul_zero {α : Type} [Ring α] (x : Holor α ds₁) : x ⊗ (0 : Holor α ds₂) = 0 
Arguments: {ds₁ ds₂ : List ℕ} {α : Type} [Ring α] (x : Holor α ds₁)
Goal: x.mul 0 = 0
-- Holor.mul_scalar_mul
theorem mul_scalar_mul [Monoid α] (x : Holor α []) (y : Holor α ds) :
    x ⊗ y = x ⟨[], Forall₂.nil⟩ • y 
Arguments: {α : Type} {ds : List ℕ} [Monoid α] (x : Holor α []) (y : Holor α ds)
Goal: x.mul y = x ⟨[], ⋯⟩ • y
-- Holor.holor_index_cons_decomp
theorem holor_index_cons_decomp (p : HolorIndex (d :: ds) → Prop) :
    ∀ t : HolorIndex (d :: ds),
      (∀ i is, ∀ h : t.1 = i :: is, p ⟨i :: is, by rw [← h]; exact t.2⟩) → p t
  
Arguments: {d : ℕ} {ds : List ℕ} (p : HolorIndex (d :: ds) → Prop) (t : HolorIndex (d :: ds))
Goal: (∀ (i : ℕ) (is : List ℕ) (h : ↑t = i :: is), p ⟨i :: is, ⋯⟩) → p t
-- Holor.slice_eq
theorem slice_eq (x : Holor α (d :: ds)) (y : Holor α (d :: ds)) (h : slice x = slice y) : x = y 
Arguments: {α : Type} {d : ℕ} {ds : List ℕ} (x y : Holor α (d :: ds)) (h : x.slice = y.slice)
Goal: x = y
-- Holor.slice_unitVec_mul
theorem slice_unitVec_mul [Ring α] {i : ℕ} {j : ℕ} (hid : i < d) (x : Holor α ds) :
    slice (unitVec d j ⊗ x) i hid = if i = j then x else 0 
Arguments: {α : Type} {d : ℕ} {ds : List ℕ} [Ring α] {i j : ℕ} (hid : i < d) (x : Holor α ds)
Goal: ((Holor.unitVec d j).mul x).slice i hid = if i = j then x else 0
-- Holor.slice_add
theorem slice_add [Add α] (i : ℕ) (hid : i < d) (x : Holor α (d :: ds)) (y : Holor α (d :: ds)) :
    slice x i hid + slice y i hid = slice (x + y) i hid 
Arguments: {α : Type} {d : ℕ} {ds : List ℕ} [Add α] (i : ℕ) (hid : i < d) (x y : Holor α (d :: ds))
Goal: x.slice i hid + y.slice i hid = (x + y).slice i hid
-- Holor.slice_zero
theorem slice_zero [Zero α] (i : ℕ) (hid : i < d) : slice (0 : Holor α (d :: ds)) i hid = 0 
Arguments: {α : Type} {d : ℕ} {ds : List ℕ} [Zero α] (i : ℕ) (hid : i < d)
Goal: Holor.slice 0 i hid = 0
-- Holor.slice_sum
theorem slice_sum [AddCommMonoid α] {β : Type} (i : ℕ) (hid : i < d) (s : Finset β)
    (f : β → Holor α (d :: ds)) : (∑ x ∈ s, slice (f x) i hid) = slice (∑ x ∈ s, f x) i hid 
Arguments: {α : Type} {d : ℕ} {ds : List ℕ} [AddCommMonoid α] {β : Type} (i : ℕ) (hid : i < d) (s : Finset β) (f : β → Holor α (d :: ds))
Goal: ∑ x ∈ s, (f x).slice i hid = (∑ x ∈ s, f x).slice i hid
-- Holor.sum_unitVec_mul_slice
@[simp]
theorem sum_unitVec_mul_slice [Ring α] (x : Holor α (d :: ds)) :
    (∑ i ∈ (Finset.range d).attach,
        unitVec d i ⊗ slice x i (Nat.succ_le_of_lt (Finset.mem_range.1 i.prop))) =
      x 
Arguments: {α : Type} {d : ℕ} {ds : List ℕ} [Ring α] (x : Holor α (d :: ds))
Goal: ∑ i ∈ (Finset.range d).attach, (Holor.unitVec d ↑i).mul (x.slice ↑i ⋯) = x
-- Holor.cprankMax_nil
theorem cprankMax_nil [Monoid α] [AddMonoid α] (x : Holor α nil) : CPRankMax 1 x 
Arguments: {α : Type} [Monoid α] [AddMonoid α] (x : Holor α [])
Goal: Holor.CPRankMax 1 x