ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
-- Set.preimage_mul_const_Iio
@[simp]
theorem preimage_mul_const_Iio (a : α) {c : α} (h : 0 < c) :
    (fun x => x * c) ⁻¹' Iio a = Iio (a / c) 
Arguments: {α : Type u_1} [LinearOrderedField α] (a : α) {c : α} (h : 0 < c)
Goal: (fun x => x * c) ⁻¹' Set.Iio a = Set.Iio (a / c)
-- Set.preimage_mul_const_Ioi
@[simp]
theorem preimage_mul_const_Ioi (a : α) {c : α} (h : 0 < c) :
    (fun x => x * c) ⁻¹' Ioi a = Ioi (a / c) 
Arguments: {α : Type u_1} [LinearOrderedField α] (a : α) {c : α} (h : 0 < c)
Goal: (fun x => x * c) ⁻¹' Set.Ioi a = Set.Ioi (a / c)
-- Set.preimage_mul_const_Iic
@[simp]
theorem preimage_mul_const_Iic (a : α) {c : α} (h : 0 < c) :
    (fun x => x * c) ⁻¹' Iic a = Iic (a / c) 
Arguments: {α : Type u_1} [LinearOrderedField α] (a : α) {c : α} (h : 0 < c)
Goal: (fun x => x * c) ⁻¹' Set.Iic a = Set.Iic (a / c)
-- Set.preimage_mul_const_Ici
@[simp]
theorem preimage_mul_const_Ici (a : α) {c : α} (h : 0 < c) :
    (fun x => x * c) ⁻¹' Ici a = Ici (a / c) 
Arguments: {α : Type u_1} [LinearOrderedField α] (a : α) {c : α} (h : 0 < c)
Goal: (fun x => x * c) ⁻¹' Set.Ici a = Set.Ici (a / c)
-- Set.preimage_mul_const_Ioo
@[simp]
theorem preimage_mul_const_Ioo (a b : α) {c : α} (h : 0 < c) :
    (fun x => x * c) ⁻¹' Ioo a b = Ioo (a / c) (b / c) 
Arguments: {α : Type u_1} [LinearOrderedField α] (a b : α) {c : α} (h : 0 < c)
Goal: (fun x => x * c) ⁻¹' Set.Ioo a b = Set.Ioo (a / c) (b / c)
-- Set.preimage_mul_const_Ioc
@[simp]
theorem preimage_mul_const_Ioc (a b : α) {c : α} (h : 0 < c) :
    (fun x => x * c) ⁻¹' Ioc a b = Ioc (a / c) (b / c) 
Arguments: {α : Type u_1} [LinearOrderedField α] (a b : α) {c : α} (h : 0 < c)
Goal: (fun x => x * c) ⁻¹' Set.Ioc a b = Set.Ioc (a / c) (b / c)
-- Set.preimage_mul_const_Ico
@[simp]
theorem preimage_mul_const_Ico (a b : α) {c : α} (h : 0 < c) :
    (fun x => x * c) ⁻¹' Ico a b = Ico (a / c) (b / c) 
Arguments: {α : Type u_1} [LinearOrderedField α] (a b : α) {c : α} (h : 0 < c)
Goal: (fun x => x * c) ⁻¹' Set.Ico a b = Set.Ico (a / c) (b / c)
-- Set.preimage_mul_const_Icc
@[simp]
theorem preimage_mul_const_Icc (a b : α) {c : α} (h : 0 < c) :
    (fun x => x * c) ⁻¹' Icc a b = Icc (a / c) (b / c) 
Arguments: {α : Type u_1} [LinearOrderedField α] (a b : α) {c : α} (h : 0 < c)
Goal: (fun x => x * c) ⁻¹' Set.Icc a b = Set.Icc (a / c) (b / c)
-- Set.preimage_mul_const_Iio_of_neg
@[simp]
theorem preimage_mul_const_Iio_of_neg (a : α) {c : α} (h : c < 0) :
    (fun x => x * c) ⁻¹' Iio a = Ioi (a / c) 
Arguments: {α : Type u_1} [LinearOrderedField α] (a : α) {c : α} (h : c < 0)
Goal: (fun x => x * c) ⁻¹' Set.Iio a = Set.Ioi (a / c)
-- Set.preimage_mul_const_Ioi_of_neg
@[simp]
theorem preimage_mul_const_Ioi_of_neg (a : α) {c : α} (h : c < 0) :
    (fun x => x * c) ⁻¹' Ioi a = Iio (a / c) 
Arguments: {α : Type u_1} [LinearOrderedField α] (a : α) {c : α} (h : c < 0)
Goal: (fun x => x * c) ⁻¹' Set.Ioi a = Set.Iio (a / c)
-- Set.preimage_mul_const_Iic_of_neg
@[simp]
theorem preimage_mul_const_Iic_of_neg (a : α) {c : α} (h : c < 0) :
    (fun x => x * c) ⁻¹' Iic a = Ici (a / c) 
