ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
-- List.alternatingProd_reverse
@[to_additive]
theorem alternatingProd_reverse :
    ∀ l : List α, alternatingProd (reverse l) = alternatingProd l ^ (-1 : ℤ) ^ (length l + 1)
  
Arguments: {α : Type u_2} [CommGroup α] (l : List α)
Goal: l.reverse.alternatingProd = l.alternatingProd ^ (-1) ^ (l.length + 1)
-- MulOpposite.op_list_prod
lemma op_list_prod : ∀ l : List M, op l.prod = (l.map op).reverse.prod 
Arguments: {M : Type u_4} [Monoid M] (l : List M)
Goal: MulOpposite.op l.prod = (List.map MulOpposite.op l).reverse.prod
-- MulOpposite.unop_list_prod
lemma unop_list_prod (l : List Mᵐᵒᵖ) : l.prod.unop = (l.map unop).reverse.prod 
Arguments: {M : Type u_4} [Monoid M] (l : List Mᵐᵒᵖ)
Goal: MulOpposite.unop l.prod = (List.map MulOpposite.unop l).reverse.prod
-- unop_map_list_prod
lemma unop_map_list_prod {F : Type*} [FunLike F M Nᵐᵒᵖ] [MonoidHomClass F M Nᵐᵒᵖ]
    (f : F) (l : List M) :
    (f l.prod).unop = (l.map (MulOpposite.unop ∘ f)).reverse.prod 
Arguments: {M : Type u_4} {N : Type u_5} [Monoid M] [Monoid N] {F : Type u_8} [FunLike F M Nᵐᵒᵖ] [MonoidHomClass F M Nᵐᵒᵖ] (f : F) (l : List M)
Goal: MulOpposite.unop (f l.prod) = (List.map (MulOpposite.unop ∘ ⇑f) l).reverse.prod
-- MonoidHom.unop_map_list_prod
@[deprecated _root_.unop_map_list_prod (since := "2023-01-10")]
protected theorem unop_map_list_prod (f : M →* Nᵐᵒᵖ) (l : List M) :
    (f l.prod).unop = (l.map (MulOpposite.unop ∘ f)).reverse.prod 
Arguments: {M : Type u_4} {N : Type u_5} [Monoid M] [Monoid N] (f : M →* Nᵐᵒᵖ) (l : List M)
Goal: MulOpposite.unop (f l.prod) = (List.map (MulOpposite.unop ∘ ⇑f) l).reverse.prod
-- RingCon.coe_algebraMap
@[simp, norm_cast]
theorem coe_algebraMap (c : RingCon A) (s : S) :
    (algebraMap S A s : c.Quotient) = algebraMap S _ s 
Arguments: {S : Type uS} [CommSemiring S] {A : Type uA} [Semiring A] [Algebra S A] (c : RingCon A) (s : S)
Goal: ↑((algebraMap S A) s) = (algebraMap S c.Quotient) s
-- RingQuot.Rel.add_right
theorem Rel.add_right {r : R → R → Prop} ⦃a b c : R⦄ (h : Rel r b c) : Rel r (a + b) (a + c) 
Arguments: {R : Type uR} [Semiring R] {r : R → R → Prop} ⦃a b c : R⦄ (h : RingQuot.Rel r b c)
Goal: RingQuot.Rel r (a + b) (a + c)
-- RingQuot.Rel.neg
theorem Rel.neg {R : Type uR} [Ring R] {r : R → R → Prop} ⦃a b : R⦄ (h : Rel r a b) :
    Rel r (-a) (-b) 
Arguments: {R : Type uR} [Ring R] {r : R → R → Prop} ⦃a b : R⦄ (h : RingQuot.Rel r a b)
Goal: RingQuot.Rel r (-a) (-b)
-- RingQuot.Rel.sub_left
theorem Rel.sub_left {R : Type uR} [Ring R] {r : R → R → Prop} ⦃a b c : R⦄ (h : Rel r a b) :
    Rel r (a - c) (b - c) 
Arguments: {R : Type uR} [Ring R] {r : R → R → Prop} ⦃a b c : R⦄ (h : RingQuot.Rel r a b)
Goal: RingQuot.Rel r (a - c) (b - c)
-- RingQuot.Rel.sub_right
theorem Rel.sub_right {R : Type uR} [Ring R] {r : R → R → Prop} ⦃a b c : R⦄ (h : Rel r b c) :
    Rel r (a - b) (a - c) 