Arguments: {α : Type u_1} [LinearOrderedField α] (a : α) {c : α} (h : c < 0)
Goal: (fun x => x * c) ⁻¹' Set.Iic a = Set.Ici (a / c)
-- Set.preimage_mul_const_Ici_of_neg
@[simp]
theorem preimage_mul_const_Ici_of_neg (a : α) {c : α} (h : c < 0) :
    (fun x => x * c) ⁻¹' Ici a = Iic (a / c) 
Arguments: {α : Type u_1} [LinearOrderedField α] (a : α) {c : α} (h : c < 0)
Goal: (fun x => x * c) ⁻¹' Set.Ici a = Set.Iic (a / c)
-- Set.preimage_mul_const_Ioo_of_neg
@[simp]
theorem preimage_mul_const_Ioo_of_neg (a b : α) {c : α} (h : c < 0) :
    (fun x => x * c) ⁻¹' Ioo a b = Ioo (b / c) (a / c) 
Arguments: {α : Type u_1} [LinearOrderedField α] (a b : α) {c : α} (h : c < 0)
Goal: (fun x => x * c) ⁻¹' Set.Ioo a b = Set.Ioo (b / c) (a / c)
-- Set.preimage_mul_const_Ioc_of_neg
@[simp]
theorem preimage_mul_const_Ioc_of_neg (a b : α) {c : α} (h : c < 0) :
    (fun x => x * c) ⁻¹' Ioc a b = Ico (b / c) (a / c) 
Arguments: {α : Type u_1} [LinearOrderedField α] (a b : α) {c : α} (h : c < 0)
Goal: (fun x => x * c) ⁻¹' Set.Ioc a b = Set.Ico (b / c) (a / c)
-- Set.preimage_mul_const_Ico_of_neg
@[simp]
theorem preimage_mul_const_Ico_of_neg (a b : α) {c : α} (h : c < 0) :
    (fun x => x * c) ⁻¹' Ico a b = Ioc (b / c) (a / c) 
Arguments: {α : Type u_1} [LinearOrderedField α] (a b : α) {c : α} (h : c < 0)
Goal: (fun x => x * c) ⁻¹' Set.Ico a b = Set.Ioc (b / c) (a / c)
-- Set.preimage_mul_const_Icc_of_neg
@[simp]
theorem preimage_mul_const_Icc_of_neg (a b : α) {c : α} (h : c < 0) :
    (fun x => x * c) ⁻¹' Icc a b = Icc (b / c) (a / c) 
Arguments: {α : Type u_1} [LinearOrderedField α] (a b : α) {c : α} (h : c < 0)
Goal: (fun x => x * c) ⁻¹' Set.Icc a b = Set.Icc (b / c) (a / c)
-- Set.preimage_const_mul_Iio
@[simp]
theorem preimage_const_mul_Iio (a : α) {c : α} (h : 0 < c) : (c * ·) ⁻¹' Iio a = Iio (a / c) 
Arguments: {α : Type u_1} [LinearOrderedField α] (a : α) {c : α} (h : 0 < c)
Goal: (fun x => c * x) ⁻¹' Set.Iio a = Set.Iio (a / c)
-- Set.preimage_const_mul_Ioi
@[simp]
theorem preimage_const_mul_Ioi (a : α) {c : α} (h : 0 < c) : (c * ·) ⁻¹' Ioi a = Ioi (a / c) 
Arguments: {α : Type u_1} [LinearOrderedField α] (a : α) {c : α} (h : 0 < c)
Goal: (fun x => c * x) ⁻¹' Set.Ioi a = Set.Ioi (a / c)
-- Set.preimage_const_mul_Iic
@[simp]
theorem preimage_const_mul_Iic (a : α) {c : α} (h : 0 < c) : (c * ·) ⁻¹' Iic a = Iic (a / c) 
Arguments: {α : Type u_1} [LinearOrderedField α] (a : α) {c : α} (h : 0 < c)
Goal: (fun x => c * x) ⁻¹' Set.Iic a = Set.Iic (a / c)
-- Set.preimage_const_mul_Ici
@[simp]
theorem preimage_const_mul_Ici (a : α) {c : α} (h : 0 < c) : (c * ·) ⁻¹' Ici a = Ici (a / c) 
Arguments: {α : Type u_1} [LinearOrderedField α] (a : α) {c : α} (h : 0 < c)
Goal: (fun x => c * x) ⁻¹' Set.Ici a = Set.Ici (a / c)
-- Set.preimage_const_mul_Ioo
@[simp]
theorem preimage_const_mul_Ioo (a b : α) {c : α} (h : 0 < c) :
    (c * ·) ⁻¹' Ioo a b = Ioo (a / c) (b / c) 
Arguments: {α : Type u_1} [LinearOrderedField α] (a b : α) {c : α} (h : 0 < c)
Goal: (fun x => c * x) ⁻¹' Set.Ioo a b = Set.Ioo (a / c) (b / c)
-- Set.preimage_const_mul_Ioc
@[simp]
theorem preimage_const_mul_Ioc (a b : α) {c : α} (h : 0 < c) :
    (c * ·) ⁻¹' Ioc a b = Ioc (a / c) (b / c) 
Arguments: {α : Type u_1} [LinearOrderedField α] (a b : α) {c : α} (h : 0 < c)
Goal: (fun x => c * x) ⁻¹' Set.Ioc a b = Set.Ioc (a / c) (b / c)
-- Set.preimage_const_mul_Ico
@[simp]
theorem preimage_const_mul_Ico (a b : α) {c : α} (h : 0 < c) :
    (c * ·) ⁻¹' Ico a b = Ico (a / c) (b / c) 
Arguments: {α : Type u_1} [LinearOrderedField α] (a b : α) {c : α} (h : 0 < c)
Goal: (fun x => c * x) ⁻¹' Set.Ico a b = Set.Ico (a / c) (b / c)
-- Set.preimage_const_mul_Icc
@[simp]
theorem preimage_const_mul_Icc (a b : α) {c : α} (h : 0 < c) :
    (c * ·) ⁻¹' Icc a b = Icc (a / c) (b / c) 
Arguments: {α : Type u_1} [LinearOrderedField α] (a b : α) {c : α} (h : 0 < c)
Goal: (fun x => c * x) ⁻¹' Set.Icc a b = Set.Icc (a / c) (b / c)
-- Set.preimage_const_mul_Iio_of_neg
@[simp]
theorem preimage_const_mul_Iio_of_neg (a : α) {c : α} (h : c < 0) :
    (c * ·) ⁻¹' Iio a = Ioi (a / c) 
Arguments: {α : Type u_1} [LinearOrderedField α] (a : α) {c : α} (h : c < 0)
Goal: (fun x => c * x) ⁻¹' Set.Iio a = Set.Ioi (a / c)
-- Set.preimage_const_mul_Ioi_of_neg
@[simp]
theorem preimage_const_mul_Ioi_of_neg (a : α) {c : α} (h : c < 0) :
    (c * ·) ⁻¹' Ioi a = Iio (a / c) 
Arguments: {α : Type u_1} [LinearOrderedField α] (a : α) {c : α} (h : c < 0)
Goal: (fun x => c * x) ⁻¹' Set.Ioi a = Set.Iio (a / c)
-- Set.preimage_const_mul_Iic_of_neg
@[simp]
theorem preimage_const_mul_Iic_of_neg (a : α) {c : α} (h : c < 0) :
    (c * ·) ⁻¹' Iic a = Ici (a / c) 
Arguments: {α : Type u_1} [LinearOrderedField α] (a : α) {c : α} (h : c < 0)
Goal: (fun x => c * x) ⁻¹' Set.Iic a = Set.Ici (a / c)
-- Set.preimage_const_mul_Ici_of_neg
@[simp]
theorem preimage_const_mul_Ici_of_neg (a : α) {c : α} (h : c < 0) :
    (c * ·) ⁻¹' Ici a = Iic (a / c) 
Arguments: {α : Type u_1} [LinearOrderedField α] (a : α) {c : α} (h : c < 0)
Goal: (fun x => c * x) ⁻¹' Set.Ici a = Set.Iic (a / c)
-- Set.preimage_const_mul_Ioo_of_neg
@[simp]
theorem preimage_const_mul_Ioo_of_neg (a b : α) {c : α} (h : c < 0) :
    (c * ·) ⁻¹' Ioo a b = Ioo (b / c) (a / c) 
Arguments: {α : Type u_1} [LinearOrderedField α] (a b : α) {c : α} (h : c < 0)
Goal: (fun x => c * x) ⁻¹' Set.Ioo a b = Set.Ioo (b / c) (a / c)
-- Set.preimage_const_mul_Ioc_of_neg
@[simp]
theorem preimage_const_mul_Ioc_of_neg (a b : α) {c : α} (h : c < 0) :
    (c * ·) ⁻¹' Ioc a b = Ico (b / c) (a / c) 
Arguments: {α : Type u_1} [LinearOrderedField α] (a b : α) {c : α} (h : c < 0)
Goal: (fun x => c * x) ⁻¹' Set.Ioc a b = Set.Ico (b / c) (a / c)
-- Set.preimage_const_mul_Ico_of_neg
@[simp]
theorem preimage_const_mul_Ico_of_neg (a b : α) {c : α} (h : c < 0) :
    (c * ·) ⁻¹' Ico a b = Ioc (b / c) (a / c) 
Arguments: {α : Type u_1} [LinearOrderedField α] (a b : α) {c : α} (h : c < 0)
Goal: (fun x => c * x) ⁻¹' Set.Ico a b = Set.Ioc (b / c) (a / c)
-- Set.preimage_const_mul_Icc_of_neg
@[simp]
theorem preimage_const_mul_Icc_of_neg (a b : α) {c : α} (h : c < 0) :
    (c * ·) ⁻¹' Icc a b = Icc (b / c) (a / c) 
Arguments: {α : Type u_1} [LinearOrderedField α] (a b : α) {c : α} (h : c < 0)
Goal: (fun x => c * x) ⁻¹' Set.Icc a b = Set.Icc (b / c) (a / c)
-- Set.preimage_mul_const_uIcc
@[simp]
theorem preimage_mul_const_uIcc (ha : a ≠ 0) (b c : α) :
    (· * a) ⁻¹' [[b, c]] = [[b / a, c / a]] 