Arguments: {R : Type uR} [Ring R] {r : R → R → Prop} ⦃a b c : R⦄ (h : RingQuot.Rel r b c)
Goal: RingQuot.Rel r (a - b) (a - c)
-- RingQuot.Rel.smul
theorem Rel.smul {r : A → A → Prop} (k : S) ⦃a b : A⦄ (h : Rel r a b) : Rel r (k • a) (k • b) 
Arguments: {S : Type uS} [CommSemiring S] {A : Type uA} [Semiring A] [Algebra S A] {r : A → A → Prop} (k : S) ⦃a b : A⦄ (h : RingQuot.Rel r a b)
Goal: RingQuot.Rel r (k • a) (k • b)
-- RingQuot.eqvGen_rel_eq
theorem eqvGen_rel_eq (r : R → R → Prop) : EqvGen (Rel r) = RingConGen.Rel r 
Arguments: {R : Type uR} [Semiring R] (r : R → R → Prop)
Goal: EqvGen (RingQuot.Rel r) = RingConGen.Rel r
-- _private.Mathlib.Algebra.RingQuot.0.RingQuot.zero_def
private irreducible_def zero : RingQuot r 
Arguments: {R : Type u_1} [Semiring R] (r : R → R → Prop)
Goal: RingQuot.zero r = { toQuot := Quot.mk (RingQuot.Rel r) 0 }
-- _private.Mathlib.Algebra.RingQuot.0.RingQuot.one_def
private irreducible_def one : RingQuot r 
Arguments: {R : Type u_1} [Semiring R] (r : R → R → Prop)
Goal: RingQuot.one r = { toQuot := Quot.mk (RingQuot.Rel r) 1 }
-- _private.Mathlib.Algebra.RingQuot.0.RingQuot.add_def
private irreducible_def add : RingQuot r → RingQuot r → RingQuot r
  
Arguments: {R : Type u_1} [Semiring R] (r : R → R → Prop)
Goal: ∀ (x x_1 : RingQuot r),
  RingQuot.add r x x_1 =
    match x, x_1 with
    | { toQuot := a }, { toQuot := b } => { toQuot := Quot.map₂ (fun x x_2 => x + x_2) ⋯ ⋯ a b }
-- _private.Mathlib.Algebra.RingQuot.0.RingQuot.mul_def
private irreducible_def mul : RingQuot r → RingQuot r → RingQuot r
  
Arguments: {R : Type u_1} [Semiring R] (r : R → R → Prop)
Goal: ∀ (x x_1 : RingQuot r),
  RingQuot.mul r x x_1 =
    match x, x_1 with
    | { toQuot := a }, { toQuot := b } => { toQuot := Quot.map₂ (fun x x_2 => x * x_2) ⋯ ⋯ a b }
-- _private.Mathlib.Algebra.RingQuot.0.RingQuot.neg_def
private irreducible_def neg {R : Type uR} [Ring R] (r : R → R → Prop) : RingQuot r → RingQuot r
  
Arguments: {R : Type u_1} [Ring R] (r : R → R → Prop)
Goal: ∀ (x : RingQuot r),
  RingQuot.neg r x =
    match x with
    | { toQuot := a } => { toQuot := Quot.map (fun a => -a) ⋯ a }
-- _private.Mathlib.Algebra.RingQuot.0.RingQuot.sub_def
private irreducible_def sub {R : Type uR} [Ring R] (r : R → R → Prop) :
  RingQuot r → RingQuot r → RingQuot r
  
Arguments: {R : Type u_1} [Ring R] (r : R → R → Prop)
Goal: ∀ (x x_1 : RingQuot r),
  RingQuot.sub r x x_1 =
    match x, x_1 with
    | { toQuot := a }, { toQuot := b } => { toQuot := Quot.map₂ Sub.sub ⋯ ⋯ a b }
-- _private.Mathlib.Algebra.RingQuot.0.RingQuot.npow_def
private irreducible_def npow (n : ℕ) : RingQuot r → RingQuot r
  
Arguments: {R : Type u_1} [Semiring R] (r : R → R → Prop) (n : ℕ)
Goal: ∀ (x : RingQuot r),
  RingQuot.npow r n x =
    match x with
    | { toQuot := a } => { toQuot := Quot.lift (fun a => Quot.mk (RingQuot.Rel r) (a ^ n)) ⋯ a }
-- RingQuot.zero_quot
theorem zero_quot : (⟨Quot.mk _ 0⟩ : RingQuot r) = 0 
Arguments: {R : Type uR} [Semiring R] (r : R → R → Prop)
Goal: { toQuot := Quot.mk (RingQuot.Rel r) 0 } = 0
-- RingQuot.one_quot
theorem one_quot : (⟨Quot.mk _ 1⟩ : RingQuot r) = 1 
Arguments: {R : Type uR} [Semiring R] (r : R → R → Prop)
Goal: { toQuot := Quot.mk (RingQuot.Rel r) 1 } = 1
-- RingQuot.add_quot
theorem add_quot {a b} : (⟨Quot.mk _ a⟩ + ⟨Quot.mk _ b⟩ : RingQuot r) = ⟨Quot.mk _ (a + b)⟩ 
Arguments: {R : Type uR} [Semiring R] (r : R → R → Prop) {a b : R}
Goal: { toQuot := Quot.mk (RingQuot.Rel r) a } + { toQuot := Quot.mk (RingQuot.Rel r) b } =
  { toQuot := Quot.mk (RingQuot.Rel r) (a + b) }