Arguments: {α : Type u_1} [LinearOrderedField α] {a : α} (ha : a ≠ 0) (b c : α)
Goal: (fun x => x * a) ⁻¹' [[b, c]] = [[b / a, c / a]]
-- Set.preimage_const_mul_uIcc
@[simp]
theorem preimage_const_mul_uIcc (ha : a ≠ 0) (b c : α) :
    (a * ·) ⁻¹' [[b, c]] = [[b / a, c / a]] 
Arguments: {α : Type u_1} [LinearOrderedField α] {a : α} (ha : a ≠ 0) (b c : α)
Goal: (fun x => a * x) ⁻¹' [[b, c]] = [[b / a, c / a]]
-- Set.preimage_div_const_uIcc
@[simp]
theorem preimage_div_const_uIcc (ha : a ≠ 0) (b c : α) :
    (fun x => x / a) ⁻¹' [[b, c]] = [[b * a, c * a]] 
Arguments: {α : Type u_1} [LinearOrderedField α] {a : α} (ha : a ≠ 0) (b c : α)
Goal: (fun x => x / a) ⁻¹' [[b, c]] = [[b * a, c * a]]
-- Set.image_mul_const_uIcc
@[simp]
theorem image_mul_const_uIcc (a b c : α) : (· * a) '' [[b, c]] = [[b * a, c * a]] 
Arguments: {α : Type u_1} [LinearOrderedField α] (a b c : α)
Goal: (fun x => x * a) '' [[b, c]] = [[b * a, c * a]]
-- Set.image_const_mul_uIcc
@[simp]
theorem image_const_mul_uIcc (a b c : α) : (a * ·) '' [[b, c]] = [[a * b, a * c]] 
Arguments: {α : Type u_1} [LinearOrderedField α] (a b c : α)
Goal: (fun x => a * x) '' [[b, c]] = [[a * b, a * c]]
-- Set.image_div_const_uIcc
@[simp]
theorem image_div_const_uIcc (a b c : α) : (fun x => x / a) '' [[b, c]] = [[b / a, c / a]] 
Arguments: {α : Type u_1} [LinearOrderedField α] (a b c : α)
Goal: (fun x => x / a) '' [[b, c]] = [[b / a, c / a]]
-- Set.image_mul_right_Icc'
theorem image_mul_right_Icc' (a b : α) {c : α} (h : 0 < c) :
    (fun x => x * c) '' Icc a b = Icc (a * c) (b * c) 
Arguments: {α : Type u_1} [LinearOrderedField α] (a b : α) {c : α} (h : 0 < c)
Goal: (fun x => x * c) '' Set.Icc a b = Set.Icc (a * c) (b * c)
-- Set.image_mul_right_Icc
theorem image_mul_right_Icc {a b c : α} (hab : a ≤ b) (hc : 0 ≤ c) :
    (fun x => x * c) '' Icc a b = Icc (a * c) (b * c) 
Arguments: {α : Type u_1} [LinearOrderedField α] {a b c : α} (hab : a ≤ b) (hc : 0 ≤ c)
Goal: (fun x => x * c) '' Set.Icc a b = Set.Icc (a * c) (b * c)
-- Set.image_mul_left_Icc'
theorem image_mul_left_Icc' {a : α} (h : 0 < a) (b c : α) :
    (a * ·) '' Icc b c = Icc (a * b) (a * c) 
Arguments: {α : Type u_1} [LinearOrderedField α] {a : α} (h : 0 < a) (b c : α)
Goal: (fun x => a * x) '' Set.Icc b c = Set.Icc (a * b) (a * c)
-- Set.image_mul_left_Icc
theorem image_mul_left_Icc {a b c : α} (ha : 0 ≤ a) (hbc : b ≤ c) :
    (a * ·) '' Icc b c = Icc (a * b) (a * c) 
Arguments: {α : Type u_1} [LinearOrderedField α] {a b c : α} (ha : 0 ≤ a) (hbc : b ≤ c)
Goal: (fun x => a * x) '' Set.Icc b c = Set.Icc (a * b) (a * c)
-- Set.image_mul_right_Ioo
theorem image_mul_right_Ioo (a b : α) {c : α} (h : 0 < c) :
    (fun x => x * c) '' Ioo a b = Ioo (a * c) (b * c) 
Arguments: {α : Type u_1} [LinearOrderedField α] (a b : α) {c : α} (h : 0 < c)
Goal: (fun x => x * c) '' Set.Ioo a b = Set.Ioo (a * c) (b * c)
-- Set.image_mul_left_Ioo
theorem image_mul_left_Ioo {a : α} (h : 0 < a) (b c : α) :
    (a * ·) '' Ioo b c = Ioo (a * b) (a * c) 
Arguments: {α : Type u_1} [LinearOrderedField α] {a : α} (h : 0 < a) (b c : α)
Goal: (fun x => a * x) '' Set.Ioo b c = Set.Ioo (a * b) (a * c)
-- Set.inv_Ioo_0_left
theorem inv_Ioo_0_left {a : α} (ha : 0 < a) : (Ioo 0 a)⁻¹ = Ioi a⁻¹ 
Arguments: {α : Type u_1} [LinearOrderedField α] {a : α} (ha : 0 < a)
Goal: (Set.Ioo 0 a)⁻¹ = Set.Ioi a⁻¹
-- Set.inv_Ioi
theorem inv_Ioi {a : α} (ha : 0 < a) : (Ioi a)⁻¹ = Ioo 0 a⁻¹ 
Arguments: {α : Type u_1} [LinearOrderedField α] {a : α} (ha : 0 < a)
Goal: (Set.Ioi a)⁻¹ = Set.Ioo 0 a⁻¹
-- Set.image_const_mul_Ioi_zero
theorem image_const_mul_Ioi_zero {k : Type*} [LinearOrderedField k] {x : k} (hx : 0 < x) :
    (fun y => x * y) '' Ioi (0 : k) = Ioi 0 
Arguments: {k : Type u_2} [LinearOrderedField k] {x : k} (hx : 0 < x)
Goal: (fun y => x * y) '' Set.Ioi 0 = Set.Ioi 0
-- Set.image_affine_Icc'
@[simp]
theorem image_affine_Icc' {a : α} (h : 0 < a) (b c d : α) :
    (a * · + b) '' Icc c d = Icc (a * c + b) (a * d + b) 
Arguments: {α : Type u_1} [LinearOrderedField α] {a : α} (h : 0 < a) (b c d : α)
Goal: (fun x => a * x + b) '' Set.Icc c d = Set.Icc (a * c + b) (a * d + b)
-- Multiset.sup_coe
@[simp]
theorem sup_coe (l : List α) : sup (l : Multiset α) = l.foldr (· ⊔ ·) ⊥ 
Arguments: {α : Type u_1} [SemilatticeSup α] [OrderBot α] (l : List α)
Goal: (↑l).sup = List.foldr (fun x x_1 => x ⊔ x_1) ⊥ l
-- Multiset.sup_zero
@[simp]
theorem sup_zero : (0 : Multiset α).sup = ⊥ 
Arguments: {α : Type u_1} [SemilatticeSup α] [OrderBot α]
Goal: Multiset.sup 0 = ⊥
-- Multiset.sup_cons
@[simp]
theorem sup_cons (a : α) (s : Multiset α) : (a ::ₘ s).sup = a ⊔ s.sup 
Arguments: {α : Type u_1} [SemilatticeSup α] [OrderBot α] (a : α) (s : Multiset α)
Goal: (a ::ₘ s).sup = a ⊔ s.sup
-- Multiset.sup_singleton
@[simp]
theorem sup_singleton {a : α} : ({a} : Multiset α).sup = a 
Arguments: {α : Type u_1} [SemilatticeSup α] [OrderBot α] {a : α}
Goal: {a}.sup = a
-- Multiset.sup_add
@[simp]
theorem sup_add (s₁ s₂ : Multiset α) : (s₁ + s₂).sup = s₁.sup ⊔ s₂.sup 
Arguments: {α : Type u_1} [SemilatticeSup α] [OrderBot α] (s₁ s₂ : Multiset α)
Goal: (s₁ + s₂).sup = s₁.sup ⊔ s₂.sup
-- Multiset.sup_le
@[simp]
theorem sup_le {s : Multiset α} {a : α} : s.sup ≤ a ↔ ∀ b ∈ s, b ≤ a 
Arguments: {α : Type u_1} [SemilatticeSup α] [OrderBot α] {s : Multiset α} {a : α}
Goal: s.sup ≤ a ↔ ∀ b ∈ s, b ≤ a
-- Multiset.le_sup
theorem le_sup {s : Multiset α} {a : α} (h : a ∈ s) : a ≤ s.sup 
Arguments: {α : Type u_1} [SemilatticeSup α] [OrderBot α] {s : Multiset α} {a : α} (h : a ∈ s)
Goal: a ≤ s.sup
-- Multiset.sup_mono
theorem sup_mono {s₁ s₂ : Multiset α} (h : s₁ ⊆ s₂) : s₁.sup ≤ s₂.sup 
Arguments: {α : Type u_1} [SemilatticeSup α] [OrderBot α] {s₁ s₂ : Multiset α} (h : s₁ ⊆ s₂)
Goal: s₁.sup ≤ s₂.sup
-- Multiset.sup_dedup
@[simp]
theorem sup_dedup (s : Multiset α) : (dedup s).sup = s.sup 
Arguments: {α : Type u_1} [SemilatticeSup α] [OrderBot α] [DecidableEq α] (s : Multiset α)
Goal: s.dedup.sup = s.sup
-- Multiset.sup_ndunion
@[simp]
theorem sup_ndunion (s₁ s₂ : Multiset α) : (ndunion s₁ s₂).sup = s₁.sup ⊔ s₂.sup 
Arguments: {α : Type u_1} [SemilatticeSup α] [OrderBot α] [DecidableEq α] (s₁ s₂ : Multiset α)
Goal: (s₁.ndunion s₂).sup = s₁.sup ⊔ s₂.sup
-- Multiset.sup_union
@[simp]
theorem sup_union (s₁ s₂ : Multiset α) : (s₁ ∪ s₂).sup = s₁.sup ⊔ s₂.sup 
Arguments: {α : Type u_1} [SemilatticeSup α] [OrderBot α] [DecidableEq α] (s₁ s₂ : Multiset α)
Goal: (s₁ ∪ s₂).sup = s₁.sup ⊔ s₂.sup
-- Multiset.sup_ndinsert
@[simp]
theorem sup_ndinsert (a : α) (s : Multiset α) : (ndinsert a s).sup = a ⊔ s.sup 
Arguments: {α : Type u_1} [SemilatticeSup α] [OrderBot α] [DecidableEq α] (a : α) (s : Multiset α)
Goal: (Multiset.ndinsert a s).sup = a ⊔ s.sup
-- Multiset.nodup_sup_iff
theorem nodup_sup_iff {α : Type*} [DecidableEq α] {m : Multiset (Multiset α)} :
    m.sup.Nodup ↔ ∀ a : Multiset α, a ∈ m → a.Nodup 