-- RingQuot.mul_quot
theorem mul_quot {a b} : (⟨Quot.mk _ a⟩ * ⟨Quot.mk _ b⟩ : RingQuot r) = ⟨Quot.mk _ (a * b)⟩ 
Arguments: {R : Type uR} [Semiring R] (r : R → R → Prop) {a b : R}
Goal: { toQuot := Quot.mk (RingQuot.Rel r) a } * { toQuot := Quot.mk (RingQuot.Rel r) b } =
  { toQuot := Quot.mk (RingQuot.Rel r) (a * b) }
-- RingQuot.pow_quot
theorem pow_quot {a} {n : ℕ} : (⟨Quot.mk _ a⟩ ^ n : RingQuot r) = ⟨Quot.mk _ (a ^ n)⟩ 
Arguments: {R : Type uR} [Semiring R] (r : R → R → Prop) {a : R} {n : ℕ}
Goal: { toQuot := Quot.mk (RingQuot.Rel r) a } ^ n = { toQuot := Quot.mk (RingQuot.Rel r) (a ^ n) }
-- RingQuot.neg_quot
theorem neg_quot {R : Type uR} [Ring R] (r : R → R → Prop) {a} :
    (-⟨Quot.mk _ a⟩ : RingQuot r) = ⟨Quot.mk _ (-a)⟩ 
Arguments: {R : Type uR} [Ring R] (r : R → R → Prop) {a : R}
Goal: -{ toQuot := Quot.mk (RingQuot.Rel r) a } = { toQuot := Quot.mk (RingQuot.Rel r) (-a) }
-- RingQuot.sub_quot
theorem sub_quot {R : Type uR} [Ring R] (r : R → R → Prop) {a b} :
    (⟨Quot.mk _ a⟩ - ⟨Quot.mk _ b⟩ : RingQuot r) = ⟨Quot.mk _ (a - b)⟩ 
Arguments: {R : Type uR} [Ring R] (r : R → R → Prop) {a b : R}
Goal: { toQuot := Quot.mk (RingQuot.Rel r) a } - { toQuot := Quot.mk (RingQuot.Rel r) b } =
  { toQuot := Quot.mk (RingQuot.Rel r) (a - b) }
-- RingQuot.smul_quot
theorem smul_quot [Algebra S R] {n : S} {a : R} :
    (n • ⟨Quot.mk _ a⟩ : RingQuot r) = ⟨Quot.mk _ (n • a)⟩ 