Arguments: {α : Type u_2} [DecidableEq α] {m : Multiset (Multiset α)}
Goal: m.sup.Nodup ↔ ∀ a ∈ m, a.Nodup
-- Multiset.inf_coe
@[simp]
theorem inf_coe (l : List α) : inf (l : Multiset α) = l.foldr (· ⊓ ·) ⊤ 
Arguments: {α : Type u_1} [SemilatticeInf α] [OrderTop α] (l : List α)
Goal: (↑l).inf = List.foldr (fun x x_1 => x ⊓ x_1) ⊤ l
-- Multiset.inf_zero
@[simp]
theorem inf_zero : (0 : Multiset α).inf = ⊤ 
Arguments: {α : Type u_1} [SemilatticeInf α] [OrderTop α]
Goal: Multiset.inf 0 = ⊤
-- Multiset.inf_cons
@[simp]
theorem inf_cons (a : α) (s : Multiset α) : (a ::ₘ s).inf = a ⊓ s.inf 
Arguments: {α : Type u_1} [SemilatticeInf α] [OrderTop α] (a : α) (s : Multiset α)
Goal: (a ::ₘ s).inf = a ⊓ s.inf
-- Multiset.inf_singleton
@[simp]
theorem inf_singleton {a : α} : ({a} : Multiset α).inf = a 
Arguments: {α : Type u_1} [SemilatticeInf α] [OrderTop α] {a : α}
Goal: {a}.inf = a
-- Multiset.inf_add
@[simp]
theorem inf_add (s₁ s₂ : Multiset α) : (s₁ + s₂).inf = s₁.inf ⊓ s₂.inf 
Arguments: {α : Type u_1} [SemilatticeInf α] [OrderTop α] (s₁ s₂ : Multiset α)
Goal: (s₁ + s₂).inf = s₁.inf ⊓ s₂.inf
-- Multiset.le_inf
@[simp]
theorem le_inf {s : Multiset α} {a : α} : a ≤ s.inf ↔ ∀ b ∈ s, a ≤ b 
Arguments: {α : Type u_1} [SemilatticeInf α] [OrderTop α] {s : Multiset α} {a : α}
Goal: a ≤ s.inf ↔ ∀ b ∈ s, a ≤ b
-- Multiset.inf_le
theorem inf_le {s : Multiset α} {a : α} (h : a ∈ s) : s.inf ≤ a 
Arguments: {α : Type u_1} [SemilatticeInf α] [OrderTop α] {s : Multiset α} {a : α} (h : a ∈ s)
Goal: s.inf ≤ a
-- Multiset.inf_mono
theorem inf_mono {s₁ s₂ : Multiset α} (h : s₁ ⊆ s₂) : s₂.inf ≤ s₁.inf 
Arguments: {α : Type u_1} [SemilatticeInf α] [OrderTop α] {s₁ s₂ : Multiset α} (h : s₁ ⊆ s₂)
Goal: s₂.inf ≤ s₁.inf
-- Multiset.inf_dedup
@[simp]
theorem inf_dedup (s : Multiset α) : (dedup s).inf = s.inf 
Arguments: {α : Type u_1} [SemilatticeInf α] [OrderTop α] [DecidableEq α] (s : Multiset α)
Goal: s.dedup.inf = s.inf
-- Multiset.inf_ndunion
@[simp]
theorem inf_ndunion (s₁ s₂ : Multiset α) : (ndunion s₁ s₂).inf = s₁.inf ⊓ s₂.inf 
Arguments: {α : Type u_1} [SemilatticeInf α] [OrderTop α] [DecidableEq α] (s₁ s₂ : Multiset α)
Goal: (s₁.ndunion s₂).inf = s₁.inf ⊓ s₂.inf
-- Multiset.inf_union
@[simp]
theorem inf_union (s₁ s₂ : Multiset α) : (s₁ ∪ s₂).inf = s₁.inf ⊓ s₂.inf 
Arguments: {α : Type u_1} [SemilatticeInf α] [OrderTop α] [DecidableEq α] (s₁ s₂ : Multiset α)
Goal: (s₁ ∪ s₂).inf = s₁.inf ⊓ s₂.inf
-- Multiset.inf_ndinsert
@[simp]
theorem inf_ndinsert (a : α) (s : Multiset α) : (ndinsert a s).inf = a ⊓ s.inf 
Arguments: {α : Type u_1} [SemilatticeInf α] [OrderTop α] [DecidableEq α] (a : α) (s : Multiset α)
Goal: (Multiset.ndinsert a s).inf = a ⊓ s.inf
-- Mathlib.Vector.mapAccumr_mapAccumr
@[simp]
theorem mapAccumr_mapAccumr :
    mapAccumr f₁ (mapAccumr f₂ xs s₂).snd s₁
    = let m := (mapAccumr (fun x s =>
        let r₂ := f₂ x s.snd
        let r₁ := f₁ r₂.snd s.fst
        ((r₁.fst, r₂.fst), r₁.snd)
      ) xs (s₁, s₂))
      (m.fst.fst, m.snd) 
Arguments: {α : Type u_3} {n : ℕ} {β : Type u_2} {σ₁ : Type} {γ : Type u_1} {σ₂ : Type} (xs : Mathlib.Vector α n) (f₁ : β → σ₁ → σ₁ × γ) (f₂ : α → σ₂ → σ₂ × β) {s₂ : σ₂} {s₁ : σ₁}
Goal: Mathlib.Vector.mapAccumr f₁ (Mathlib.Vector.mapAccumr f₂ xs s₂).2 s₁ =
  let m :=
    Mathlib.Vector.mapAccumr
      (fun x s =>
        let r₂ := f₂ x s.2;
        let r₁ := f₁ r₂.2 s.1;
        ((r₁.1, r₂.1), r₁.2))
      xs (s₁, s₂);
  (m.1.1, m.2)
-- Mathlib.Vector.mapAccumr_map
@[simp]
theorem mapAccumr_map (f₂ : α → β) :
    (mapAccumr f₁ (map f₂ xs) s) = (mapAccumr (fun x s => f₁ (f₂ x) s) xs s) 
Arguments: {α : Type u_3} {n : ℕ} {β : Type u_2} {σ₁ : Type} {γ : Type u_1} (xs : Mathlib.Vector α n) (f₁ : β → σ₁ → σ₁ × γ) {s : σ₁} (f₂ : α → β)
Goal: Mathlib.Vector.mapAccumr f₁ (Mathlib.Vector.map f₂ xs) s = Mathlib.Vector.mapAccumr (fun x s => f₁ (f₂ x) s) xs s
-- Mathlib.Vector.map_mapAccumr
@[simp]
theorem map_mapAccumr (f₁ : β → γ) :
    (map f₁ (mapAccumr f₂ xs s).snd) = (mapAccumr (fun x s =>
        let r := (f₂ x s); (r.fst, f₁ r.snd)
      ) xs s).snd 
Arguments: {α : Type u_3} {n : ℕ} {β : Type u_2} {γ : Type u_1} {σ₂ : Type} (xs : Mathlib.Vector α n) (f₂ : α → σ₂ → σ₂ × β) {s : σ₂} (f₁ : β → γ)
Goal: Mathlib.Vector.map f₁ (Mathlib.Vector.mapAccumr f₂ xs s).2 =
  (Mathlib.Vector.mapAccumr
      (fun x s =>
        let r := f₂ x s;
        (r.1, f₁ r.2))
      xs s).2
-- Mathlib.Vector.map_map
@[simp]
theorem map_map (f₁ : β → γ) (f₂ : α → β) :
    map f₁ (map f₂ xs) = map (fun x => f₁ <| f₂ x) xs 
Arguments: {α : Type u_3} {n : ℕ} {β : Type u_2} {γ : Type u_1} (xs : Mathlib.Vector α n) (f₁ : β → γ) (f₂ : α → β)
Goal: Mathlib.Vector.map f₁ (Mathlib.Vector.map f₂ xs) = Mathlib.Vector.map (fun x => f₁ (f₂ x)) xs
-- Mathlib.Vector.mapAccumr₂_mapAccumr_left
@[simp]
theorem mapAccumr₂_mapAccumr_left (f₁ : γ → β → σ₁ → σ₁ × ζ) (f₂ : α → σ₂ → σ₂ × γ) :
    (mapAccumr₂ f₁ (mapAccumr f₂ xs s₂).snd ys s₁)
    = let m := (mapAccumr₂ (fun x y s =>
          let r₂ := f₂ x s.snd
          let r₁ := f₁ r₂.snd y s.fst
          ((r₁.fst, r₂.fst), r₁.snd)
        ) xs ys (s₁, s₂))
      (m.fst.fst, m.snd) 