Arguments: {R : Type uR} [Semiring R] {S : Type uS} [CommSemiring S] (r : R → R → Prop) [Algebra S R] {n : S} {a : R}
Goal: n • { toQuot := Quot.mk (RingQuot.Rel r) a } = { toQuot := Quot.mk (RingQuot.Rel r) (n • a) }
-- RingQuot.mkRingHom_def
irreducible_def mkRingHom (r : R → R → Prop) : R →+* RingQuot r 
Arguments: {R : Type u_1} [Semiring R] (r : R → R → Prop)
Goal: RingQuot.mkRingHom r =
  { toFun := fun x => { toQuot := Quot.mk (RingQuot.Rel r) x }, map_one' := ⋯, map_mul' := ⋯, map_zero' := ⋯,
    map_add' := ⋯ }
-- RingQuot.mkRingHom_rel
theorem mkRingHom_rel {r : R → R → Prop} {x y : R} (w : r x y) : mkRingHom r x = mkRingHom r y 
Arguments: {R : Type uR} [Semiring R] {r : R → R → Prop} {x y : R} (w : r x y)
Goal: (RingQuot.mkRingHom r) x = (RingQuot.mkRingHom r) y
-- RingQuot.mkRingHom_surjective
theorem mkRingHom_surjective (r : R → R → Prop) : Function.Surjective (mkRingHom r) 
Arguments: {R : Type uR} [Semiring R] (r : R → R → Prop)
Goal: Function.Surjective ⇑(RingQuot.mkRingHom r)
-- RingQuot.ringQuot_ext
@[ext 1100]
theorem ringQuot_ext [Semiring T] {r : R → R → Prop} (f g : RingQuot r →+* T)
    (w : f.comp (mkRingHom r) = g.comp (mkRingHom r)) : f = g 
Arguments: {R : Type uR} [Semiring R] {T : Type uT} [Semiring T] {r : R → R → Prop} (f g : RingQuot r →+* T) (w : f.comp (RingQuot.mkRingHom r) = g.comp (RingQuot.mkRingHom r))
Goal: f = g
-- RingQuot.preLift_def
irreducible_def preLift {r : R → R → Prop} {f : R →+* T} (h : ∀ ⦃x y⦄, r x y → f x = f y) :
  RingQuot r →+* T 
Arguments: {R : Type u_1} [Semiring R] {T : Type u_2} [Semiring T] {r : R → R → Prop} {f : R →+* T} (h : ∀ ⦃x y : R⦄, r x y → f x = f y)
Goal: RingQuot.preLift h =
  { toFun := fun x => Quot.lift ⇑f ⋯ x.toQuot, map_one' := ⋯, map_mul' := ⋯, map_zero' := ⋯, map_add' := ⋯ }
-- RingQuot.lift_def
irreducible_def lift {r : R → R → Prop} :
  { f : R →+* T // ∀ ⦃x y⦄, r x y → f x = f y } ≃ (RingQuot r →+* T) 
Arguments: {R : Type u_1} [Semiring R] {T : Type u_2} [Semiring T] {r : R → R → Prop}
Goal: RingQuot.lift =
  { toFun := fun f => RingQuot.preLift ⋯, invFun := fun F => ⟨F.comp (RingQuot.mkRingHom r), ⋯⟩, left_inv := ⋯,
    right_inv := ⋯ }
-- RingQuot.lift_mkRingHom_apply
@[simp]
theorem lift_mkRingHom_apply (f : R →+* T) {r : R → R → Prop} (w : ∀ ⦃x y⦄, r x y → f x = f y) (x) :
    lift ⟨f, w⟩ (mkRingHom r x) = f x 
Arguments: {R : Type uR} [Semiring R] {T : Type uT} [Semiring T] (f : R →+* T) {r : R → R → Prop} (w : ∀ ⦃x y : R⦄, r x y → f x = f y) (x : R)
Goal: (RingQuot.lift ⟨f, w⟩) ((RingQuot.mkRingHom r) x) = f x
-- RingQuot.lift_unique
theorem lift_unique (f : R →+* T) {r : R → R → Prop} (w : ∀ ⦃x y⦄, r x y → f x = f y)
    (g : RingQuot r →+* T) (h : g.comp (mkRingHom r) = f) : g = lift ⟨f, w⟩ 
Arguments: {R : Type uR} [Semiring R] {T : Type uT} [Semiring T] (f : R →+* T) {r : R → R → Prop} (w : ∀ ⦃x y : R⦄, r x y → f x = f y) (g : RingQuot r →+* T) (h : g.comp (RingQuot.mkRingHom r) = f)
Goal: g = RingQuot.lift ⟨f, w⟩
-- RingQuot.eq_lift_comp_mkRingHom
theorem eq_lift_comp_mkRingHom {r : R → R → Prop} (f : RingQuot r →+* T) :
    f = lift ⟨f.comp (mkRingHom r), fun x y h ↦ congr_arg f (mkRingHom_rel h)⟩ 
Arguments: {R : Type uR} [Semiring R] {T : Type uT} [Semiring T] {r : R → R → Prop} (f : RingQuot r →+* T)
Goal: f = RingQuot.lift ⟨f.comp (RingQuot.mkRingHom r), ⋯⟩
-- RingQuot.ringQuotToIdealQuotient_apply
@[simp]
theorem ringQuotToIdealQuotient_apply (r : B → B → Prop) (x : B) :
    ringQuotToIdealQuotient r (mkRingHom r x) = Ideal.Quotient.mk (Ideal.ofRel r) x 
Arguments: {B : Type uR} [CommRing B] (r : B → B → Prop) (x : B)
Goal: (RingQuot.ringQuotToIdealQuotient r) ((RingQuot.mkRingHom r) x) = (Ideal.Quotient.mk (Ideal.ofRel r)) x
-- RingQuot.idealQuotientToRingQuot_apply
@[simp]
theorem idealQuotientToRingQuot_apply (r : B → B → Prop) (x : B) :
    idealQuotientToRingQuot r (Ideal.Quotient.mk _ x) = mkRingHom r x 
Arguments: {B : Type uR} [CommRing B] (r : B → B → Prop) (x : B)
Goal: (RingQuot.idealQuotientToRingQuot r) ((Ideal.Quotient.mk (Ideal.ofRel r)) x) = (RingQuot.mkRingHom r) x
-- RingQuot.mkAlgHom_def
irreducible_def mkAlgHom (s : A → A → Prop) : A →ₐ[S] RingQuot s 
Arguments: (S : Type u_1) [CommSemiring S] {A : Type u_2} [Semiring A] [Algebra S A] (s : A → A → Prop)
Goal: RingQuot.mkAlgHom S s =
  let __src := RingQuot.mkRingHom s;
  { toRingHom := __src, commutes' := ⋯ }
-- RingQuot.mkAlgHom_coe
@[simp]
theorem mkAlgHom_coe (s : A → A → Prop) : (mkAlgHom S s : A →+* RingQuot s) = mkRingHom s 
Arguments: (S : Type uS) [CommSemiring S] {A : Type uA} [Semiring A] [Algebra S A] (s : A → A → Prop)
Goal: ↑(RingQuot.mkAlgHom S s) = RingQuot.mkRingHom s
-- RingQuot.mkAlgHom_rel
theorem mkAlgHom_rel {s : A → A → Prop} {x y : A} (w : s x y) :
    mkAlgHom S s x = mkAlgHom S s y 
Arguments: (S : Type uS) [CommSemiring S] {A : Type uA} [Semiring A] [Algebra S A] {s : A → A → Prop} {x y : A} (w : s x y)
Goal: (RingQuot.mkAlgHom S s) x = (RingQuot.mkAlgHom S s) y
-- RingQuot.mkAlgHom_surjective
theorem mkAlgHom_surjective (s : A → A → Prop) : Function.Surjective (mkAlgHom S s) 
Arguments: (S : Type uS) [CommSemiring S] {A : Type uA} [Semiring A] [Algebra S A] (s : A → A → Prop)
Goal: Function.Surjective ⇑(RingQuot.mkAlgHom S s)
-- RingQuot.ringQuot_ext'
@[ext 1100]
theorem ringQuot_ext' {s : A → A → Prop} (f g : RingQuot s →ₐ[S] B)
    (w : f.comp (mkAlgHom S s) = g.comp (mkAlgHom S s)) : f = g 
Arguments: (S : Type uS) [CommSemiring S] {A : Type uA} [Semiring A] [Algebra S A] {B : Type u₄} [Semiring B] [Algebra S B] {s : A → A → Prop} (f g : RingQuot s →ₐ[S] B) (w : f.comp (RingQuot.mkAlgHom S s) = g.comp (RingQuot.mkAlgHom S s))
Goal: f = g
-- RingQuot.preLiftAlgHom_def
irreducible_def preLiftAlgHom {s : A → A → Prop} {f : A →ₐ[S] B}
  (h : ∀ ⦃x y⦄, s x y → f x = f y) : RingQuot s →ₐ[S] B 
Arguments: (S : Type u_1) [CommSemiring S] {A : Type u_2} [Semiring A] [Algebra S A] {B : Type u_3} [Semiring B] [Algebra S B] {s : A → A → Prop} {f : A →ₐ[S] B} (h : ∀ ⦃x y : A⦄, s x y → f x = f y)
Goal: RingQuot.preLiftAlgHom S h =
  { toFun := fun x => Quot.lift ⇑f ⋯ x.toQuot, map_one' := ⋯, map_mul' := ⋯, map_zero' := ⋯, map_add' := ⋯,
    commutes' := ⋯ }
-- RingQuot.liftAlgHom_def
irreducible_def liftAlgHom {s : A → A → Prop} :
  { f : A →ₐ[S] B // ∀ ⦃x y⦄, s x y → f x = f y } ≃ (RingQuot s →ₐ[S] B) 
Arguments: (S : Type u_1) [CommSemiring S] {A : Type u_2} [Semiring A] [Algebra S A] {B : Type u_3} [Semiring B] [Algebra S B] {s : A → A → Prop}
Goal: RingQuot.liftAlgHom S =
  { toFun := fun f' => RingQuot.preLiftAlgHom S ⋯, invFun := fun F => ⟨F.comp (RingQuot.mkAlgHom S s), ⋯⟩,
    left_inv := ⋯, right_inv := ⋯ }
-- RingQuot.liftAlgHom_mkAlgHom_apply
@[simp]
theorem liftAlgHom_mkAlgHom_apply (f : A →ₐ[S] B) {s : A → A → Prop}
    (w : ∀ ⦃x y⦄, s x y → f x = f y) (x) : (liftAlgHom S ⟨f, w⟩) ((mkAlgHom S s) x) = f x 
Arguments: (S : Type uS) [CommSemiring S] {A : Type uA} [Semiring A] [Algebra S A] {B : Type u₄} [Semiring B] [Algebra S B] (f : A →ₐ[S] B) {s : A → A → Prop} (w : ∀ ⦃x y : A⦄, s x y → f x = f y) (x : A)
Goal: ((RingQuot.liftAlgHom S) ⟨f, w⟩) ((RingQuot.mkAlgHom S s) x) = f x
-- RingQuot.liftAlgHom_unique
theorem liftAlgHom_unique (f : A →ₐ[S] B) {s : A → A → Prop} (w : ∀ ⦃x y⦄, s x y → f x = f y)
    (g : RingQuot s →ₐ[S] B) (h : g.comp (mkAlgHom S s) = f) : g = liftAlgHom S ⟨f, w⟩ 
Arguments: (S : Type uS) [CommSemiring S] {A : Type uA} [Semiring A] [Algebra S A] {B : Type u₄} [Semiring B] [Algebra S B] (f : A →ₐ[S] B) {s : A → A → Prop} (w : ∀ ⦃x y : A⦄, s x y → f x = f y) (g : RingQuot s →ₐ[S] B) (h : g.comp (RingQuot.mkAlgHom S s) = f)
Goal: g = (RingQuot.liftAlgHom S) ⟨f, w⟩
-- RingQuot.eq_liftAlgHom_comp_mkAlgHom
theorem eq_liftAlgHom_comp_mkAlgHom {s : A → A → Prop} (f : RingQuot s →ₐ[S] B) :
    f = liftAlgHom S ⟨f.comp (mkAlgHom S s), fun x y h ↦ congr_arg f (mkAlgHom_rel S h)⟩ 
Arguments: (S : Type uS) [CommSemiring S] {A : Type uA} [Semiring A] [Algebra S A] {B : Type u₄} [Semiring B] [Algebra S B] {s : A → A → Prop} (f : RingQuot s →ₐ[S] B)
Goal: f = (RingQuot.liftAlgHom S) ⟨f.comp (RingQuot.mkAlgHom S s), ⋯⟩
-- Finset.sum_Ico_by_parts
theorem sum_Ico_by_parts (hmn : m < n) :
    ∑ i ∈ Ico m n, f i • g i =
      f (n - 1) • G n - f m • G m - ∑ i ∈ Ico m (n - 1), (f (i + 1) - f i) • G (i + 1) 
Arguments: {R : Type u_1} {M : Type u_2} [Ring R] [AddCommGroup M] [Module R M] (f : ℕ → R) (g : ℕ → M) {m n : ℕ} (hmn : m < n)
Goal: ∑ i ∈ Finset.Ico m n, f i • g i =
  f (n - 1) • ∑ i ∈ Finset.range n, g i - f m • ∑ i ∈ Finset.range m, g i -
    ∑ i ∈ Finset.Ico m (n - 1), (f (i + 1) - f i) • ∑ i ∈ Finset.range (i + 1), g i
-- Finset.sum_range_by_parts
theorem sum_range_by_parts :
    ∑ i ∈ range n, f i • g i =
      f (n - 1) • G n - ∑ i ∈ range (n - 1), (f (i + 1) - f i) • G (i + 1) 
Arguments: {R : Type u_1} {M : Type u_2} [Ring R] [AddCommGroup M] [Module R M] (f : ℕ → R) (g : ℕ → M) (n : ℕ)
Goal: ∑ i ∈ Finset.range n, f i • g i =
  f (n - 1) • ∑ i ∈ Finset.range n, g i -
    ∑ i ∈ Finset.range (n - 1), (f (i + 1) - f i) • ∑ i ∈ Finset.range (i + 1), g i
-- IsLocalization.surj_of_gcd_domain
theorem IsLocalization.surj_of_gcd_domain [GCDMonoid R] (M : Submonoid R) [IsLocalization M A]
    (z : A) : ∃ a b : R, IsUnit (gcd a b) ∧ z * algebraMap R A b = algebraMap R A a 
Arguments: {R : Type u_1} {A : Type u_2} [CommRing R] [IsDomain R] [CommRing A] [Algebra R A] [GCDMonoid R] (M : Submonoid R) [IsLocalization M A] (z : A)
Goal: ∃ a b, IsUnit (gcd a b) ∧ z * (algebraMap R A) b = (algebraMap R A) a
-- Finset.lcm_def
theorem lcm_def : s.lcm f = (s.1.map f).lcm 
Arguments: {α : Type u_2} {β : Type u_3} [CancelCommMonoidWithZero α] [NormalizedGCDMonoid α] {s : Finset β} {f : β → α}
Goal: s.lcm f = (Multiset.map f s.val).lcm
-- Finset.lcm_empty
@[simp]
theorem lcm_empty : (∅ : Finset β).lcm f = 1 
Arguments: {α : Type u_2} {β : Type u_3} [CancelCommMonoidWithZero α] [NormalizedGCDMonoid α] {f : β → α}
Goal: ∅.lcm f = 1
-- Finset.lcm_dvd_iff
@[simp]
theorem lcm_dvd_iff {a : α} : s.lcm f ∣ a ↔ ∀ b ∈ s, f b ∣ a 
Arguments: {α : Type u_2} {β : Type u_3} [CancelCommMonoidWithZero α] [NormalizedGCDMonoid α] {s : Finset β} {f : β → α} {a : α}
Goal: s.lcm f ∣ a ↔ ∀ b ∈ s, f b ∣ a
-- Finset.lcm_dvd
theorem lcm_dvd {a : α} : (∀ b ∈ s, f b ∣ a) → s.lcm f ∣ a 
Arguments: {α : Type u_2} {β : Type u_3} [CancelCommMonoidWithZero α] [NormalizedGCDMonoid α] {s : Finset β} {f : β → α} {a : α}
Goal: (∀ b ∈ s, f b ∣ a) → s.lcm f ∣ a
-- Finset.dvd_lcm
theorem dvd_lcm {b : β} (hb : b ∈ s) : f b ∣ s.lcm f 
Arguments: {α : Type u_2} {β : Type u_3} [CancelCommMonoidWithZero α] [NormalizedGCDMonoid α] {s : Finset β} {f : β → α} {b : β} (hb : b ∈ s)
Goal: f b ∣ s.lcm f
-- Finset.lcm_insert
@[simp]
theorem lcm_insert [DecidableEq β] {b : β} :
    (insert b s : Finset β).lcm f = GCDMonoid.lcm (f b) (s.lcm f) 
Arguments: {α : Type u_2} {β : Type u_3} [CancelCommMonoidWithZero α] [NormalizedGCDMonoid α] {s : Finset β} {f : β → α} [DecidableEq β] {b : β}
Goal: (insert b s).lcm f = lcm (f b) (s.lcm f)
-- Finset.lcm_singleton
@[simp]
theorem lcm_singleton {b : β} : ({b} : Finset β).lcm f = normalize (f b) 
Arguments: {α : Type u_2} {β : Type u_3} [CancelCommMonoidWithZero α] [NormalizedGCDMonoid α] {f : β → α} {b : β}
Goal: {b}.lcm f = normalize (f b)
-- Finset.normalize_lcm
@[simp 1100]
theorem normalize_lcm : normalize (s.lcm f) = s.lcm f 
Arguments: {α : Type u_2} {β : Type u_3} [CancelCommMonoidWithZero α] [NormalizedGCDMonoid α] {s : Finset β} {f : β → α}
Goal: normalize (s.lcm f) = s.lcm f
-- Finset.lcm_union
theorem lcm_union [DecidableEq β] : (s₁ ∪ s₂).lcm f = GCDMonoid.lcm (s₁.lcm f) (s₂.lcm f) 
Arguments: {α : Type u_2} {β : Type u_3} [CancelCommMonoidWithZero α] [NormalizedGCDMonoid α] {s₁ s₂ : Finset β} {f : β → α} [DecidableEq β]
Goal: (s₁ ∪ s₂).lcm f = lcm (s₁.lcm f) (s₂.lcm f)
-- Finset.lcm_congr
theorem lcm_congr {f g : β → α} (hs : s₁ = s₂) (hfg : ∀ a ∈ s₂, f a = g a) :
    s₁.lcm f = s₂.lcm g 
Arguments: {α : Type u_2} {β : Type u_3} [CancelCommMonoidWithZero α] [NormalizedGCDMonoid α] {s₁ s₂ : Finset β} {f g : β → α} (hs : s₁ = s₂) (hfg : ∀ a ∈ s₂, f a = g a)
Goal: s₁.lcm f = s₂.lcm g
-- Finset.lcm_mono_fun
theorem lcm_mono_fun {g : β → α} (h : ∀ b ∈ s, f b ∣ g b) : s.lcm f ∣ s.lcm g 
Arguments: {α : Type u_2} {β : Type u_3} [CancelCommMonoidWithZero α] [NormalizedGCDMonoid α] {s : Finset β} {f g : β → α} (h : ∀ b ∈ s, f b ∣ g b)
Goal: s.lcm f ∣ s.lcm g
-- Finset.lcm_mono
theorem lcm_mono (h : s₁ ⊆ s₂) : s₁.lcm f ∣ s₂.lcm f 
Arguments: {α : Type u_2} {β : Type u_3} [CancelCommMonoidWithZero α] [NormalizedGCDMonoid α] {s₁ s₂ : Finset β} {f : β → α} (h : s₁ ⊆ s₂)
Goal: s₁.lcm f ∣ s₂.lcm f
-- Finset.lcm_image
theorem lcm_image [DecidableEq β] {g : γ → β} (s : Finset γ) :
    (s.image g).lcm f = s.lcm (f ∘ g) 
Arguments: {α : Type u_2} {β : Type u_3} {γ : Type u_4} [CancelCommMonoidWithZero α] [NormalizedGCDMonoid α] {f : β → α} [DecidableEq β] {g : γ → β} (s : Finset γ)
Goal: (Finset.image g s).lcm f = s.lcm (f ∘ g)
-- Finset.lcm_eq_lcm_image
theorem lcm_eq_lcm_image [DecidableEq α] : s.lcm f = (s.image f).lcm id 
Arguments: {α : Type u_2} {β : Type u_3} [CancelCommMonoidWithZero α] [NormalizedGCDMonoid α] {s : Finset β} {f : β → α} [DecidableEq α]
Goal: s.lcm f = (Finset.image f s).lcm id
-- Finset.lcm_eq_zero_iff
theorem lcm_eq_zero_iff [Nontrivial α] : s.lcm f = 0 ↔ 0 ∈ f '' s 
Arguments: {α : Type u_2} {β : Type u_3} [CancelCommMonoidWithZero α] [NormalizedGCDMonoid α] {s : Finset β} {f : β → α} [Nontrivial α]
Goal: s.lcm f = 0 ↔ 0 ∈ f '' ↑s
-- Finset.gcd_def
theorem gcd_def : s.gcd f = (s.1.map f).gcd 
Arguments: {α : Type u_2} {β : Type u_3} [CancelCommMonoidWithZero α] [NormalizedGCDMonoid α] {s : Finset β} {f : β → α}
Goal: s.gcd f = (Multiset.map f s.val).gcd
-- Finset.gcd_empty
@[simp]
theorem gcd_empty : (∅ : Finset β).gcd f = 0 
Arguments: {α : Type u_2} {β : Type u_3} [CancelCommMonoidWithZero α] [NormalizedGCDMonoid α] {f : β → α}
Goal: ∅.gcd f = 0
-- Finset.dvd_gcd_iff
theorem dvd_gcd_iff {a : α} : a ∣ s.gcd f ↔ ∀ b ∈ s, a ∣ f b 
Arguments: {α : Type u_2} {β : Type u_3} [CancelCommMonoidWithZero α] [NormalizedGCDMonoid α] {s : Finset β} {f : β → α} {a : α}
Goal: a ∣ s.gcd f ↔ ∀ b ∈ s, a ∣ f b
-- Finset.gcd_dvd
theorem gcd_dvd {b : β} (hb : b ∈ s) : s.gcd f ∣ f b 
Arguments: {α : Type u_2} {β : Type u_3} [CancelCommMonoidWithZero α] [NormalizedGCDMonoid α] {s : Finset β} {f : β → α} {b : β} (hb : b ∈ s)
Goal: s.gcd f ∣ f b
-- Finset.dvd_gcd
theorem dvd_gcd {a : α} : (∀ b ∈ s, a ∣ f b) → a ∣ s.gcd f 
Arguments: {α : Type u_2} {β : Type u_3} [CancelCommMonoidWithZero α] [NormalizedGCDMonoid α] {s : Finset β} {f : β → α} {a : α}
Goal: (∀ b ∈ s, a ∣ f b) → a ∣ s.gcd f
-- Finset.gcd_insert
@[simp]
theorem gcd_insert [DecidableEq β] {b : β} :
    (insert b s : Finset β).gcd f = GCDMonoid.gcd (f b) (s.gcd f) 
Arguments: {α : Type u_2} {β : Type u_3} [CancelCommMonoidWithZero α] [NormalizedGCDMonoid α] {s : Finset β} {f : β → α} [DecidableEq β] {b : β}
Goal: (insert b s).gcd f = gcd (f b) (s.gcd f)
-- Finset.gcd_singleton
@[simp]
theorem gcd_singleton {b : β} : ({b} : Finset β).gcd f = normalize (f b) 
Arguments: {α : Type u_2} {β : Type u_3} [CancelCommMonoidWithZero α] [NormalizedGCDMonoid α] {f : β → α} {b : β}
Goal: {b}.gcd f = normalize (f b)
-- Finset.normalize_gcd
@[simp 1100]
theorem normalize_gcd : normalize (s.gcd f) = s.gcd f 
Arguments: {α : Type u_2} {β : Type u_3} [CancelCommMonoidWithZero α] [NormalizedGCDMonoid α] {s : Finset β} {f : β → α}
Goal: normalize (s.gcd f) = s.gcd f
-- Finset.gcd_union
theorem gcd_union [DecidableEq β] : (s₁ ∪ s₂).gcd f = GCDMonoid.gcd (s₁.gcd f) (s₂.gcd f) 
Arguments: {α : Type u_2} {β : Type u_3} [CancelCommMonoidWithZero α] [NormalizedGCDMonoid α] {s₁ s₂ : Finset β} {f : β → α} [DecidableEq β]
Goal: (s₁ ∪ s₂).gcd f = gcd (s₁.gcd f) (s₂.gcd f)
-- Finset.gcd_congr
theorem gcd_congr {f g : β → α} (hs : s₁ = s₂) (hfg : ∀ a ∈ s₂, f a = g a) :
    s₁.gcd f = s₂.gcd g 
Arguments: {α : Type u_2} {β : Type u_3} [CancelCommMonoidWithZero α] [NormalizedGCDMonoid α] {s₁ s₂ : Finset β} {f g : β → α} (hs : s₁ = s₂) (hfg : ∀ a ∈ s₂, f a = g a)
Goal: s₁.gcd f = s₂.gcd g
-- Finset.gcd_mono_fun
theorem gcd_mono_fun {g : β → α} (h : ∀ b ∈ s, f b ∣ g b) : s.gcd f ∣ s.gcd g 
Arguments: {α : Type u_2} {β : Type u_3} [CancelCommMonoidWithZero α] [NormalizedGCDMonoid α] {s : Finset β} {f g : β → α} (h : ∀ b ∈ s, f b ∣ g b)
Goal: s.gcd f ∣ s.gcd g
-- Finset.gcd_mono
theorem gcd_mono (h : s₁ ⊆ s₂) : s₂.gcd f ∣ s₁.gcd f 
Arguments: {α : Type u_2} {β : Type u_3} [CancelCommMonoidWithZero α] [NormalizedGCDMonoid α] {s₁ s₂ : Finset β} {f : β → α} (h : s₁ ⊆ s₂)
Goal: s₂.gcd f ∣ s₁.gcd f