Arguments: {α : Type} {n : ℕ} {β : Type} (xs : Mathlib.Vector α n) (ys : Mathlib.Vector β n) {γ σ₁ ζ σ₂ : Type} {s₂ : σ₂} {s₁ : σ₁} (f₁ : γ → β → σ₁ → σ₁ × ζ) (f₂ : α → σ₂ → σ₂ × γ)
Goal: Mathlib.Vector.mapAccumr₂ f₁ (Mathlib.Vector.mapAccumr f₂ xs s₂).2 ys s₁ =
  let m :=
    Mathlib.Vector.mapAccumr₂
      (fun x y s =>
        let r₂ := f₂ x s.2;
        let r₁ := f₁ r₂.2 y s.1;
        ((r₁.1, r₂.1), r₁.2))
      xs ys (s₁, s₂);
  (m.1.1, m.2)
-- Mathlib.Vector.map₂_map_left
@[simp]
theorem map₂_map_left (f₁ : γ → β → ζ) (f₂ : α → γ) :
    map₂ f₁ (map f₂ xs) ys = map₂ (fun x y => f₁ (f₂ x) y) xs ys 
Arguments: {α : Type u_4} {n : ℕ} {β : Type u_3} (xs : Mathlib.Vector α n) (ys : Mathlib.Vector β n) {γ : Type u_1} {ζ : Type u_2} (f₁ : γ → β → ζ) (f₂ : α → γ)
Goal: Mathlib.Vector.map₂ f₁ (Mathlib.Vector.map f₂ xs) ys = Mathlib.Vector.map₂ (fun x y => f₁ (f₂ x) y) xs ys
-- Mathlib.Vector.mapAccumr₂_mapAccumr_right
@[simp]
theorem mapAccumr₂_mapAccumr_right (f₁ : α → γ → σ₁ → σ₁ × ζ) (f₂ : β → σ₂ → σ₂ × γ) :
    (mapAccumr₂ f₁ xs (mapAccumr f₂ ys s₂).snd s₁)
    = let m := (mapAccumr₂ (fun x y s =>
          let r₂ := f₂ y s.snd
          let r₁ := f₁ x r₂.snd s.fst
          ((r₁.fst, r₂.fst), r₁.snd)
        ) xs ys (s₁, s₂))
      (m.fst.fst, m.snd) 
Arguments: {α : Type} {n : ℕ} {β : Type} (xs : Mathlib.Vector α n) (ys : Mathlib.Vector β n) {γ σ₁ ζ σ₂ : Type} {s₂ : σ₂} {s₁ : σ₁} (f₁ : α → γ → σ₁ → σ₁ × ζ) (f₂ : β → σ₂ → σ₂ × γ)
Goal: Mathlib.Vector.mapAccumr₂ f₁ xs (Mathlib.Vector.mapAccumr f₂ ys s₂).2 s₁ =
  let m :=
    Mathlib.Vector.mapAccumr₂
      (fun x y s =>
        let r₂ := f₂ y s.2;
        let r₁ := f₁ x r₂.2 s.1;
        ((r₁.1, r₂.1), r₁.2))
      xs ys (s₁, s₂);
  (m.1.1, m.2)
-- Mathlib.Vector.map₂_map_right
@[simp]
theorem map₂_map_right (f₁ : α → γ → ζ) (f₂ : β → γ) :
    map₂ f₁ xs (map f₂ ys) = map₂ (fun x y => f₁ x (f₂ y)) xs ys 
Arguments: {α : Type u_3} {n : ℕ} {β : Type u_4} (xs : Mathlib.Vector α n) (ys : Mathlib.Vector β n) {γ : Type u_1} {ζ : Type u_2} (f₁ : α → γ → ζ) (f₂ : β → γ)
Goal: Mathlib.Vector.map₂ f₁ xs (Mathlib.Vector.map f₂ ys) = Mathlib.Vector.map₂ (fun x y => f₁ x (f₂ y)) xs ys
-- Mathlib.Vector.mapAccumr_mapAccumr₂
@[simp]
theorem mapAccumr_mapAccumr₂ (f₁ : γ → σ₁ → σ₁ × ζ) (f₂ : α → β → σ₂ → σ₂ × γ) :
    (mapAccumr f₁ (mapAccumr₂ f₂ xs ys s₂).snd s₁)
    = let m := mapAccumr₂ (fun x y s =>
          let r₂ := f₂ x y s.snd
          let r₁ := f₁ r₂.snd s.fst
          ((r₁.fst, r₂.fst), r₁.snd)
        ) xs ys (s₁, s₂)
      (m.fst.fst, m.snd) 
Arguments: {α : Type} {n : ℕ} {β : Type} (xs : Mathlib.Vector α n) (ys : Mathlib.Vector β n) {γ σ₁ ζ σ₂ : Type} {s₂ : σ₂} {s₁ : σ₁} (f₁ : γ → σ₁ → σ₁ × ζ) (f₂ : α → β → σ₂ → σ₂ × γ)
Goal: Mathlib.Vector.mapAccumr f₁ (Mathlib.Vector.mapAccumr₂ f₂ xs ys s₂).2 s₁ =
  let m :=
    Mathlib.Vector.mapAccumr₂
      (fun x y s =>
        let r₂ := f₂ x y s.2;
        let r₁ := f₁ r₂.2 s.1;
        ((r₁.1, r₂.1), r₁.2))
      xs ys (s₁, s₂);
  (m.1.1, m.2)