I think it's all done!

fetch_books_and_formal.py

@@ -104,7 +104,7 @@ def lean(creds):
         {
             "author": "leanprover-community",
             "repo": "mathlib",
-            "sha": "e2ba6de0eb20eed7f16a19c3abf6904fad937fa4",
+            "sha": "63138639ca195344ae96aa77f3a02b90a3ac5c68",
             "repo_dir": "src",
             "save_path": os.path.join(save_dir, "mathlib"),
         },
@@ -118,7 +118,7 @@ def lean(creds):
         {
             "author": "leanprover-community",
             "repo": "sphere-eversion",
-            "sha": "3a2e501bbb2512870c98c3e6831a6067b3c826b8",
+            "sha": "cb378966c3c02d9e4ee83040d20c51782fa351ae",
             "repo_dir": "src",
             "save_path": os.path.join(save_dir, "sphere-eversion"),
         },
@@ -506,20 +506,19 @@ def napkin(creds):
 
 def main():
     creds = ("zhangir-azerbayev", os.environ["GITHUB_TOKEN"])
-    #napkin(creds)
-    #cring(creds)
-    # naturalproofs_proofwiki(testing=False)
-    #stacks(creds)
-    #mizar(creds)
-    #afp(testing=False)
+    napkin(creds)
+    cring(creds)
+    stacks(creds)
+    mizar(creds)
+    afp(testing=False)
     setmm(creds)
-    #trench()
-    #hott(creds)
-    #stein(creds)
-    #coq(creds)
-    #lean(creds)
-    #hol()
-    #cam()
+    trench()
+    hott(creds)
+    stein(creds)
+    coq(creds)
+    lean(creds)
+    hol()
+    cam()
 
 
 if __name__ == "__main__":

formal/lean/mathlib/algebra/algebra/basic.lean

@@ -112,7 +112,7 @@ An associative unital `R`-algebra is a semiring `A` equipped with a map into its
 
 See the implementation notes in this file for discussion of the details of this definition.
 -/
-@[nolint has_inhabited_instance]
+@[nolint has_nonempty_instance]
 class algebra (R : Type u) (A : Type v) [comm_semiring R] [semiring A]
   extends has_smul R A, R →+* A :=
 (commutes' : ∀ r x, to_fun r * x = x * to_fun r)
@@ -261,6 +261,11 @@ search (and was here first). -/
   (r • x) * y = r • (x * y) :=
 smul_mul_assoc r x y
 
+@[simp]
+lemma _root_.smul_algebra_map {α : Type*} [monoid α] [mul_distrib_mul_action α A]
+  [smul_comm_class α R A] (a : α) (r : R) : a • algebra_map R A r = algebra_map R A r :=
+by rw [algebra_map_eq_smul_one, smul_comm a r (1 : A), smul_one]
+
 section
 variables {r : R} {a : A}
 
@@ -474,7 +479,7 @@ end module
 
 set_option old_structure_cmd true
 /-- Defining the homomorphism in the category R-Alg. -/
-@[nolint has_inhabited_instance]
+@[nolint has_nonempty_instance]
 structure alg_hom (R : Type u) (A : Type v) (B : Type w)
   [comm_semiring R] [semiring A] [semiring B] [algebra R A] [algebra R B] extends ring_hom A B :=
 (commutes' : ∀ r : R, to_fun (algebra_map R A r) = algebra_map R B r)
@@ -695,6 +700,17 @@ lemma map_list_prod (s : list A) :
   φ s.prod = (s.map φ).prod :=
 φ.to_ring_hom.map_list_prod s
 
+@[simps mul one {attrs := []}] instance End : monoid (A →ₐ[R] A) :=
+{ mul := comp,
+  mul_assoc := λ ϕ ψ χ, rfl,
+  one := alg_hom.id R A,
+  one_mul := λ ϕ, ext $ λ x, rfl,
+  mul_one := λ ϕ, ext $ λ x, rfl }
+
+@[simp] lemma one_apply (x : A) : (1 : A →ₐ[R] A) x = x := rfl
+
+@[simp] lemma mul_apply (φ ψ : A →ₐ[R] A) (x : A) : (φ * ψ) x = φ (ψ x) := rfl
+
 section prod
 
 /-- First projection as `alg_hom`. -/
@@ -797,6 +813,13 @@ instance to_alg_hom_class (F R A B : Type*)
   map_one := map_one,
   .. h }
 
+@[priority 100]
+instance to_linear_equiv_class (F R A B : Type*)
+  [comm_semiring R] [semiring A] [semiring B] [algebra R A] [algebra R B]
+  [h : alg_equiv_class F R A B] : linear_equiv_class F R A B :=
+{ map_smulₛₗ := λ f, map_smulₛₗ f,
+  ..h }
+
 end alg_equiv_class
 
 namespace alg_equiv
@@ -1225,7 +1248,9 @@ This is a stronger version of `mul_semiring_action.to_ring_hom` and
 `distrib_mul_action.to_linear_map`. -/
 @[simps]
 def to_alg_hom (m : M) : A →ₐ[R] A :=
-alg_hom.mk' (mul_semiring_action.to_ring_hom _ _ m) (smul_comm _)
+{ to_fun := λ a, m • a,
+  commutes' := smul_algebra_map _,
+  ..mul_semiring_action.to_ring_hom _ _ m }
 
 theorem to_alg_hom_injective [has_faithful_smul M A] :
   function.injective (mul_semiring_action.to_alg_hom R A : M → A →ₐ[R] A) :=

formal/lean/mathlib/algebra/algebra/bilinear.lean

@@ -5,6 +5,7 @@ Authors: Kenny Lau, Yury Kudryashov
 -/
 import algebra.algebra.basic
 import algebra.hom.iterate
+import algebra.hom.non_unital_alg
 import linear_algebra.tensor_product
 
 /-!
@@ -15,143 +16,168 @@ in order to avoid importing `linear_algebra.bilinear_map` and
 `linear_algebra.tensor_product` unnecessarily.
 -/
 
-universes u v w
-
-namespace algebra
-
 open_locale tensor_product
 open module
 
-section
+namespace linear_map
 
-variables (R A : Type*) [comm_semiring R] [semiring A] [algebra R A]
+section non_unital_non_assoc
 
-/-- The multiplication in an algebra is a bilinear map.
+variables (R A : Type*) [comm_semiring R] [non_unital_non_assoc_semiring A]
+  [module R A] [smul_comm_class R A A] [is_scalar_tower R A A]
+
+/-- The multiplication in a non-unital non-associative algebra is a bilinear map.
 
 A weaker version of this for semirings exists as `add_monoid_hom.mul`. -/
-def lmul : A →ₐ[R] (End R A) :=
-{ map_one' := by { ext a, exact one_mul a },
-  map_mul' := by { intros a b, ext c, exact mul_assoc a b c },
-  map_zero' := by { ext a, exact zero_mul a },
-  commutes' := by { intro r, ext a, dsimp, rw [smul_def] },
-  .. (show A →ₗ[R] A →ₗ[R] A, from linear_map.mk₂ R (*)
-  (λ x y z, add_mul x y z)
-  (λ c x y, by rw [smul_def, smul_def, mul_assoc _ x y])
-  (λ x y z, mul_add x y z)
-  (λ c x y, by rw [smul_def, smul_def, left_comm])) }
+def mul : A →ₗ[R] A →ₗ[R] A := linear_map.mk₂ R (*) add_mul smul_mul_assoc mul_add mul_smul_comm
 
-variables {R A}
+/-- The multiplication map on a non-unital algebra, as an `R`-linear map from `A ⊗[R] A` to `A`. -/
+def mul' : A ⊗[R] A →ₗ[R] A :=
+tensor_product.lift (mul R A)
 
-@[simp] lemma lmul_apply (p q : A) : lmul R A p q = p * q := rfl
+variables {A}
 
+/-- The multiplication on the left in a non-unital algebra is a linear map. -/
+def mul_left (a : A) : A →ₗ[R] A := mul R A a
 
-variables (R)
+/-- The multiplication on the right in an algebra is a linear map. -/
+def mul_right (a : A) : A →ₗ[R] A := (mul R A).flip a
 
-/-- The multiplication on the left in an algebra is a linear map. -/
-def lmul_left (r : A) : A →ₗ[R] A :=
-lmul R A r
+/-- Simultaneous multiplication on the left and right is a linear map. -/
+def mul_left_right (ab : A × A) : A →ₗ[R] A := (mul_right R ab.snd).comp (mul_left R ab.fst)
 
-@[simp] lemma lmul_left_to_add_monoid_hom (r : A) :
-  (lmul_left R r : A →+ A) = add_monoid_hom.mul_left r :=
-fun_like.coe_injective rfl
+@[simp] lemma mul_left_to_add_monoid_hom (a : A) :
+  (mul_left R a : A →+ A) = add_monoid_hom.mul_left a := rfl
 
-/-- The multiplication on the right in an algebra is a linear map. -/
-def lmul_right (r : A) : A →ₗ[R] A :=
-(lmul R A).to_linear_map.flip r
+@[simp] lemma mul_right_to_add_monoid_hom (a : A) :
+  (mul_right R a : A →+ A) = add_monoid_hom.mul_right a := rfl
 
-@[simp] lemma lmul_right_to_add_monoid_hom (r : A) :
-  (lmul_right R r : A →+ A) = add_monoid_hom.mul_right r :=
-fun_like.coe_injective rfl
+variables {R}
 
-/-- Simultaneous multiplication on the left and right is a linear map. -/
-def lmul_left_right (vw: A × A) : A →ₗ[R] A :=
-(lmul_right R vw.2).comp (lmul_left R vw.1)
+@[simp] lemma mul_apply' (a b : A) : mul R A a b = a * b := rfl
+@[simp] lemma mul_left_apply (a b : A) : mul_left R a b = a * b := rfl
+@[simp] lemma mul_right_apply (a b : A) : mul_right R a b = b * a := rfl
+@[simp] lemma mul_left_right_apply (a b x : A) : mul_left_right R (a, b) x = a * x * b := rfl
 
-lemma commute_lmul_left_right (a b : A) :
-  commute (lmul_left R a) (lmul_right R b) :=
-by { ext c, exact (mul_assoc a c b).symm, }
+@[simp] lemma mul'_apply {a b : A} : mul' R A (a ⊗ₜ b) = a * b :=
+by simp only [linear_map.mul', tensor_product.lift.tmul, mul_apply']
+
+@[simp] lemma mul_left_zero_eq_zero :
+  mul_left R (0 : A) = 0 :=
+(mul R A).map_zero
+
+@[simp] lemma mul_right_zero_eq_zero :
+  mul_right R (0 : A) = 0 :=
+(mul R A).flip.map_zero
+
+end non_unital_non_assoc
+
+section non_unital
 
-/-- The multiplication map on an algebra, as an `R`-linear map from `A ⊗[R] A` to `A`. -/
-def lmul' : A ⊗[R] A →ₗ[R] A :=
-tensor_product.lift (lmul R A).to_linear_map
+variables (R A : Type*) [comm_semiring R] [non_unital_semiring A]
+  [module R A] [smul_comm_class R A A] [is_scalar_tower R A A]
+
+/-- The multiplication in a non-unital algebra is a bilinear map.
+
+A weaker version of this for non-unital non-associative algebras exists as `linear_map.mul`. -/
+def _root_.non_unital_alg_hom.lmul : A →ₙₐ[R] (End R A) :=
+{ map_mul' := by { intros a b, ext c, exact mul_assoc a b c },
+  map_zero' := by { ext a, exact zero_mul a },
+  .. (mul R A) }
 
 variables {R A}
 
-@[simp] lemma lmul'_apply {x y : A} : lmul' R (x ⊗ₜ y) = x * y :=
-by simp only [algebra.lmul', tensor_product.lift.tmul, alg_hom.to_linear_map_apply, lmul_apply]
+@[simp]
+lemma _root_.non_unital_alg_hom.coe_lmul_eq_mul : ⇑(non_unital_alg_hom.lmul R A) = mul R A := rfl
+
+lemma commute_mul_left_right (a b : A) :
+  commute (mul_left R a) (mul_right R b) :=
+by { ext c, exact (mul_assoc a c b).symm, }
+
+@[simp] lemma mul_left_mul (a b : A) :
+  mul_left R (a * b) = (mul_left R a).comp (mul_left R b) :=
+by { ext, simp only [mul_left_apply, comp_apply, mul_assoc] }
 
-@[simp] lemma lmul_left_apply (p q : A) : lmul_left R p q = p * q := rfl
-@[simp] lemma lmul_right_apply (p q : A) : lmul_right R p q = q * p := rfl
-@[simp] lemma lmul_left_right_apply (vw : A × A) (p : A) :
-  lmul_left_right R vw p = vw.1 * p * vw.2 := rfl
+@[simp] lemma mul_right_mul (a b : A) :
+  mul_right R (a * b) = (mul_right R b).comp (mul_right R a) :=
+by { ext, simp only [mul_right_apply, comp_apply, mul_assoc] }
 
-@[simp] lemma lmul_left_one : lmul_left R (1:A) = linear_map.id :=
-by { ext, simp only [linear_map.id_coe, one_mul, id.def, lmul_left_apply] }
+end non_unital
 
-@[simp] lemma lmul_left_mul (a b : A) :
-  lmul_left R (a * b) = (lmul_left R a).comp (lmul_left R b) :=
-by { ext, simp only [lmul_left_apply, linear_map.comp_apply, mul_assoc] }
+section semiring
+
+variables (R A : Type*) [comm_semiring R] [semiring A] [algebra R A]
 
-@[simp] lemma lmul_right_one : lmul_right R (1:A) = linear_map.id :=
-by { ext, simp only [linear_map.id_coe, mul_one, id.def, lmul_right_apply] }
+/-- The multiplication in an algebra is an algebra homomorphism into the endomorphisms on
+the algebra.
 
-@[simp] lemma lmul_right_mul (a b : A) :
-  lmul_right R (a * b) = (lmul_right R b).comp (lmul_right R a) :=
-by { ext, simp only [lmul_right_apply, linear_map.comp_apply, mul_assoc] }
+A weaker version of this for non-unital algebras exists as `non_unital_alg_hom.mul`. -/
+def _root_.algebra.lmul : A →ₐ[R] (End R A) :=
+{ map_one' := by { ext a, exact one_mul a },
+  map_mul' := by { intros a b, ext c, exact mul_assoc a b c },
+  map_zero' := by { ext a, exact zero_mul a },
+  commutes' := by { intro r, ext a, exact (algebra.smul_def r a).symm, },
+  .. (linear_map.mul R A) }
 
-@[simp] lemma lmul_left_zero_eq_zero :
-  lmul_left R (0 : A) = 0 :=
-(lmul R A).map_zero
+variables {R A}
 
-@[simp] lemma lmul_right_zero_eq_zero :
-  lmul_right R (0 : A) = 0 :=
-(lmul R A).to_linear_map.flip.map_zero
+@[simp] lemma _root_.algebra.coe_lmul_eq_mul : ⇑(algebra.lmul R A) = mul R A := rfl
 
-@[simp] lemma lmul_left_eq_zero_iff (a : A) :
-  lmul_left R a = 0 ↔ a = 0 :=
+@[simp] lemma mul_left_eq_zero_iff (a : A) :
+  mul_left R a = 0 ↔ a = 0 :=
 begin
   split; intros h,
-  { rw [← mul_one a, ← lmul_left_apply a 1, h, linear_map.zero_apply], },
-  { rw h, exact lmul_left_zero_eq_zero, },
+  { rw [← mul_one a, ← mul_left_apply a 1, h, linear_map.zero_apply], },
+  { rw h, exact mul_left_zero_eq_zero, },
 end
 
-@[simp] lemma lmul_right_eq_zero_iff (a : A) :
-  lmul_right R a = 0 ↔ a = 0 :=
+@[simp] lemma mul_right_eq_zero_iff (a : A) :
+  mul_right R a = 0 ↔ a = 0 :=
 begin
   split; intros h,
-  { rw [← one_mul a, ← lmul_right_apply a 1, h, linear_map.zero_apply], },
-  { rw h, exact lmul_right_zero_eq_zero, },
+  { rw [← one_mul a, ← mul_right_apply a 1, h, linear_map.zero_apply], },
+  { rw h, exact mul_right_zero_eq_zero, },
 end
 
-@[simp] lemma pow_lmul_left (a : A) (n : ℕ) :
-  (lmul_left R a) ^ n = lmul_left R (a ^ n) :=
-((lmul R A).map_pow a n).symm
+@[simp] lemma mul_left_one : mul_left R (1:A) = linear_map.id :=
+by { ext, simp only [linear_map.id_coe, one_mul, id.def, mul_left_apply] }
 
-@[simp] lemma pow_lmul_right (a : A) (n : ℕ) :
-  (lmul_right R a) ^ n = lmul_right R (a ^ n) :=
-linear_map.coe_injective $ ((lmul_right R a).coe_pow n).symm ▸ (mul_right_iterate a n)
+@[simp] lemma mul_right_one : mul_right R (1:A) = linear_map.id :=
+by { ext, simp only [linear_map.id_coe, mul_one, id.def, mul_right_apply] }
 
+@[simp] lemma pow_mul_left (a : A) (n : ℕ) :
+  (mul_left R a) ^ n = mul_left R (a ^ n) :=
+by simpa only [mul_left, ←algebra.coe_lmul_eq_mul] using ((algebra.lmul R A).map_pow a n).symm
+
+@[simp] lemma pow_mul_right (a : A) (n : ℕ) :
+  (mul_right R a) ^ n = mul_right R (a ^ n) :=
+begin
+  simp only [mul_right, ←algebra.coe_lmul_eq_mul],
+  exact linear_map.coe_injective
+    (((mul_right R a).coe_pow n).symm ▸ (mul_right_iterate a n)),
 end
 
-section
+end semiring
+
+section ring
 
 variables {R A : Type*} [comm_semiring R] [ring A] [algebra R A]
 
-lemma lmul_left_injective [no_zero_divisors A] {x : A} (hx : x ≠ 0) :
-  function.injective (lmul_left R x) :=
+lemma mul_left_injective [no_zero_divisors A] {x : A} (hx : x ≠ 0) :
+  function.injective (mul_left R x) :=
 by { letI : is_domain A := { exists_pair_ne := ⟨x, 0, hx⟩, ..‹ring A›, ..‹no_zero_divisors A› },
      exact mul_right_injective₀ hx }
 
-lemma lmul_right_injective [no_zero_divisors A] {x : A} (hx : x ≠ 0) :
-  function.injective (lmul_right R x) :=
+lemma mul_right_injective [no_zero_divisors A] {x : A} (hx : x ≠ 0) :
+  function.injective (mul_right R x) :=
 by { letI : is_domain A := { exists_pair_ne := ⟨x, 0, hx⟩, ..‹ring A›, ..‹no_zero_divisors A› },
      exact mul_left_injective₀ hx }
 
-lemma lmul_injective [no_zero_divisors A] {x : A} (hx : x ≠ 0) :
-  function.injective (lmul R A x) :=
+lemma mul_injective [no_zero_divisors A] {x : A} (hx : x ≠ 0) :
+  function.injective (mul R A x) :=
 by { letI : is_domain A := { exists_pair_ne := ⟨x, 0, hx⟩, ..‹ring A›, ..‹no_zero_divisors A› },
      exact mul_right_injective₀ hx }
 
-end
+end ring
 
-end algebra
+end linear_map

formal/lean/mathlib/algebra/algebra/operations.lean

@@ -18,7 +18,7 @@ An interface for multiplication and division of sub-R-modules of an R-algebra A
 
 ## Main definitions
 
-Let `R` be a commutative ring (or semiring) and aet `A` be an `R`-algebra.
+Let `R` be a commutative ring (or semiring) and let `A` be an `R`-algebra.
 
 * `1 : submodule R A`       : the R-submodule R of the R-algebra A
 * `has_mul (submodule R A)` : multiplication of two sub-R-modules M and N of A is defined to be
@@ -28,6 +28,9 @@ Let `R` be a commutative ring (or semiring) and aet `A` be an `R`-algebra.
 
 It is proved that `submodule R A` is a semiring, and also an algebra over `set A`.
 
+Additionally, in the `pointwise` locale we promote `submodule.pointwise_distrib_mul_action` to a
+`mul_semiring_action` as `submodule.pointwise_mul_semiring_action`.
+
 ## Tags
 
 multiplication of submodules, division of submodules, submodule semiring
@@ -118,7 +121,7 @@ by rw [←map_equiv_eq_comap_symm, map_op_one]
 
 /-- Multiplication of sub-R-modules of an R-algebra A. The submodule `M * N` is the
 smallest R-submodule of `A` containing the elements `m * n` for `m ∈ M` and `n ∈ N`. -/
-instance : has_mul (submodule R A) := ⟨submodule.map₂ (algebra.lmul R A).to_linear_map⟩
+instance : has_mul (submodule R A) := ⟨submodule.map₂ $ linear_map.mul R A⟩
 
 theorem mul_mem_mul (hm : m ∈ M) (hn : n ∈ N) : m * n ∈ M * N := apply_mem_map₂ _ hm hn
 
@@ -128,7 +131,7 @@ lemma mul_to_add_submonoid (M N : submodule R A) :
   (M * N).to_add_submonoid = M.to_add_submonoid * N.to_add_submonoid :=
 begin
   dsimp [has_mul.mul],
-  simp_rw [←algebra.lmul_left_to_add_monoid_hom R, algebra.lmul_left, ←map_to_add_submonoid _ N,
+  simp_rw [←linear_map.mul_left_to_add_monoid_hom R, linear_map.mul_left, ←map_to_add_submonoid _ N,
     map₂],
   rw supr_to_add_submonoid,
   refl,
@@ -189,7 +192,7 @@ image2_subset_map₂ (algebra.lmul R A).to_linear_map M N
 protected lemma map_mul {A'} [semiring A'] [algebra R A'] (f : A →ₐ[R] A') :
   map f.to_linear_map (M * N) = map f.to_linear_map M * map f.to_linear_map N :=
 calc map f.to_linear_map (M * N)
-    = ⨆ (i : M), (N.map (lmul R A i)).map f.to_linear_map : map_supr _ _
+    = ⨆ (i : M), (N.map (linear_map.mul R A i)).map f.to_linear_map : map_supr _ _
 ... = map f.to_linear_map M * map f.to_linear_map N  :
   begin
     apply congr_arg Sup,
@@ -454,6 +457,23 @@ def span.ring_hom : set_semiring A →+* submodule R A :=
   map_add' := span_union,
   map_mul' := λ s t, by erw [span_mul_span, ← image_mul_prod] }
 
+section
+variables {α : Type*} [monoid α] [mul_semiring_action α A] [smul_comm_class α R A]
+
+/-- The action on a submodule corresponding to applying the action to every element.
+
+This is available as an instance in the `pointwise` locale.
+
+This is a stronger version of `submodule.pointwise_distrib_mul_action`. -/
+protected def pointwise_mul_semiring_action : mul_semiring_action α (submodule R A) :=
+{ smul_mul := λ r x y, submodule.map_mul x y $ mul_semiring_action.to_alg_hom R A r,
+  smul_one := λ r, submodule.map_one $ mul_semiring_action.to_alg_hom R A r,
+  ..submodule.pointwise_distrib_mul_action }
+
+localized "attribute [instance] submodule.pointwise_mul_semiring_action" in pointwise
+
+end
+
 end ring
 
 section comm_ring
@@ -512,7 +532,7 @@ lemma smul_le_smul {s t : set_semiring A} {M N : submodule R A} (h₁ : s.down
 mul_le_mul (span_mono h₁) h₂
 
 lemma smul_singleton (a : A) (M : submodule R A) :
-  ({a} : set A).up • M = M.map (lmul_left _ a) :=
+  ({a} : set A).up • M = M.map (linear_map.mul_left _ a) :=
 begin
   conv_lhs {rw ← span_eq M},
   change span _ _ * span _ _ = _,

formal/lean/mathlib/algebra/algebra/subalgebra/basic.lean

@@ -305,7 +305,7 @@ def to_submodule_equiv (S : subalgebra R A) : S.to_submodule ≃ₗ[R] S :=
 linear_equiv.of_eq _ _ rfl
 
 /-- Transport a subalgebra via an algebra homomorphism. -/
-def map (S : subalgebra R A) (f : A →ₐ[R] B) : subalgebra R B :=
+def map (f : A →ₐ[R] B) (S : subalgebra R A) : subalgebra R B :=
 { algebra_map_mem' := λ r, f.commutes r ▸ set.mem_image_of_mem _ (S.algebra_map_mem r),
   .. S.to_subsemiring.map (f : A →+* B) }
 
@@ -313,9 +313,9 @@ lemma map_mono {S₁ S₂ : subalgebra R A} {f : A →ₐ[R] B} :
   S₁ ≤ S₂ → S₁.map f ≤ S₂.map f :=
 set.image_subset f
 
-lemma map_injective {S₁ S₂ : subalgebra R A} (f : A →ₐ[R] B)
-  (hf : function.injective f) (ih : S₁.map f = S₂.map f) : S₁ = S₂ :=
-ext $ set.ext_iff.1 $ set.image_injective.2 hf $ set.ext $ set_like.ext_iff.mp ih
+lemma map_injective {f : A →ₐ[R] B} (hf : function.injective f) :
+  function.injective (map f) :=
+λ S₁ S₂ ih, ext $ set.ext_iff.1 $ set.image_injective.2 hf $ set.ext $ set_like.ext_iff.mp ih
 
 @[simp] lemma map_id (S : subalgebra R A) : S.map (alg_hom.id R A) = S :=
 set_like.coe_injective $ set.image_id _
@@ -325,7 +325,7 @@ lemma map_map (S : subalgebra R A) (g : B →ₐ[R] C) (f : A →ₐ[R] B) :
 set_like.coe_injective $ set.image_image _ _ _
 
 lemma mem_map {S : subalgebra R A} {f : A →ₐ[R] B} {y : B} :
-  y ∈ map S f ↔ ∃ x ∈ S, f x = y :=
+  y ∈ map f S ↔ ∃ x ∈ S, f x = y :=
 subsemiring.mem_map
 
 lemma map_to_submodule {S : subalgebra R A} {f : A →ₐ[R] B} :
@@ -341,16 +341,16 @@ set_like.coe_injective rfl
 rfl
 
 /-- Preimage of a subalgebra under an algebra homomorphism. -/
-def comap (S : subalgebra R B) (f : A →ₐ[R] B) : subalgebra R A :=
+def comap (f : A →ₐ[R] B) (S : subalgebra R B) : subalgebra R A :=
 { algebra_map_mem' := λ r, show f (algebra_map R A r) ∈ S,
     from (f.commutes r).symm ▸ S.algebra_map_mem r,
   .. S.to_subsemiring.comap (f : A →+* B) }
 
 theorem map_le {S : subalgebra R A} {f : A →ₐ[R] B} {U : subalgebra R B} :
-  map S f ≤ U ↔ S ≤ comap U f :=
+  map f S ≤ U ↔ S ≤ comap f U :=
 set.image_subset_iff
 
-lemma gc_map_comap (f : A →ₐ[R] B) : galois_connection (λ S, map S f) (λ S, comap S f) :=
+lemma gc_map_comap (f : A →ₐ[R] B) : galois_connection (map f) (comap f) :=
 λ S U, map_le
 
 @[simp] lemma mem_comap (S : subalgebra R B) (f : A →ₐ[R] B) (x : A) :
@@ -648,14 +648,14 @@ algebra.eq_top_iff
 @[simp] theorem range_id : (alg_hom.id R A).range = ⊤ :=
 set_like.coe_injective set.range_id
 
-@[simp] theorem map_top (f : A →ₐ[R] B) : subalgebra.map (⊤ : subalgebra R A) f = f.range :=
+@[simp] theorem map_top (f : A →ₐ[R] B) : (⊤ : subalgebra R A).map f = f.range :=
 set_like.coe_injective set.image_univ
 
-@[simp] theorem map_bot (f : A →ₐ[R] B) : subalgebra.map (⊥ : subalgebra R A) f = ⊥ :=
+@[simp] theorem map_bot (f : A →ₐ[R] B) : (⊥ : subalgebra R A).map f = ⊥ :=
 set_like.coe_injective $
   by simp only [← set.range_comp, (∘), algebra.coe_bot, subalgebra.coe_map, f.commutes]
 
-@[simp] theorem comap_top (f : A →ₐ[R] B) : subalgebra.comap (⊤ : subalgebra R B) f = ⊤ :=
+@[simp] theorem comap_top (f : A →ₐ[R] B) : (⊤ : subalgebra R B).comap f = ⊤ :=
 eq_top_iff.2 $ λ x, mem_top
 
 /-- `alg_hom` to `⊤ : subalgebra R A`. -/
@@ -810,12 +810,11 @@ variables (S₁ : subalgebra R B)
 
 /-- The product of two subalgebras is a subalgebra. -/
 def prod : subalgebra R (A × B) :=
-{ carrier := (S : set A) ×ˢ (S₁ : set B),
+{ carrier := S ×ˢ S₁,
   algebra_map_mem' := λ r, ⟨algebra_map_mem _ _, algebra_map_mem _ _⟩,
   .. S.to_subsemiring.prod S₁.to_subsemiring }
 
-@[simp] lemma coe_prod :
-  (prod S S₁ : set (A × B)) = (S : set A) ×ˢ (S₁ : set B):= rfl
+@[simp] lemma coe_prod : (prod S S₁ : set (A × B)) = S ×ˢ S₁ := rfl
 
 lemma prod_to_submodule :
   (S.prod S₁).to_submodule = S.to_submodule.prod S₁.to_submodule := rfl

formal/lean/mathlib/algebra/algebra/tower.lean

@@ -48,7 +48,7 @@ def lsmul : A →ₐ[R] module.End R M :=
 @[simp] lemma lsmul_coe (a : A) : (lsmul R M a : M → M) = (•) a := rfl
 
 lemma lmul_algebra_map (x : R) :
-  lmul R A (algebra_map R A x) = algebra.lsmul R A x :=
+  algebra.lmul R A (algebra_map R A x) = algebra.lsmul R A x :=
 eq.symm $ linear_map.ext $ smul_def x
 
 end algebra

formal/lean/mathlib/algebra/algebra/unitization.lean

@@ -345,9 +345,8 @@ instance [comm_monoid R] [non_unital_semiring A] [distrib_mul_action R A] [is_sc
       abel },
   ..unitization.mul_one_class }
 
--- This should work for `non_unital_comm_semiring`s, but we don't seem to have those
-instance [comm_monoid R] [comm_semiring A] [distrib_mul_action R A] [is_scalar_tower R A A]
-  [smul_comm_class R A A] : comm_monoid (unitization R A) :=
+instance [comm_monoid R] [non_unital_comm_semiring A] [distrib_mul_action R A]
+  [is_scalar_tower R A A] [smul_comm_class R A A] : comm_monoid (unitization R A) :=
 { mul_comm := λ x₁ x₂, ext (mul_comm x₁.1 x₂.1) $
     show x₁.1 • x₂.2 + x₂.1 • x₁.2 + x₁.2 * x₂.2 = x₂.1 • x₁.2 + x₁.1 • x₂.2 + x₂.2 * x₁.2,
     by rw [add_comm (x₁.1 • x₂.2), mul_comm],
@@ -358,8 +357,7 @@ instance [comm_semiring R] [non_unital_semiring A] [module R A] [is_scalar_tower
 { ..unitization.monoid,
   ..unitization.non_assoc_semiring }
 
--- This should work for `non_unital_comm_semiring`s, but we don't seem to have those
-instance [comm_semiring R] [comm_semiring A] [module R A] [is_scalar_tower R A A]
+instance [comm_semiring R] [non_unital_comm_semiring A] [module R A] [is_scalar_tower R A A]
   [smul_comm_class R A A] : comm_semiring (unitization R A) :=
 { ..unitization.comm_monoid,
   ..unitization.non_assoc_semiring }

formal/lean/mathlib/algebra/big_operators/basic.lean

@@ -39,7 +39,7 @@ See the documentation of `to_additive.attr` for more information.
 -/
 
 universes u v w
-variables {β : Type u} {α : Type v} {γ : Type w}
+variables {ι : Type*} {β : Type u} {α : Type v} {γ : Type w}
 
 open fin
 
@@ -512,24 +512,24 @@ eq.trans (by rw one_mul; refl) fold_op_distrib
 
 @[to_additive]
 lemma prod_product {s : finset γ} {t : finset α} {f : γ×α → β} :
-  (∏ x in s.product t, f x) = ∏ x in s, ∏ y in t, f (x, y) :=
-prod_finset_product (s.product t) s (λ a, t) (λ p, mem_product)
+  (∏ x in s ×ˢ t, f x) = ∏ x in s, ∏ y in t, f (x, y) :=
+prod_finset_product (s ×ˢ t) s (λ a, t) (λ p, mem_product)
 
 /-- An uncurried version of `finset.prod_product`. -/
 @[to_additive "An uncurried version of `finset.sum_product`"]
 lemma prod_product' {s : finset γ} {t : finset α} {f : γ → α → β} :
-  (∏ x in s.product t, f x.1 x.2) = ∏ x in s, ∏ y in t, f x y :=
+  (∏ x in s ×ˢ t, f x.1 x.2) = ∏ x in s, ∏ y in t, f x y :=
 prod_product
 
 @[to_additive]
 lemma prod_product_right {s : finset γ} {t : finset α} {f : γ×α → β} :
-  (∏ x in s.product t, f x) = ∏ y in t, ∏ x in s, f (x, y) :=
-prod_finset_product_right (s.product t) t (λ a, s) (λ p, mem_product.trans and.comm)
+  (∏ x in s ×ˢ t, f x) = ∏ y in t, ∏ x in s, f (x, y) :=
+prod_finset_product_right (s ×ˢ t) t (λ a, s) (λ p, mem_product.trans and.comm)
 
 /-- An uncurried version of `finset.prod_product_right`. -/
 @[to_additive "An uncurried version of `finset.prod_product_right`"]
 lemma prod_product_right' {s : finset γ} {t : finset α} {f : γ → α → β} :
-  (∏ x in s.product t, f x.1 x.2) = ∏ y in t, ∏ x in s, f x y :=
+  (∏ x in s ×ˢ t, f x.1 x.2) = ∏ y in t, ∏ x in s, f x y :=
 prod_product_right
 
 /-- Generalization of `finset.prod_comm` to the case when the inner `finset`s depend on the outer
@@ -1015,6 +1015,10 @@ begin
   rw [count_eq_zero_of_not_mem hx, pow_zero],
 end
 
+lemma sum_filter_count_eq_countp [decidable_eq α] (p : α → Prop) [decidable_pred p] (l : list α) :
+  ∑ x in l.to_finset.filter p, l.count x = l.countp p :=
+by simp [finset.sum, sum_map_count_dedup_filter_eq_countp p l]
+
 open multiset
 
 @[to_additive] lemma prod_multiset_map_count [decidable_eq α] (s : multiset α)
@@ -1099,6 +1103,16 @@ lemma prod_range_div' {M : Type*} [comm_group M] (f : ℕ → M) (n : ℕ) :
   ∏ i in range n, (f i / f (i + 1)) = f 0 / f n :=
 by apply prod_range_induction; simp
 
+@[to_additive]
+lemma eq_prod_range_div {M : Type*} [comm_group M] (f : ℕ → M) (n : ℕ) :
+  f n = f 0 * ∏ i in range n, (f (i + 1) / f i) :=
+by rw [prod_range_div, mul_div_cancel'_right]
+
+@[to_additive]
+lemma eq_prod_range_div' {M : Type*} [comm_group M] (f : ℕ → M) (n : ℕ) :
+  f n = ∏ i in range (n + 1), if i = 0 then f 0 else f i / f (i - 1) :=
+by { conv_lhs { rw [finset.eq_prod_range_div f] }, simp [finset.prod_range_succ', mul_comm] }
+
 /--
 A telescoping sum along `{0, ..., n-1}` of an `ℕ`-valued function
 reduces to the difference of the last and first terms
@@ -1291,9 +1305,13 @@ begin
 end
 
 /-- Taking a product over `s : finset α` is the same as multiplying the value on a single element
-`f a` by the product of `s.erase a`. -/
+`f a` by the product of `s.erase a`.
+
+See `multiset.prod_map_erase` for the `multiset` version. -/
 @[to_additive "Taking a sum over `s : finset α` is the same as adding the value on a single element
-`f a` to the sum over `s.erase a`."]
+`f a` to the sum over `s.erase a`.
+
+See `multiset.sum_map_erase` for the `multiset` version."]
 lemma mul_prod_erase [decidable_eq α] (s : finset α) (f : α → β) {a : α} (h : a ∈ s) :
   f a * (∏ x in s.erase a, f x) = ∏ x in s, f x :=
 by rw [← prod_insert (not_mem_erase a s), insert_erase h]
@@ -1388,17 +1406,6 @@ lemma sum_boole {s : finset α} {p : α → Prop} [non_assoc_semiring β] {hp :
   (∑ x in s, if p x then (1 : β) else (0 : β)) = (s.filter p).card :=
 by simp [sum_ite]
 
-lemma eq_sum_range_sub [add_comm_group β] (f : ℕ → β) (n : ℕ) :
-  f n = f 0 + ∑ i in range n, (f (i+1) - f i) :=
-by rw [finset.sum_range_sub, add_sub_cancel'_right]
-
-lemma eq_sum_range_sub' [add_comm_group β] (f : ℕ → β) (n : ℕ) :
-  f n = ∑ i in range (n + 1), if i = 0 then f 0 else f i - f (i - 1) :=
-begin
-  conv_lhs { rw [finset.eq_sum_range_sub f] },
-  simp [finset.sum_range_succ', add_comm]
-end
-
 lemma _root_.commute.sum_right [non_unital_non_assoc_semiring β] (s : finset α)
   (f : α → β) (b : β) (h : ∀ i ∈ s, commute b (f i)) :
   commute b (∑ i in s, f i) :=
@@ -1539,13 +1546,7 @@ end prod_eq_zero
 lemma prod_unique_nonempty {α β : Type*} [comm_monoid β] [unique α]
   (s : finset α) (f : α → β) (h : s.nonempty) :
   (∏ x in s, f x) = f default :=
-begin
-  obtain ⟨a, ha⟩ := h,
-  have : s = {a},
-  { ext b,
-    simpa [subsingleton.elim a b] using ha },
-  rw [this, finset.prod_singleton, subsingleton.elim a default]
-end
+by rw [h.eq_singleton_default, finset.prod_singleton]
 
 end finset
 
@@ -1596,8 +1597,8 @@ by rw [univ_unique, prod_singleton]
   (∏ x : α, f x) = 1 :=
 by rw [eq_empty_of_is_empty (univ : finset α), finset.prod_empty]
 
-@[to_additive]
-lemma prod_subsingleton {α β : Type*} [comm_monoid β] [subsingleton α] (f : α → β) (a : α) :
+@[to_additive] lemma prod_subsingleton {α β : Type*} [comm_monoid β] [subsingleton α] [fintype α]
+  (f : α → β) (a : α) :
   (∏ x : α, f x) = f a :=
 begin
   haveI : unique α := unique_of_subsingleton a,
@@ -1631,8 +1632,85 @@ end list
 
 namespace multiset
 
+lemma disjoint_list_sum_left {a : multiset α} {l : list (multiset α)} :
+  multiset.disjoint l.sum a ↔ ∀ b ∈ l, multiset.disjoint b a :=
+begin
+  induction l with b bs ih,
+  { simp only [zero_disjoint, list.not_mem_nil, is_empty.forall_iff, forall_const, list.sum_nil], },
+  { simp_rw [list.sum_cons, disjoint_add_left, list.mem_cons_iff, forall_eq_or_imp],
+    simp [and.congr_left_iff, iff_self, ih], },
+end
+
+lemma disjoint_list_sum_right {a : multiset α} {l : list (multiset α)} :
+  multiset.disjoint a l.sum ↔ ∀ b ∈ l, multiset.disjoint a b :=
+by simpa only [disjoint_comm] using disjoint_list_sum_left
+
+lemma disjoint_sum_left {a : multiset α} {i : multiset (multiset α)} :
+  multiset.disjoint i.sum a ↔ ∀ b ∈ i, multiset.disjoint b a :=
+quotient.induction_on i $ λ l, begin
+  rw [quot_mk_to_coe, multiset.coe_sum],
+  exact disjoint_list_sum_left,
+end
+
+lemma disjoint_sum_right {a : multiset α} {i : multiset (multiset α)} :
+  multiset.disjoint a i.sum ↔ ∀ b ∈ i, multiset.disjoint a b :=
+by simpa only [disjoint_comm] using disjoint_sum_left
+
+lemma disjoint_finset_sum_left {β : Type*} {i : finset β} {f : β → multiset α} {a : multiset α} :
+  multiset.disjoint (i.sum f) a ↔ ∀ b ∈ i, multiset.disjoint (f b) a :=
+begin
+  convert (@disjoint_sum_left _ a) (map f i.val),
+  simp [finset.mem_def, and.congr_left_iff, iff_self],
+end
+
+lemma disjoint_finset_sum_right {β : Type*} {i : finset β} {f : β → multiset α} {a : multiset α} :
+  multiset.disjoint a (i.sum f) ↔ ∀ b ∈ i, multiset.disjoint a (f b) :=
+by simpa only [disjoint_comm] using disjoint_finset_sum_left
+
 variables [decidable_eq α]
 
+lemma add_eq_union_left_of_le {x y z : multiset α} (h : y ≤ x) :
+  z + x = z ∪ y ↔ z.disjoint x ∧ x = y :=
+begin
+  rw ←add_eq_union_iff_disjoint,
+  split,
+  { intro h0,
+    rw and_iff_right_of_imp,
+    { exact (le_of_add_le_add_left $ h0.trans_le $ union_le_add z y).antisymm h, },
+    { rintro rfl,
+      exact h0, } },
+  { rintro ⟨h0, rfl⟩,
+    exact h0, }
+end
+
+lemma add_eq_union_right_of_le {x y z : multiset α} (h : z ≤ y) :
+  x + y = x ∪ z ↔ y = z ∧ x.disjoint y :=
+by simpa only [and_comm] using add_eq_union_left_of_le h
+
+lemma finset_sum_eq_sup_iff_disjoint {β : Type*} {i : finset β} {f : β → multiset α} :
+  i.sum f = i.sup f ↔ ∀ x y ∈ i, x ≠ y → multiset.disjoint (f x) (f y) :=
+begin
+  induction i using finset.cons_induction_on with z i hz hr,
+  { simp only [finset.not_mem_empty, is_empty.forall_iff, implies_true_iff,
+      finset.sum_empty, finset.sup_empty, bot_eq_zero, eq_self_iff_true], },
+  { simp_rw [finset.sum_cons hz, finset.sup_cons, finset.mem_cons, multiset.sup_eq_union,
+      forall_eq_or_imp, ne.def, eq_self_iff_true, not_true, is_empty.forall_iff, true_and,
+      imp_and_distrib, forall_and_distrib, ←hr, @eq_comm _ z],
+    have := λ x ∈ i, ne_of_mem_of_not_mem H hz,
+    simp only [this, not_false_iff, true_implies_iff] {contextual := tt},
+    simp_rw [←disjoint_finset_sum_left, ←disjoint_finset_sum_right, disjoint_comm, ←and_assoc,
+      and_self],
+    exact add_eq_union_left_of_le (finset.sup_le (λ x hx, le_sum_of_mem (mem_map_of_mem f hx))), },
+end
+
+lemma sup_powerset_len {α : Type*} [decidable_eq α] (x : multiset α) :
+  finset.sup (finset.range (x.card + 1)) (λ k, x.powerset_len k) = x.powerset :=
+begin
+  convert bind_powerset_len x,
+  rw [multiset.bind, multiset.join, ←finset.range_coe, ←finset.sum_eq_multiset_sum],
+  exact eq.symm (finset_sum_eq_sup_iff_disjoint.mpr (λ _ _ _ _ h, disjoint_powerset_len x h)),
+end
+
 @[simp] lemma to_finset_sum_count_eq (s : multiset α) :
   (∑ a in s.to_finset, s.count a) = s.card :=
 multiset.induction_on s rfl
@@ -1780,3 +1858,63 @@ begin
     simp only [his, finset.sum_insert, not_false_iff],
     exact (int.nat_abs_add_le _ _).trans (add_le_add le_rfl IH) }
 end
+
+/-! ### `additive`, `multiplicative` -/
+
+open additive multiplicative
+
+section monoid
+variables [monoid α]
+
+@[simp] lemma of_mul_list_prod (s : list α) : of_mul s.prod = (s.map of_mul).sum :=
+by simpa [of_mul]
+
+@[simp] lemma to_mul_list_sum (s : list (additive α)) :
+  to_mul s.sum = (s.map to_mul).prod := by simpa [to_mul, of_mul]
+
+end monoid
+
+section add_monoid
+variables [add_monoid α]
+
+@[simp] lemma of_add_list_prod (s : list α) : of_add s.sum = (s.map of_add).prod :=
+by simpa [of_add]
+
+@[simp] lemma to_add_list_sum (s : list (multiplicative α)) :
+  to_add s.prod = (s.map to_add).sum := by simpa [to_add, of_add]
+
+end add_monoid
+
+section comm_monoid
+variables [comm_monoid α]
+
+@[simp] lemma of_mul_multiset_prod (s : multiset α) :
+  of_mul s.prod = (s.map of_mul).sum := by simpa [of_mul]
+
+@[simp] lemma to_mul_multiset_sum (s : multiset (additive α)) :
+  to_mul s.sum = (s.map to_mul).prod := by simpa [to_mul, of_mul]
+
+@[simp] lemma of_mul_prod (s : finset ι) (f : ι → α) :
+  of_mul (∏ i in s, f i) = ∑ i in s, of_mul (f i) := rfl
+
+@[simp] lemma to_mul_sum (s : finset ι) (f : ι → additive α) :
+  to_mul (∑ i in s, f i) = ∏ i in s, to_mul (f i) := rfl
+
+end comm_monoid
+
+section add_comm_monoid
+variables [add_comm_monoid α]
+
+@[simp] lemma of_add_multiset_prod (s : multiset α) :
+  of_add s.sum = (s.map of_add).prod := by simpa [of_add]
+
+@[simp] lemma to_add_multiset_sum (s : multiset (multiplicative α)) :
+  to_add s.prod = (s.map to_add).sum := by simpa [to_add, of_add]
+
+@[simp] lemma of_add_sum (s : finset ι) (f : ι → α)  :
+  of_add (∑ i in s, f i) = ∏ i in s, of_add (f i) := rfl
+
+@[simp] lemma to_add_prod (s : finset ι) (f : ι → multiplicative α) :
+  to_add (∏ i in s, f i) = ∑ i in s, to_add (f i) := rfl
+
+end add_comm_monoid

formal/lean/mathlib/algebra/big_operators/fin.lean

@@ -95,6 +95,30 @@ by simp
   ∏ i, f i = f 0 * f 1 :=
 by simp [prod_univ_succ]
 
+@[to_additive] theorem prod_univ_three [comm_monoid β] (f : fin 3 → β) :
+  ∏ i, f i = f 0 * f 1 * f 2 :=
+by { rw [prod_univ_cast_succ, prod_univ_two], refl }
+
+@[to_additive] theorem prod_univ_four [comm_monoid β] (f : fin 4 → β) :
+  ∏ i, f i = f 0 * f 1 * f 2 * f 3 :=
+by { rw [prod_univ_cast_succ, prod_univ_three], refl }
+
+@[to_additive] theorem prod_univ_five [comm_monoid β] (f : fin 5 → β) :
+  ∏ i, f i = f 0 * f 1 * f 2 * f 3 * f 4 :=
+by { rw [prod_univ_cast_succ, prod_univ_four], refl }
+
+@[to_additive] theorem prod_univ_six [comm_monoid β] (f : fin 6 → β) :
+  ∏ i, f i = f 0 * f 1 * f 2 * f 3 * f 4 * f 5 :=
+by { rw [prod_univ_cast_succ, prod_univ_five], refl }
+
+@[to_additive] theorem prod_univ_seven [comm_monoid β] (f : fin 7 → β) :
+  ∏ i, f i = f 0 * f 1 * f 2 * f 3 * f 4 * f 5 * f 6 :=
+by { rw [prod_univ_cast_succ, prod_univ_six], refl }
+
+@[to_additive] theorem prod_univ_eight [comm_monoid β] (f : fin 8 → β) :
+  ∏ i, f i = f 0 * f 1 * f 2 * f 3 * f 4 * f 5 * f 6 * f 7 :=
+by { rw [prod_univ_cast_succ, prod_univ_seven], refl }
+
 lemma sum_pow_mul_eq_add_pow {n : ℕ} {R : Type*} [comm_semiring R] (a b : R) :
   ∑ s : finset (fin n), a ^ s.card * b ^ (n - s.card) = (a + b) ^ n :=
 by simpa using fintype.sum_pow_mul_eq_add_pow (fin n) a b
@@ -157,6 +181,29 @@ by simp [partial_prod, list.take_succ, list.of_fn_nth_val, dif_pos j.is_lt, ←o
   partial_prod f j.succ = f 0 * partial_prod (fin.tail f) j :=
 by simpa [partial_prod]
 
+@[to_additive] lemma partial_prod_left_inv {G : Type*} [group G] (f : fin (n + 1) → G) :
+  f 0 • partial_prod (λ i : fin n, (f i)⁻¹ * f i.succ) = f :=
+funext $ λ x, fin.induction_on x (by simp) (λ x hx,
+begin
+  simp only [coe_eq_cast_succ, pi.smul_apply, smul_eq_mul] at hx ⊢,
+  rw [partial_prod_succ, ←mul_assoc, hx, mul_inv_cancel_left],
+end)
+
+@[to_additive] lemma partial_prod_right_inv {G : Type*} [group G]
+  (g : G) (f : fin n → G) (i : fin n) :
+  ((g • partial_prod f) i)⁻¹ * (g • partial_prod f) i.succ = f i :=
+begin
+  cases i with i hn,
+  induction i with i hi generalizing hn,
+  { simp [←fin.succ_mk, partial_prod_succ] },
+  { specialize hi (lt_trans (nat.lt_succ_self i) hn),
+    simp only [mul_inv_rev, fin.coe_eq_cast_succ, fin.succ_mk, fin.cast_succ_mk,
+      smul_eq_mul, pi.smul_apply] at hi ⊢,
+    rw [←fin.succ_mk _ _ (lt_trans (nat.lt_succ_self _) hn), ←fin.succ_mk],
+    simp only [partial_prod_succ, mul_inv_rev, fin.cast_succ_mk],
+    assoc_rw [hi, inv_mul_cancel_left] }
+end
+
 end partial_prod
 
 end fin

formal/lean/mathlib/algebra/big_operators/multiset.lean

@@ -58,6 +58,12 @@ lemma prod_cons (a : α) (s) : prod (a ::ₘ s) = a * prod s := foldr_cons _ _ _
 lemma prod_erase [decidable_eq α] (h : a ∈ s) : a * (s.erase a).prod = s.prod :=
 by rw [← s.coe_to_list, coe_erase, coe_prod, coe_prod, list.prod_erase ((s.mem_to_list a).2 h)]
 
+@[simp, to_additive]
+lemma prod_map_erase [decidable_eq ι] {a : ι} (h : a ∈ m) :
+  f a * ((m.erase a).map f).prod = (m.map f).prod :=
+by rw [← m.coe_to_list, coe_erase, coe_map, coe_map, coe_prod, coe_prod,
+  list.prod_map_erase f ((m.mem_to_list a).2 h)]
+
 @[simp, to_additive]
 lemma prod_singleton (a : α) : prod {a} = a :=
 by simp only [mul_one, prod_cons, singleton_eq_cons, eq_self_iff_true, prod_zero]
@@ -78,6 +84,22 @@ lemma prod_nsmul (m : multiset α) : ∀ (n : ℕ), (n • m).prod = m.prod ^ n
 @[simp, to_additive] lemma prod_repeat (a : α) (n : ℕ) : (repeat a n).prod = a ^ n :=
 by simp [repeat, list.prod_repeat]
 
+@[to_additive]
+lemma prod_map_eq_pow_single [decidable_eq ι] (i : ι) (hf : ∀ i' ≠ i, i' ∈ m → f i' = 1) :
+  (m.map f).prod = f i ^ m.count i :=
+begin
+  induction m using quotient.induction_on with l,
+  simp [list.prod_map_eq_pow_single i f hf],
+end
+
+@[to_additive]
+lemma prod_eq_pow_single [decidable_eq α] (a : α) (h : ∀ a' ≠ a, a' ∈ s → a' = 1) :
+  s.prod = a ^ (s.count a) :=
+begin
+  induction s using quotient.induction_on with l,
+  simp [list.prod_eq_pow_single a h],
+end
+
 @[to_additive]
 lemma pow_count [decidable_eq α] (a : α) : a ^ s.count a = (s.filter (eq a)).prod :=
 by rw [filter_eq, prod_repeat]
@@ -319,6 +341,15 @@ lemma prod_eq_one_iff [canonically_ordered_monoid α] {m : multiset α} :
   m.prod = 1 ↔ ∀ x ∈ m, x = (1 : α) :=
 quotient.induction_on m $ λ l, by simpa using list.prod_eq_one_iff l
 
+/-- Slightly more general version of `multiset.prod_eq_one_iff` for a non-ordered `monoid` -/
+@[to_additive "Slightly more general version of `multiset.sum_eq_zero_iff`
+  for a non-ordered `add_monoid`"]
+lemma prod_eq_one [comm_monoid α] {m : multiset α} (h : ∀ x ∈ m, x = (1 : α)) : m.prod = 1 :=
+begin
+  induction m using quotient.induction_on with l,
+  simp [list.prod_eq_one h],
+end
+
 @[to_additive]
 lemma le_prod_of_mem [canonically_ordered_monoid α] {m : multiset α} {a : α} (h : a ∈ m) :
   a ≤ m.prod :=

formal/lean/mathlib/algebra/big_operators/norm_num.lean

@@ -83,72 +83,6 @@ meta def list.decide_mem (decide_eq : expr → expr → tactic (bool × expr)) :
       pf ← i_to_expr ``(list.not_mem_cons %%head_pf %%tail_pf),
       pure (ff, pf)
 
-lemma finset.insert_eq_coe_list_of_mem {α : Type*} [decidable_eq α] (x : α) (xs : finset α)
-  {xs' : list α} (h : x ∈ xs') (nd_xs : xs'.nodup)
-  (hxs' : xs = finset.mk ↑xs' (multiset.coe_nodup.mpr nd_xs)) :
-  insert x xs = finset.mk ↑xs' (multiset.coe_nodup.mpr nd_xs) :=
-have h : x ∈ xs, by simpa [hxs'] using h,
-by rw [finset.insert_eq_of_mem h, hxs']
-
-lemma finset.insert_eq_coe_list_cons {α : Type*} [decidable_eq α] (x : α) (xs : finset α)
-  {xs' : list α} (h : x ∉ xs') (nd_xs : xs'.nodup) (nd_xxs : (x :: xs').nodup)
-  (hxs' : xs = finset.mk ↑xs' (multiset.coe_nodup.mpr nd_xs)) :
-  insert x xs = finset.mk ↑(x :: xs') (multiset.coe_nodup.mpr nd_xxs) :=
-have h : x ∉ xs, by simpa [hxs'] using h,
-by { rw [← finset.val_inj, finset.insert_val_of_not_mem h, hxs'], simp only [multiset.cons_coe] }
-
-/-- Convert an expression denoting a finset to a list of elements,
-a proof that this list is equal to the original finset,
-and a proof that the list contains no duplicates.
-
-We return a list rather than a finset, so we can more easily iterate over it
-(without having to prove that our tactics are independent of the order of iteration,
-which is in general not true).
-
-`decide_eq` is a (partial) decision procedure for determining whether two
-elements of the finset are equal, for example to parse `{2, 1, 2}` into `[2, 1]`.
--/
-meta def eval_finset (decide_eq : expr → expr → tactic (bool × expr)) :
-  expr → tactic (list expr × expr × expr)
-| e@`(has_emptyc.emptyc) := do
-  eq ← mk_eq_refl e,
-  nd ← i_to_expr ``(list.nodup_nil),
-  pure ([], eq, nd)
-| e@`(has_singleton.singleton %%x) := do
-  eq ← mk_eq_refl e,
-  nd ← i_to_expr ``(list.nodup_singleton %%x),
-  pure ([x], eq, nd)
-| `(@@has_insert.insert (@@finset.has_insert %%dec) %%x %%xs) := do
-  (exs, xs_eq, xs_nd) ← eval_finset xs,
-  (is_mem, mem_pf) ← list.decide_mem decide_eq x exs,
-  if is_mem then do
-    pf ← i_to_expr ``(finset.insert_eq_coe_list_of_mem %%x %%xs %%mem_pf %%xs_nd %%xs_eq),
-    pure (exs, pf, xs_nd)
-  else do
-    nd ← i_to_expr ``(list.nodup_cons.mpr ⟨%%mem_pf, %%xs_nd⟩),
-    pf ← i_to_expr ``(finset.insert_eq_coe_list_cons %%x %%xs %%mem_pf %%xs_nd %%nd %%xs_eq),
-    pure (x :: exs, pf, nd)
-| `(@@finset.univ %%ft) := do
-  -- Convert the fintype instance expression `ft` to a list of its elements.
-  -- Unfold it to the `fintype.mk` constructor and a list of arguments.
-  `fintype.mk ← get_app_fn_const_whnf ft
-    | fail (to_fmt "Unknown fintype expression" ++ format.line ++ to_fmt ft),
-  [_, args, _] ← get_app_args_whnf ft | fail (to_fmt "Expected 3 arguments to `fintype.mk`"),
-  eval_finset args
-| e@`(finset.range %%en) := do
-  n ← expr.to_nat en,
-  eis ← (list.range n).mmap (λ i, expr.of_nat `(ℕ) i),
-  eq ← mk_eq_refl e,
-  nd ← i_to_expr ``(list.nodup_range %%en),
-  pure (eis, eq, nd)
-| e@`(finset.fin_range %%en) := do
-  n ← expr.to_nat en,
-  eis ← (list.fin_range n).mmap (λ i, expr.of_nat `(fin %%en) i),
-  eq ← mk_eq_refl e,
-  nd ← i_to_expr ``(list.nodup_fin_range %%en),
-  pure (eis, eq, nd)
-| e := fail (to_fmt "Unknown finset expression" ++ format.line ++ to_fmt e)
-
 lemma list.map_cons_congr {α β : Type*} (f : α → β) {x : α} {xs : list α} {fx : β} {fxs : list β}
   (h₁ : f x = fx) (h₂ : xs.map f = fxs) : (x :: xs).map f = fx :: fxs :=
 by rw [list.map_cons, h₁, h₂]
@@ -164,6 +98,36 @@ meta def eval_list_map (ef : expr) : list expr → tactic (list expr × expr)
   eq ← i_to_expr ``(list.map_cons_congr %%ef %%fx_eq %%fxs_eq),
   pure (fx :: fxs, eq)
 
+lemma list.cons_congr {α : Type*} (x : α) {xs : list α} {xs' : list α} (xs_eq : xs' = xs) :
+  x :: xs' = x :: xs :=
+by rw xs_eq
+
+lemma list.map_congr {α β : Type*} (f : α → β) {xs xs' : list α}
+  {ys : list β} (xs_eq : xs = xs') (ys_eq : xs'.map f = ys) :
+  xs.map f = ys :=
+by rw [← ys_eq, xs_eq]
+
+/-- Convert an expression denoting a list to a list of elements. -/
+meta def eval_list : expr → tactic (list expr × expr)
+| e@`(list.nil) := do
+  eq ← mk_eq_refl e,
+  pure ([], eq)
+| e@`(list.cons %%x %%xs) := do
+  (xs, xs_eq) ← eval_list xs,
+  eq ← i_to_expr ``(list.cons_congr %%x %%xs_eq),
+  pure (x :: xs, eq)
+| e@`(list.range %%en) := do
+  n ← expr.to_nat en,
+  eis ← (list.range n).mmap (λ i, expr.of_nat `(ℕ) i),
+  eq ← mk_eq_refl e,
+  pure (eis, eq)
+| `(@list.map %%α %%β %%ef %%exs) := do
+  (xs, xs_eq) ← eval_list exs,
+  (ys, ys_eq) ← eval_list_map ef xs,
+  eq ← i_to_expr ``(list.map_congr %%ef %%xs_eq %%ys_eq),
+  pure (ys, eq)
+| e := fail (to_fmt "Unknown list expression" ++ format.line ++ to_fmt e)
+
 lemma multiset.cons_congr {α : Type*} (x : α) {xs : multiset α} {xs' : list α}
   (xs_eq : (xs' : multiset α) = xs) : (list.cons x xs' : multiset α) = x ::ₘ xs :=
 by rw [← xs_eq]; refl
@@ -209,35 +173,71 @@ meta def eval_multiset : expr → tactic (list expr × expr)
   pure (ys, eq)
 | e := fail (to_fmt "Unknown multiset expression" ++ format.line ++ to_fmt e)
 
-lemma list.cons_congr {α : Type*} (x : α) {xs : list α} {xs' : list α} (xs_eq : xs' = xs) :
-  x :: xs' = x :: xs :=
-by rw xs_eq
+lemma finset.insert_eq_coe_list_of_mem {α : Type*} [decidable_eq α] (x : α) (xs : finset α)
+  {xs' : list α} (h : x ∈ xs') (nd_xs : xs'.nodup)
+  (hxs' : xs = finset.mk ↑xs' (multiset.coe_nodup.mpr nd_xs)) :
+  insert x xs = finset.mk ↑xs' (multiset.coe_nodup.mpr nd_xs) :=
+have h : x ∈ xs, by simpa [hxs'] using h,
+by rw [finset.insert_eq_of_mem h, hxs']
 
-lemma list.map_congr {α β : Type*} (f : α → β) {xs xs' : list α}
-  {ys : list β} (xs_eq : xs = xs') (ys_eq : xs'.map f = ys) :
-  xs.map f = ys :=
-by rw [← ys_eq, xs_eq]
+lemma finset.insert_eq_coe_list_cons {α : Type*} [decidable_eq α] (x : α) (xs : finset α)
+  {xs' : list α} (h : x ∉ xs') (nd_xs : xs'.nodup) (nd_xxs : (x :: xs').nodup)
+  (hxs' : xs = finset.mk ↑xs' (multiset.coe_nodup.mpr nd_xs)) :
+  insert x xs = finset.mk ↑(x :: xs') (multiset.coe_nodup.mpr nd_xxs) :=
+have h : x ∉ xs, by simpa [hxs'] using h,
+by { rw [← finset.val_inj, finset.insert_val_of_not_mem h, hxs'], simp only [multiset.cons_coe] }
 
-/-- Convert an expression denoting a list to a list of elements. -/
-meta def eval_list : expr → tactic (list expr × expr)
-| e@`(list.nil) := do
+/-- Convert an expression denoting a finset to a list of elements,
+a proof that this list is equal to the original finset,
+and a proof that the list contains no duplicates.
+
+We return a list rather than a finset, so we can more easily iterate over it
+(without having to prove that our tactics are independent of the order of iteration,
+which is in general not true).
+
+`decide_eq` is a (partial) decision procedure for determining whether two
+elements of the finset are equal, for example to parse `{2, 1, 2}` into `[2, 1]`.
+-/
+meta def eval_finset (decide_eq : expr → expr → tactic (bool × expr)) :
+  expr → tactic (list expr × expr × expr)
+| e@`(has_emptyc.emptyc) := do
   eq ← mk_eq_refl e,
-  pure ([], eq)
-| e@`(list.cons %%x %%xs) := do
-  (xs, xs_eq) ← eval_list xs,
-  eq ← i_to_expr ``(list.cons_congr %%x %%xs_eq),
-  pure (x :: xs, eq)
-| e@`(list.range %%en) := do
+  nd ← i_to_expr ``(list.nodup_nil),
+  pure ([], eq, nd)
+| e@`(has_singleton.singleton %%x) := do
+  eq ← mk_eq_refl e,
+  nd ← i_to_expr ``(list.nodup_singleton %%x),
+  pure ([x], eq, nd)
+| `(@@has_insert.insert (@@finset.has_insert %%dec) %%x %%xs) := do
+  (exs, xs_eq, xs_nd) ← eval_finset xs,
+  (is_mem, mem_pf) ← list.decide_mem decide_eq x exs,
+  if is_mem then do
+    pf ← i_to_expr ``(finset.insert_eq_coe_list_of_mem %%x %%xs %%mem_pf %%xs_nd %%xs_eq),
+    pure (exs, pf, xs_nd)
+  else do
+    nd ← i_to_expr ``(list.nodup_cons.mpr ⟨%%mem_pf, %%xs_nd⟩),
+    pf ← i_to_expr ``(finset.insert_eq_coe_list_cons %%x %%xs %%mem_pf %%xs_nd %%nd %%xs_eq),
+    pure (x :: exs, pf, nd)
+| `(@@finset.univ %%ft) := do
+  -- Convert the fintype instance expression `ft` to a list of its elements.
+  -- Unfold it to the `fintype.mk` constructor and a list of arguments.
+  `fintype.mk ← get_app_fn_const_whnf ft
+    | fail (to_fmt "Unknown fintype expression" ++ format.line ++ to_fmt ft),
+  [_, args, _] ← get_app_args_whnf ft | fail (to_fmt "Expected 3 arguments to `fintype.mk`"),
+  eval_finset args
+| e@`(finset.range %%en) := do
   n ← expr.to_nat en,
   eis ← (list.range n).mmap (λ i, expr.of_nat `(ℕ) i),
   eq ← mk_eq_refl e,
-  pure (eis, eq)
-| `(@list.map %%α %%β %%ef %%exs) := do
-  (xs, xs_eq) ← eval_list exs,
-  (ys, ys_eq) ← eval_list_map ef xs,
-  eq ← i_to_expr ``(list.map_congr %%ef %%xs_eq %%ys_eq),
-  pure (ys, eq)
-| e := fail (to_fmt "Unknown list expression" ++ format.line ++ to_fmt e)
+  nd ← i_to_expr ``(list.nodup_range %%en),
+  pure (eis, eq, nd)
+| e@`(finset.fin_range %%en) := do
+  n ← expr.to_nat en,
+  eis ← (list.fin_range n).mmap (λ i, expr.of_nat `(fin %%en) i),
+  eq ← mk_eq_refl e,
+  nd ← i_to_expr ``(list.nodup_fin_range %%en),
+  pure (eis, eq, nd)
+| e := fail (to_fmt "Unknown finset expression" ++ format.line ++ to_fmt e)
 
 @[to_additive]
 lemma list.prod_cons_congr {α : Type*} [monoid α] (xs : list α) (x y z : α)

formal/lean/mathlib/algebra/big_operators/ring.lean

@@ -52,7 +52,7 @@ add_monoid_hom.map_sum (add_monoid_hom.mul_left b) _ s
 
 lemma sum_mul_sum {ι₁ : Type*} {ι₂ : Type*} (s₁ : finset ι₁) (s₂ : finset ι₂)
   (f₁ : ι₁ → β) (f₂ : ι₂ → β) :
-  (∑ x₁ in s₁, f₁ x₁) * (∑ x₂ in s₂, f₂ x₂) = ∑ p in s₁.product s₂, f₁ p.1 * f₂ p.2 :=
+  (∑ x₁ in s₁, f₁ x₁) * (∑ x₂ in s₂, f₂ x₂) = ∑ p in s₁ ×ˢ s₂, f₁ p.1 * f₂ p.2 :=
 by { rw [sum_product, sum_mul, sum_congr rfl], intros, rw mul_sum }
 
 end semiring

formal/lean/mathlib/algebra/category/FinVect.lean

@@ -31,22 +31,21 @@ instance monoidal_predicate_finite_dimensional :
 { prop_id' := finite_dimensional.finite_dimensional_self K,
   prop_tensor' := λ X Y hX hY, by exactI module.finite.tensor_product K X Y }
 
+instance closed_predicate_finite_dimensional :
+  monoidal_category.closed_predicate (λ V : Module.{u} K, finite_dimensional K V) :=
+{ prop_ihom' := λ X Y hX hY, by exactI @linear_map.finite_dimensional K _ X _ _ hX Y _ _ hY }
+
 /-- Define `FinVect` as the subtype of `Module.{u} K` of finite dimensional vector spaces. -/
-@[derive [large_category, λ α, has_coe_to_sort α (Sort*), concrete_category, monoidal_category,
-  symmetric_category]]
-def FinVect := { V : Module.{u} K // finite_dimensional K V }
+@[derive [large_category, concrete_category, monoidal_category, symmetric_category,
+monoidal_closed]]
+def FinVect := full_subcategory (λ (V : Module.{u} K), finite_dimensional K V)
 
 namespace FinVect
 
-instance finite_dimensional (V : FinVect K) : finite_dimensional K V := V.prop
+instance finite_dimensional (V : FinVect K) : finite_dimensional K V.obj := V.property
 
 instance : inhabited (FinVect K) := ⟨⟨Module.of K K, finite_dimensional.finite_dimensional_self K⟩⟩
 
-instance : has_coe (FinVect.{u} K) (Module.{u} K) := { coe := λ V, V.1, }
-
-protected lemma coe_comp {U V W : FinVect K} (f : U ⟶ V) (g : V ⟶ W) :
-  ((f ≫ g) : U → W) = (g : V → W) ∘ (f : U → V) := rfl
-
 /-- Lift an unbundled vector space to `FinVect K`. -/
 def of (V : Type u) [add_comm_group V] [module K V] [finite_dimensional K V] : FinVect K :=
 ⟨Module.of K V, by { change finite_dimensional K V, apply_instance }⟩
@@ -57,46 +56,45 @@ by { dsimp [FinVect], apply_instance, }
 instance : full (forget₂ (FinVect K) (Module.{u} K)) :=
 { preimage := λ X Y f, f, }
 
-variables (V : FinVect K)
+variables (V W : FinVect K)
+
+@[simp] lemma ihom_obj : (ihom V).obj W = FinVect.of K (V.obj →ₗ[K] W.obj) := rfl
 
 /-- The dual module is the dual in the rigid monoidal category `FinVect K`. -/
 def FinVect_dual : FinVect K :=
-⟨Module.of K (module.dual K V), subspace.module.dual.finite_dimensional⟩
-
-instance : has_coe_to_fun (FinVect_dual K V) (λ _, V → K) :=
-{ coe := λ v, by { change V →ₗ[K] K at v, exact v, } }
+⟨Module.of K (module.dual K V.obj), subspace.module.dual.finite_dimensional⟩
 
 open category_theory.monoidal_category
 
 /-- The coevaluation map is defined in `linear_algebra.coevaluation`. -/
 def FinVect_coevaluation : 𝟙_ (FinVect K) ⟶ V ⊗ (FinVect_dual K V) :=
-by apply coevaluation K V
+by apply coevaluation K V.obj
 
 lemma FinVect_coevaluation_apply_one : FinVect_coevaluation K V (1 : K) =
-   ∑ (i : basis.of_vector_space_index K V),
-    (basis.of_vector_space K V) i ⊗ₜ[K] (basis.of_vector_space K V).coord i :=
-by apply coevaluation_apply_one K V
+   ∑ (i : basis.of_vector_space_index K V.obj),
+    (basis.of_vector_space K V.obj) i ⊗ₜ[K] (basis.of_vector_space K V.obj).coord i :=
+by apply coevaluation_apply_one K V.obj
 
 /-- The evaluation morphism is given by the contraction map. -/
 def FinVect_evaluation : (FinVect_dual K V) ⊗ V ⟶ 𝟙_ (FinVect K) :=
-by apply contract_left K V
+by apply contract_left K V.obj
 
 @[simp]
-lemma FinVect_evaluation_apply (f : (FinVect_dual K V)) (x : V) :
-  (FinVect_evaluation K V) (f ⊗ₜ x) = f x :=
+lemma FinVect_evaluation_apply (f : (FinVect_dual K V).obj) (x : V.obj) :
+  (FinVect_evaluation K V) (f ⊗ₜ x) = f.to_fun x :=
 by apply contract_left_apply f x
 
 private theorem coevaluation_evaluation :
   let V' : FinVect K := FinVect_dual K V in
   (𝟙 V' ⊗ (FinVect_coevaluation K V)) ≫ (α_ V' V V').inv ≫ (FinVect_evaluation K V ⊗ 𝟙 V')
   = (ρ_ V').hom ≫ (λ_ V').inv :=
-by apply contract_left_assoc_coevaluation K V
+by apply contract_left_assoc_coevaluation K V.obj
 
 private theorem evaluation_coevaluation :
   (FinVect_coevaluation K V ⊗ 𝟙 V)
   ≫ (α_ V (FinVect_dual K V) V).hom ≫ (𝟙 V ⊗ FinVect_evaluation K V)
   = (λ_ V).hom ≫ (ρ_ V).inv :=
-by apply contract_left_assoc_coevaluation' K V
+by apply contract_left_assoc_coevaluation' K V.obj
 
 instance exact_pairing : exact_pairing V (FinVect_dual K V) :=
 { coevaluation := FinVect_coevaluation K V,
@@ -108,11 +106,11 @@ instance right_dual : has_right_dual V := ⟨FinVect_dual K V⟩
 
 instance right_rigid_category : right_rigid_category (FinVect K) := { }
 
-variables {K V} (W : FinVect K)
+variables {K V}
 
 /-- Converts and isomorphism in the category `FinVect` to a `linear_equiv` between the underlying
 vector spaces. -/
-def iso_to_linear_equiv {V W : FinVect K} (i : V ≅ W) : V ≃ₗ[K] W :=
+def iso_to_linear_equiv {V W : FinVect K} (i : V ≅ W) : V.obj ≃ₗ[K] W.obj :=
   ((forget₂ (FinVect.{u} K) (Module.{u} K)).map_iso i).to_linear_equiv
 
 lemma iso.conj_eq_conj {V W : FinVect K} (i : V ≅ W) (f : End V) :

formal/lean/mathlib/algebra/category/FinVect/limits.lean

@@ -48,7 +48,7 @@ instance (F : J ⥤ FinVect k) :
   finite_dimensional k (limit (F ⋙ forget₂ (FinVect k) (Module.{v} k)) : Module.{v} k) :=
 begin
   haveI : ∀ j, finite_dimensional k ((F ⋙ forget₂ (FinVect k) (Module.{v} k)).obj j),
-  { intro j, change finite_dimensional k (F.obj j), apply_instance, },
+  { intro j, change finite_dimensional k (F.obj j).obj, apply_instance, },
   exact finite_dimensional.of_injective
     (limit_subobject_product (F ⋙ forget₂ (FinVect k) (Module.{v} k)))
     ((Module.mono_iff_injective _).1 (by apply_instance)),

formal/lean/mathlib/algebra/category/Group/epi_mono.lean

@@ -3,7 +3,7 @@ Copyright (c) 2022 Jujian Zhang. All rights reserved.
 Released under Apache 2.0 license as described in the file LICENSE.
 Authors: Jujian Zhang
 -/
-import algebra.category.Group.basic
+import algebra.category.Group.equivalence_Group_AddGroup
 import category_theory.epi_mono
 import group_theory.quotient_group
 
@@ -23,6 +23,7 @@ open quotient_group
 
 variables {A : Type u} {B : Type v}
 
+section
 variables [group A] [group B]
 
 @[to_additive add_monoid_hom.ker_eq_bot_of_cancel]
@@ -30,6 +31,28 @@ lemma ker_eq_bot_of_cancel {f : A →* B} (h : ∀ (u v : f.ker →* A), f.comp
   f.ker = ⊥ :=
 by simpa using _root_.congr_arg range (h f.ker.subtype 1 (by tidy))
 
+end
+
+section
+variables [comm_group A] [comm_group B]
+
+@[to_additive add_monoid_hom.range_eq_top_of_cancel]
+lemma range_eq_top_of_cancel {f : A →* B}
+  (h : ∀ (u v : B →* B ⧸ f.range), u.comp f = v.comp f → u = v) :
+  f.range = ⊤ :=
+begin
+  specialize h 1 (quotient_group.mk' _) _,
+  { ext1,
+    simp only [one_apply, coe_comp, coe_mk', function.comp_app],
+    rw [show (1 : B ⧸ f.range) = (1 : B), from quotient_group.coe_one _, quotient_group.eq,
+     inv_one, one_mul],
+    exact ⟨x, rfl⟩, },
+  replace h : (quotient_group.mk' _).ker = (1 : B →* B ⧸ f.range).ker := by rw h,
+  rwa [ker_one, quotient_group.ker_mk] at h,
+end
+
+end
+
 end monoid_hom
 
 section
@@ -61,7 +84,7 @@ local notation `X` := set.range (function.swap left_coset f.range.carrier)
 /--
 Define `X'` to be the set of all left cosets with an extra point at "infinity".
 -/
-@[nolint has_inhabited_instance]
+@[nolint has_nonempty_instance]
 inductive X_with_infinity
 | from_coset : set.range (function.swap left_coset f.range.carrier) → X_with_infinity
 | infinity : X_with_infinity
@@ -281,4 +304,58 @@ iff.trans (epi_iff_surjective _) (subgroup.eq_top_iff' f.range).symm
 
 end Group
 
+namespace AddGroup
+variables {A B : AddGroup.{u}} (f : A ⟶ B)
+
+lemma epi_iff_surjective : epi f ↔ function.surjective f :=
+begin
+  have i1 : epi f ↔ epi (Group_AddGroup_equivalence.inverse.map f),
+  { refine ⟨_, Group_AddGroup_equivalence.inverse.epi_of_epi_map⟩,
+    introsI e',
+    apply Group_AddGroup_equivalence.inverse.map_epi },
+  rwa Group.epi_iff_surjective at i1,
+end
+
+lemma epi_iff_range_eq_top : epi f ↔ f.range = ⊤ :=
+iff.trans (epi_iff_surjective _) (add_subgroup.eq_top_iff' f.range).symm
+
+end AddGroup
+
+namespace CommGroup
+variables {A B : CommGroup.{u}} (f : A ⟶ B)
+
+@[to_additive AddCommGroup.ker_eq_bot_of_mono]
+lemma ker_eq_bot_of_mono [mono f] : f.ker = ⊥ :=
+monoid_hom.ker_eq_bot_of_cancel $ λ u v,
+  (@cancel_mono _ _ _ _ _ f _ (show CommGroup.of f.ker ⟶ A, from u) _).1
+
+@[to_additive AddCommGroup.mono_iff_ker_eq_bot]
+lemma mono_iff_ker_eq_bot : mono f ↔ f.ker = ⊥ :=
+⟨λ h, @@ker_eq_bot_of_mono f h,
+ λ h, concrete_category.mono_of_injective _ $ (monoid_hom.ker_eq_bot_iff f).1 h⟩
+
+@[to_additive AddCommGroup.mono_iff_injective]
+lemma mono_iff_injective : mono f ↔ function.injective f :=
+iff.trans (mono_iff_ker_eq_bot f) $ monoid_hom.ker_eq_bot_iff f
+
+@[to_additive]
+lemma range_eq_top_of_epi [epi f] : f.range = ⊤ :=
+monoid_hom.range_eq_top_of_cancel $ λ u v h,
+  (@cancel_epi _ _ _ _ _ f _ (show B ⟶ ⟨B ⧸ monoid_hom.range f⟩, from u) v).1 h
+
+@[to_additive]
+lemma epi_iff_range_eq_top : epi f ↔ f.range = ⊤ :=
+⟨λ hf, by exactI range_eq_top_of_epi _,
+ λ hf, concrete_category.epi_of_surjective _ $ monoid_hom.range_top_iff_surjective.mp hf⟩
+
+@[to_additive]
+lemma epi_iff_surjective : epi f ↔ function.surjective f :=
+by rw [epi_iff_range_eq_top, monoid_hom.range_top_iff_surjective]
+
+@[to_additive]
+instance : functor.preserves_epimorphisms (forget₂ CommGroup Group) :=
+{ preserves := λ X Y f e, by rwa [epi_iff_surjective, ←@Group.epi_iff_surjective ⟨X⟩ ⟨Y⟩ f] at e }
+
+end CommGroup
+
 end

formal/lean/mathlib/algebra/category/Group/equivalence_Group_AddGroup.lean

@@ -0,0 +1,86 @@
+/-
+Copyright (c) 2022 Jujian Zhang. All rights reserved.
+Released under Apache 2.0 license as described in the file LICENSE.
+Authors: Jujian Zhang
+-/
+import algebra.category.Group.basic
+
+/-!
+# Equivalence between `Group` and `AddGroup`
+
+This file contains two equivalences:
+* `Group_AddGroup_equivalence` : the equivalence between `Group` and `AddGroup` by sending
+  `X : Group` to `additive X` and `Y : AddGroup` to `multiplicative Y`.
+* `CommGroup_AddCommGroup_equivlance` : the equivalence between `CommGroup` and `AddCommGroup` by
+  sending `X : CommGroup` to `additive X` and `Y : AddCommGroup` to `multiplicative Y`.
+-/
+
+open category_theory
+
+namespace Group
+
+/--
+The functor `Group ⥤ AddGroup` by sending `X ↦ additive X` and `f ↦ f`.
+-/
+@[simps] def to_AddGroup : Group ⥤ AddGroup :=
+{ obj := λ X, AddGroup.of (additive X),
+  map := λ X Y, monoid_hom.to_additive }
+
+end Group
+
+namespace CommGroup
+
+/--
+The functor `CommGroup ⥤ AddCommGroup` by sending `X ↦ additive X` and `f ↦ f`.
+-/
+@[simps] def to_AddCommGroup : CommGroup ⥤ AddCommGroup :=
+{ obj := λ X, AddCommGroup.of (additive X),
+  map := λ X Y, monoid_hom.to_additive }
+
+end CommGroup
+
+namespace AddGroup
+
+/--
+The functor `AddGroup ⥤ Group` by sending `X ↦ multiplicative Y` and `f ↦ f`.
+-/
+@[simps] def to_Group : AddGroup ⥤ Group :=
+{ obj := λ X, Group.of (multiplicative X),
+  map := λ X Y, add_monoid_hom.to_multiplicative }
+
+end AddGroup
+
+namespace AddCommGroup
+
+/--
+The functor `AddCommGroup ⥤ CommGroup` by sending `X ↦ multiplicative Y` and `f ↦ f`.
+-/
+@[simps] def to_CommGroup : AddCommGroup ⥤ CommGroup :=
+{ obj := λ X, CommGroup.of (multiplicative X),
+  map := λ X Y, add_monoid_hom.to_multiplicative }
+
+end AddCommGroup
+
+/--
+The equivalence of categories between `Group` and `AddGroup`
+-/
+@[simps] def Group_AddGroup_equivalence : Group ≌ AddGroup :=
+equivalence.mk Group.to_AddGroup AddGroup.to_Group
+  (nat_iso.of_components
+    (λ X, mul_equiv.to_Group_iso (mul_equiv.multiplicative_additive X))
+    (λ X Y f, rfl))
+  (nat_iso.of_components
+    (λ X, add_equiv.to_AddGroup_iso (add_equiv.additive_multiplicative X))
+    (λ X Y f, rfl))
+
+/--
+The equivalence of categories between `CommGroup` and `AddCommGroup`.
+-/
+@[simps] def CommGroup_AddCommGroup_equivalence : CommGroup ≌ AddCommGroup :=
+equivalence.mk CommGroup.to_AddCommGroup AddCommGroup.to_CommGroup
+  (nat_iso.of_components
+    (λ X, mul_equiv.to_CommGroup_iso (mul_equiv.multiplicative_additive X))
+    (λ X Y f, rfl))
+  (nat_iso.of_components
+    (λ X, add_equiv.to_AddCommGroup_iso (add_equiv.additive_multiplicative X))
+    (λ X Y f, rfl))

formal/lean/mathlib/algebra/category/Module/adjunctions.lean

@@ -156,7 +156,7 @@ universes v u
 we will equip with a category structure where the morphisms are formal `R`-linear combinations
 of the morphisms in `C`.
 -/
-@[nolint unused_arguments has_inhabited_instance]
+@[nolint unused_arguments has_nonempty_instance]
 def Free (R : Type*) (C : Type u) := C
 
 /--

formal/lean/mathlib/algebra/category/Module/change_of_rings.lean

@@ -0,0 +1,65 @@
+/-
+Copyright (c) 2022 Jujian Zhang. All rights reserved.
+Released under Apache 2.0 license as described in the file LICENSE.
+Authors: Jujian Zhang
+-/
+import algebra.category.Module.basic
+
+/-!
+# Change Of Rings
+
+## Main definitions
+
+* `category_theory.Module.restrict_scalars`: given rings `R, S` and a ring homomorphism `R ⟶ S`,
+  then `restrict_scalars : Module S ⥤ Module R` is defined by `M ↦ M` where `M : S-module` is seen
+  as `R-module` by `r • m := f r • m` and `S`-linear map `l : M ⟶ M'` is `R`-linear as well.
+-/
+
+
+namespace category_theory.Module
+
+universes v u₁ u₂
+
+namespace restrict_scalars
+
+variables {R : Type u₁} {S : Type u₂} [ring R] [ring S] (f : R →+* S)
+variable (M : Module.{v} S)
+
+/-- Any `S`-module M is also an `R`-module via a ring homomorphism `f : R ⟶ S` by defining
+    `r • m := f r • m` (`module.comp_hom`). This is called restriction of scalars. -/
+def obj' : Module R :=
+{ carrier := M,
+  is_module := module.comp_hom M f }
+
+/--
+Given an `S`-linear map `g : M → M'` between `S`-modules, `g` is also `R`-linear between `M` and
+`M'` by means of restriction of scalars.
+-/
+def map' {M M' : Module.{v} S} (g : M ⟶ M') :
+  obj' f M ⟶ obj' f M' :=
+{ map_smul' := λ r, g.map_smul (f r), ..g }
+
+end restrict_scalars
+
+/--
+The restriction of scalars operation is functorial. For any `f : R →+* S` a ring homomorphism,
+* an `S`-module `M` can be considered as `R`-module by `r • m = f r • m`
+* an `S`-linear map is also `R`-linear
+-/
+def restrict_scalars {R : Type u₁} {S : Type u₂} [ring R] [ring S] (f : R →+* S) :
+  Module.{v} S ⥤ Module.{v} R :=
+{ obj := restrict_scalars.obj' f,
+  map := λ _ _, restrict_scalars.map' f,
+  map_id' := λ _, linear_map.ext $ λ m, rfl,
+  map_comp' := λ _ _ _ g h, linear_map.ext $ λ m, rfl }
+
+@[simp] lemma restrict_scalars.map_apply {R : Type u₁} {S : Type u₂} [ring R] [ring S] (f : R →+* S)
+  {M M' : Module.{v} S} (g : M ⟶ M') (x) : (restrict_scalars f).map g x = g x := rfl
+
+@[simp] lemma restrict_scalars.smul_def {R : Type u₁} {S : Type u₂} [ring R] [ring S] (f : R →+* S)
+  {M : Module.{v} S} (r : R) (m : (restrict_scalars f).obj M) : r • m = (f r • m : M) := rfl
+
+@[simp] lemma restrict_scalars.smul_def' {R : Type u₁} {S : Type u₂} [ring R] [ring S] (f : R →+* S)
+  {M : Module.{v} S} (r : R) (m : M) : (r • m : (restrict_scalars f).obj M) = (f r • m : M) := rfl
+
+end category_theory.Module

formal/lean/mathlib/algebra/char_p/algebra.lean

@@ -65,6 +65,9 @@ variables (K L : Type*) [field K] [comm_semiring L] [nontrivial L] [algebra K L]
 lemma algebra.char_p_iff (p : ℕ) : char_p K p ↔ char_p L p :=
 (algebra_map K L).char_p_iff_char_p p
 
+lemma algebra.ring_char_eq : ring_char K = ring_char L :=
+by { rw [ring_char.eq_iff, algebra.char_p_iff K L], apply ring_char.char_p }
+
 end
 
 namespace free_algebra

formal/lean/mathlib/algebra/char_p/basic.lean

@@ -349,13 +349,16 @@ calc (k : R) = ↑(k % p + p * (k / p)) : by rw [nat.mod_add_div]
          ... = ↑(k % p)               : by simp [cast_eq_zero]
 
 /-- The characteristic of a finite ring cannot be zero. -/
-theorem char_ne_zero_of_fintype (p : ℕ) [hc : char_p R p] [fintype R] : p ≠ 0 :=
-assume h : p = 0,
-have char_zero R := @char_p_to_char_zero R _ (h ▸ hc),
-absurd (@nat.cast_injective R _ this) (not_injective_infinite_fintype coe)
+theorem char_ne_zero_of_finite (p : ℕ) [char_p R p] [finite R] : p ≠ 0 :=
+begin
+  unfreezingI { rintro rfl },
+  haveI : char_zero R := char_p_to_char_zero R,
+  casesI nonempty_fintype R,
+  exact absurd nat.cast_injective (not_injective_infinite_fintype (coe : ℕ → R))
+end
 
-lemma ring_char_ne_zero_of_fintype [fintype R] : ring_char R ≠ 0 :=
-char_ne_zero_of_fintype R (ring_char R)
+lemma ring_char_ne_zero_of_finite [finite R] : ring_char R ≠ 0 :=
+char_ne_zero_of_finite R (ring_char R)
 
 end
 
@@ -432,11 +435,11 @@ end semiring
 
 section ring
 
-variables (R) [ring R] [no_zero_divisors R] [nontrivial R] [fintype R]
+variables (R) [ring R] [no_zero_divisors R] [nontrivial R] [finite R]
 
 theorem char_is_prime (p : ℕ) [char_p R p] :
   p.prime :=
-or.resolve_right (char_is_prime_or_zero R p) (char_ne_zero_of_fintype R p)
+or.resolve_right (char_is_prime_or_zero R p) (char_ne_zero_of_finite R p)
 
 end ring
 

formal/lean/mathlib/algebra/char_p/char_and_card.lean

@@ -15,12 +15,14 @@ We prove some results relating characteristic and cardinality of finite rings
 characterstic, cardinality, ring
 -/
 
-/-- A prime `p` is a unit in a finite commutative ring `R`
-iff it does not divide the characteristic. -/
-lemma is_unit_iff_not_dvd_char (R : Type*) [comm_ring R] [fintype R] (p : ℕ) [fact p.prime] :
+/-- A prime `p` is a unit in a commutative ring `R` of nonzero characterstic iff it does not divide
+the characteristic. -/
+lemma is_unit_iff_not_dvd_char_of_ring_char_ne_zero (R : Type*) [comm_ring R] (p : ℕ) [fact p.prime]
+  (hR : ring_char R ≠ 0) :
   is_unit (p : R) ↔ ¬ p ∣ ring_char R :=
 begin
   have hch := char_p.cast_eq_zero R (ring_char R),
+  have hp : p.prime := fact.out p.prime,
   split,
   { rintros h₁ ⟨q, hq⟩,
     rcases is_unit.exists_left_inv h₁ with ⟨a, ha⟩,
@@ -29,8 +31,7 @@ begin
       rintro ⟨r, hr⟩,
       rw [hr, ← mul_assoc, mul_comm p, mul_assoc] at hq,
       nth_rewrite 0 ← mul_one (ring_char R) at hq,
-      exact nat.prime.not_dvd_one (fact.out p.prime)
-             ⟨r, mul_left_cancel₀ (char_p.char_ne_zero_of_fintype R (ring_char R)) hq⟩,
+      exact nat.prime.not_dvd_one hp ⟨r, mul_left_cancel₀ hR hq⟩,
     end,
     have h₄ := mt (char_p.int_cast_eq_zero_iff R (ring_char R) q).mp,
     apply_fun (coe : ℕ → R) at hq,
@@ -39,14 +40,19 @@ begin
     norm_cast at h₄,
     exact h₄ h₃ hq.symm, },
   { intro h,
-    rcases nat.is_coprime_iff_coprime.mpr ((nat.prime.coprime_iff_not_dvd (fact.out _)).mpr h)
-      with ⟨a, b, hab⟩,
+    rcases (hp.coprime_iff_not_dvd.mpr h).is_coprime with ⟨a, b, hab⟩,
     apply_fun (coe : ℤ → R) at hab,
     push_cast at hab,
     rw [hch, mul_zero, add_zero, mul_comm] at hab,
     exact is_unit_of_mul_eq_one (p : R) a hab, },
 end
 
+/-- A prime `p` is a unit in a finite commutative ring `R`
+iff it does not divide the characteristic. -/
+lemma is_unit_iff_not_dvd_char (R : Type*) [comm_ring R] (p : ℕ) [fact p.prime] [finite R] :
+  is_unit (p : R) ↔ ¬ p ∣ ring_char R :=
+is_unit_iff_not_dvd_char_of_ring_char_ne_zero R p $ char_p.char_ne_zero_of_finite R (ring_char R)
+
 /-- The prime divisors of the characteristic of a finite commutative ring are exactly
 the prime divisors of its cardinality. -/
 lemma prime_dvd_char_iff_dvd_card {R : Type*} [comm_ring R] [fintype R] (p : ℕ) [fact p.prime] :

formal/lean/mathlib/algebra/direct_sum/internal.lean

@@ -152,8 +152,7 @@ lemma direct_sum.coe_mul_apply [add_monoid ι] [semiring R] [set_like σ R]
   [add_submonoid_class σ R] (A : ι → σ) [set_like.graded_monoid A]
   [Π (i : ι) (x : A i), decidable (x ≠ 0)] (r r' : ⨁ i, A i) (i : ι) :
   ((r * r') i : R) =
-    ∑ ij in finset.filter (λ ij : ι × ι, ij.1 + ij.2 = i) (r.support.product r'.support),
-      r ij.1 * r' ij.2 :=
+    ∑ ij in (r.support ×ˢ r'.support).filter (λ ij : ι × ι, ij.1 + ij.2 = i), r ij.1 * r' ij.2 :=
 begin
   rw [direct_sum.mul_eq_sum_support_ghas_mul, dfinsupp.finset_sum_apply,
     add_submonoid_class.coe_finset_sum],

formal/lean/mathlib/algebra/direct_sum/ring.lean

@@ -269,7 +269,7 @@ open_locale big_operators
 lemma mul_eq_sum_support_ghas_mul
   [Π (i : ι) (x : A i), decidable (x ≠ 0)] (a a' : ⨁ i, A i) :
   a * a' =
-    ∑ (ij : ι × ι) in (dfinsupp.support a).product (dfinsupp.support a'),
+    ∑ ij in dfinsupp.support a ×ˢ dfinsupp.support a',
       direct_sum.of _ _ (graded_monoid.ghas_mul.mul (a ij.fst) (a' ij.snd)) :=
 begin
   change direct_sum.mul_hom _ a a' = _,

formal/lean/mathlib/algebra/field/basic.lean

@@ -144,36 +144,8 @@ by rwa [add_comm, add_div', add_comm]
 
 end division_semiring
 
-section division_ring
-variables [division_ring K] {a b : K}
-
-namespace rat
-
-/-- Construct the canonical injection from `ℚ` into an arbitrary
-  division ring. If the field has positive characteristic `p`,
-  we define `1 / p = 1 / 0 = 0` for consistency with our
-  division by zero convention. -/
--- see Note [coercion into rings]
-@[priority 900] instance cast_coe {K : Type*} [has_rat_cast K] : has_coe_t ℚ K :=
-⟨has_rat_cast.rat_cast⟩
-
-theorem cast_mk' (a b h1 h2) : ((⟨a, b, h1, h2⟩ : ℚ) : K) = a * b⁻¹ :=
-division_ring.rat_cast_mk _ _ _ _
-
-theorem cast_def : ∀ (r : ℚ), (r : K) = r.num / r.denom
-| ⟨a, b, h1, h2⟩ := (cast_mk' _ _ _ _).trans (div_eq_mul_inv _ _).symm
-
-@[priority 100]
-instance smul_division_ring : has_smul ℚ K :=
-⟨division_ring.qsmul⟩
-
-lemma smul_def (a : ℚ) (x : K) : a • x = ↑a * x := division_ring.qsmul_eq_mul' a x
-
-end rat
-
-local attribute [simp]
-  division_def mul_comm mul_assoc
-  mul_left_comm mul_inv_cancel inv_mul_cancel
+section division_monoid
+variables [division_monoid K] [has_distrib_neg K] {a b : K}
 
 lemma one_div_neg_one_eq_neg_one : (1:K) / (-1) = -1 :=
 have (-1) * (-1) = (1:K), by rw [neg_mul_neg, one_mul],
@@ -202,6 +174,44 @@ by simp [neg_div]
 lemma neg_div_neg_eq (a b : K) : (-a) / (-b) = a / b :=
 by rw [div_neg_eq_neg_div, neg_div, neg_neg]
 
+lemma neg_inv : - a⁻¹ = (- a)⁻¹ :=
+by rw [inv_eq_one_div, inv_eq_one_div, div_neg_eq_neg_div]
+
+lemma div_neg (a : K) : a / -b = -(a / b) :=
+by rw [← div_neg_eq_neg_div]
+
+lemma inv_neg : (-a)⁻¹ = -(a⁻¹) :=
+by rw neg_inv
+
+end division_monoid
+
+section division_ring
+variables [division_ring K] {a b : K}
+
+namespace rat
+
+/-- Construct the canonical injection from `ℚ` into an arbitrary
+  division ring. If the field has positive characteristic `p`,
+  we define `1 / p = 1 / 0 = 0` for consistency with our
+  division by zero convention. -/
+-- see Note [coercion into rings]
+@[priority 900] instance cast_coe {K : Type*} [has_rat_cast K] : has_coe_t ℚ K :=
+⟨has_rat_cast.rat_cast⟩
+
+theorem cast_mk' (a b h1 h2) : ((⟨a, b, h1, h2⟩ : ℚ) : K) = a * b⁻¹ :=
+division_ring.rat_cast_mk _ _ _ _
+
+theorem cast_def : ∀ (r : ℚ), (r : K) = r.num / r.denom
+| ⟨a, b, h1, h2⟩ := (cast_mk' _ _ _ _).trans (div_eq_mul_inv _ _).symm
+
+@[priority 100]
+instance smul_division_ring : has_smul ℚ K :=
+⟨division_ring.qsmul⟩
+
+lemma smul_def (a : ℚ) (x : K) : a • x = ↑a * x := division_ring.qsmul_eq_mul' a x
+
+end rat
+
 @[simp] lemma div_neg_self {a : K} (h : a ≠ 0) : a / -a = -1 :=
 by rw [div_neg_eq_neg_div, div_self h]
 
@@ -221,18 +231,9 @@ by simpa only [← @div_self _ _ b h] using (div_sub_div_same a b b).symm
 
 lemma div_sub_one {a b : K} (h : b ≠ 0) : a / b - 1 = (a - b) / b := (div_sub_same h).symm
 
-lemma neg_inv : - a⁻¹ = (- a)⁻¹ :=
-by rw [inv_eq_one_div, inv_eq_one_div, div_neg_eq_neg_div]
-
 lemma sub_div (a b c : K) : (a - b) / c = a / c - b / c :=
 (div_sub_div_same _ _ _).symm
 
-lemma div_neg (a : K) : a / -b = -(a / b) :=
-by rw [← div_neg_eq_neg_div]
-
-lemma inv_neg : (-a)⁻¹ = -(a⁻¹) :=
-by rw neg_inv
-
 lemma one_div_mul_sub_mul_one_div_eq_one_div_add_one_div (ha : a ≠ 0) (hb : b ≠ 0) :
           (1 / a) * (b - a) * (1 / b) = 1 / a - 1 / b :=
 by rw [(mul_sub_left_distrib (1 / a)), (one_div_mul_cancel ha), mul_sub_right_distrib,

formal/lean/mathlib/algebra/field_power.lean

@@ -48,19 +48,11 @@ lemma zpow_pos_of_pos (ha : 0 < a) : ∀ (z : ℤ), 0 < a ^ z
 
 lemma zpow_le_of_le (ha : 1 ≤ a) (h : m ≤ n) : a ^ m ≤ a ^ n :=
 begin
-  induction m with m m; induction n with n n,
-  { simp only [of_nat_eq_coe, zpow_coe_nat],
-    exact pow_le_pow ha (le_of_coe_nat_le_coe_nat h) },
-  { cases h.not_lt ((neg_succ_lt_zero _).trans_le $ of_nat_nonneg _) },
-  { simp only [zpow_neg_succ_of_nat, one_div, of_nat_eq_coe, zpow_coe_nat],
-    apply le_trans (inv_le_one _); apply one_le_pow_of_one_le ha },
-  { simp only [zpow_neg_succ_of_nat],
-    apply (inv_le_inv _ _).2,
-    { apply pow_le_pow ha,
-      have : -(↑(m+1) : ℤ) ≤ -(↑(n+1) : ℤ), from h,
-      have h' := le_of_neg_le_neg this,
-      apply le_of_coe_nat_le_coe_nat h' },
-    repeat { apply pow_pos (zero_lt_one.trans_le ha) } }
+  have ha₀ : 0 < a, from one_pos.trans_le ha,
+  lift n - m to ℕ using sub_nonneg.2 h with k hk,
+  calc a ^ m = a ^ m * 1 : (mul_one _).symm
+  ... ≤ a ^ m * a ^ k : mul_le_mul_of_nonneg_left (one_le_pow_of_one_le ha _) (zpow_nonneg ha₀.le _)
+  ... = a ^ n : by rw [← zpow_coe_nat, ← zpow_add₀ ha₀.ne', hk, add_sub_cancel'_right]
 end
 
 lemma pow_le_max_of_min_le (hx : 1 ≤ x) {a b c : ℤ} (h : min a b ≤ c) :
@@ -159,17 +151,7 @@ lemma zpow_two_pos_of_ne_zero (h : a ≠ 0) : 0 < a ^ (2 : ℤ) := zpow_bit0_pos
 le_iff_le_iff_lt_iff_lt.2 zpow_bit1_neg_iff
 
 @[simp] theorem zpow_bit1_nonpos_iff : a ^ bit1 n ≤ 0 ↔ a ≤ 0 :=
-begin
-  rw [le_iff_lt_or_eq, zpow_bit1_neg_iff],
-  split,
-  { rintro (h | h),
-    { exact h.le },
-    { exact (zpow_eq_zero h).le } },
-  { intro h,
-    rcases eq_or_lt_of_le h with rfl|h,
-    { exact or.inr (zero_zpow _ (bit1_ne_zero n)) },
-    { exact or.inl h } }
-end
+by rw [le_iff_lt_or_eq, le_iff_lt_or_eq, zpow_bit1_neg_iff, zpow_eq_zero_iff (bit1_ne_zero n)]
 
 @[simp] theorem zpow_bit1_pos_iff : 0 < a ^ bit1 n ↔ 0 < a :=
 lt_iff_lt_of_le_iff_le zpow_bit1_nonpos_iff

formal/lean/mathlib/algebra/group/prod.lean

@@ -495,7 +495,7 @@ open mul_opposite
 /-- Canonical homomorphism of monoids from `αˣ` into `α × αᵐᵒᵖ`.
 Used mainly to define the natural topology of `αˣ`. -/
 @[to_additive "Canonical homomorphism of additive monoids from `add_units α` into `α × αᵃᵒᵖ`.
-Used mainly to define the natural topology of `add_units α`."]
+Used mainly to define the natural topology of `add_units α`.", simps]
 def embed_product (α : Type*) [monoid α] : αˣ →* α × αᵐᵒᵖ :=
 { to_fun := λ x, ⟨x, op ↑x⁻¹⟩,
   map_one' := by simp only [inv_one, eq_self_iff_true, units.coe_one, op_one, prod.mk_eq_one,

formal/lean/mathlib/algebra/group/to_additive.lean

@@ -219,6 +219,8 @@ meta def tr : bool → list string → list string
 | is_comm ("npow" :: s)               := add_comm_prefix is_comm "nsmul"     :: tr ff s
 | is_comm ("zpow" :: s)               := add_comm_prefix is_comm "zsmul"     :: tr ff s
 | is_comm ("is" :: "square" :: s)     := add_comm_prefix is_comm "even"      :: tr ff s
+| is_comm ("is" :: "scalar" :: "tower" :: s) :=
+   add_comm_prefix is_comm "vadd_assoc_class"   :: tr ff s
 | is_comm ("is" :: "regular" :: s)    := add_comm_prefix is_comm "is_add_regular"   :: tr ff s
 | is_comm ("is" :: "left" :: "regular" :: s)  :=
   add_comm_prefix is_comm "is_add_left_regular"  :: tr ff s

formal/lean/mathlib/algebra/group/units.lean

@@ -1,7 +1,7 @@
 /-
 Copyright (c) 2017 Kenny Lau. All rights reserved.
 Released under Apache 2.0 license as described in the file LICENSE.
-Authors: Kenny Lau, Mario Carneiro, Johannes Hölzl, Chris Hughes, Jens Wagemaker
+Authors: Kenny Lau, Mario Carneiro, Johannes Hölzl, Chris Hughes, Jens Wagemaker, Jon Eugster
 -/
 import algebra.group.basic
 import logic.nontrivial
@@ -250,6 +250,10 @@ infix ` /ₚ `:70 := divp
 theorem divp_assoc (a b : α) (u : αˣ) : a * b /ₚ u = a * (b /ₚ u) :=
 mul_assoc _ _ _
 
+/-- `field_simp` needs the reverse direction of `divp_assoc` to move all `/ₚ` to the right. -/
+@[field_simps] lemma divp_assoc' (x y : α) (u : αˣ) : x * (y /ₚ u) = (x * y) /ₚ u :=
+(divp_assoc _ _ _).symm
+
 @[simp] theorem divp_inv (u : αˣ) : a /ₚ u⁻¹ = a * u := rfl
 
 @[simp] theorem divp_mul_cancel (a : α) (u : αˣ) : a /ₚ u * u = a :=
@@ -261,31 +265,60 @@ mul_assoc _ _ _
 @[simp] theorem divp_left_inj (u : αˣ) {a b : α} : a /ₚ u = b /ₚ u ↔ a = b :=
 units.mul_left_inj _
 
-theorem divp_divp_eq_divp_mul (x : α) (u₁ u₂ : αˣ) : (x /ₚ u₁) /ₚ u₂ = x /ₚ (u₂ * u₁) :=
+@[field_simps] theorem divp_divp_eq_divp_mul (x : α) (u₁ u₂ : αˣ) :
+  (x /ₚ u₁) /ₚ u₂ = x /ₚ (u₂ * u₁) :=
 by simp only [divp, mul_inv_rev, units.coe_mul, mul_assoc]
 
-theorem divp_eq_iff_mul_eq {x : α} {u : αˣ} {y : α} : x /ₚ u = y ↔ y * u = x :=
+@[field_simps] theorem divp_eq_iff_mul_eq {x : α} {u : αˣ} {y : α} : x /ₚ u = y ↔ y * u = x :=
 u.mul_left_inj.symm.trans $ by rw [divp_mul_cancel]; exact ⟨eq.symm, eq.symm⟩
 
+@[field_simps] theorem eq_divp_iff_mul_eq {x : α} {u : αˣ} {y : α} : x = y /ₚ u ↔ x * u = y :=
+by rw [eq_comm, divp_eq_iff_mul_eq]
+
 theorem divp_eq_one_iff_eq {a : α} {u : αˣ} : a /ₚ u = 1 ↔ a = u :=
 (units.mul_left_inj u).symm.trans $ by rw [divp_mul_cancel, one_mul]
 
 @[simp] theorem one_divp (u : αˣ) : 1 /ₚ u = ↑u⁻¹ :=
 one_mul _
 
+/-- Used for `field_simp` to deal with inverses of units. -/
+@[field_simps] lemma inv_eq_one_divp (u : αˣ) : ↑u⁻¹ = 1 /ₚ u :=
+by rw one_divp
+
+/--
+Used for `field_simp` to deal with inverses of units. This form of the lemma
+is essential since `field_simp` likes to use `inv_eq_one_div` to rewrite
+`↑u⁻¹ = ↑(1 / u)`.
+-/
+@[field_simps] lemma inv_eq_one_divp' (u : αˣ) :
+  ((1 / u : αˣ) : α) = 1 /ₚ u :=
+by rw [one_div, one_divp]
+
+/--
+`field_simp` moves division inside `αˣ` to the right, and this lemma
+lifts the calculation to `α`.
+-/
+@[field_simps] lemma coe_div_eq_divp (u₁ u₂ : αˣ) : ↑(u₁ / u₂) = ↑u₁ /ₚ u₂ :=
+by rw [divp, division_def, units.coe_mul]
+
 end monoid
 
 section comm_monoid
 
 variables [comm_monoid α]
 
-theorem divp_eq_divp_iff {x y : α} {ux uy : αˣ} :
+@[field_simps] theorem divp_mul_eq_mul_divp (x y : α) (u : αˣ) : x /ₚ u * y = x * y /ₚ u :=
+by simp_rw [divp, mul_assoc, mul_comm]
+
+-- Theoretically redundant as `field_simp` lemma.
+@[field_simps] lemma divp_eq_divp_iff {x y : α} {ux uy : αˣ} :
   x /ₚ ux = y /ₚ uy ↔ x * uy = y * ux :=
-by rw [divp_eq_iff_mul_eq, mul_comm, ← divp_assoc, divp_eq_iff_mul_eq, mul_comm y ux]
+by rw [divp_eq_iff_mul_eq, divp_mul_eq_mul_divp, divp_eq_iff_mul_eq]
 
-theorem divp_mul_divp (x y : α) (ux uy : αˣ) :
+-- Theoretically redundant as `field_simp` lemma.
+@[field_simps] lemma divp_mul_divp (x y : α) (ux uy : αˣ) :
   (x /ₚ ux) * (y /ₚ uy) = (x * y) /ₚ (ux * uy) :=
-by rw [← divp_divp_eq_divp_mul, divp_assoc, mul_comm x, divp_assoc, mul_comm]
+by rw [divp_mul_eq_mul_divp, divp_assoc', divp_divp_eq_divp_mul]
 
 end comm_monoid
 

formal/lean/mathlib/algebra/group_with_zero/power.lean

@@ -134,13 +134,9 @@ by rw [zpow_bit1₀, (commute.refl a).mul_zpow]
 lemma zpow_eq_zero {x : G₀} {n : ℤ} (h : x ^ n = 0) : x = 0 :=
 classical.by_contradiction $ λ hx, zpow_ne_zero_of_ne_zero hx n h
 
-lemma zpow_eq_zero_iff {a : G₀} {n : ℤ} (hn : 0 < n) :
+lemma zpow_eq_zero_iff {a : G₀} {n : ℤ} (hn : n ≠ 0) :
   a ^ n = 0 ↔ a = 0 :=
-begin
-  refine ⟨zpow_eq_zero, _⟩,
-  rintros rfl,
-  exact zero_zpow _ hn.ne'
-end
+⟨zpow_eq_zero, λ ha, ha.symm ▸ zero_zpow _ hn⟩
 
 lemma zpow_ne_zero {x : G₀} (n : ℤ) : x ≠ 0 → x ^ n ≠ 0 :=
 mt zpow_eq_zero

formal/lean/mathlib/algebra/hom/equiv.lean

@@ -729,3 +729,16 @@ def mul_equiv.to_additive'' [add_zero_class G] [mul_one_class H] :
 add_equiv.to_multiplicative''.symm
 
 end type_tags
+
+section
+variables (G) (H)
+
+/-- `additive (multiplicative G)` is just `G`. -/
+def add_equiv.additive_multiplicative [add_zero_class G] : additive (multiplicative G) ≃+ G :=
+mul_equiv.to_additive'' (mul_equiv.refl (multiplicative G))
+
+/-- `multiplicative (additive H)` is just `H`. -/
+def mul_equiv.multiplicative_additive [mul_one_class H] : multiplicative (additive H) ≃* H :=
+add_equiv.to_multiplicative'' (add_equiv.refl (additive H))
+
+end

formal/lean/mathlib/algebra/hom/group_action.lean

@@ -54,7 +54,7 @@ variables (G : Type*) [group G] (H : subgroup G)
 set_option old_structure_cmd true
 
 /-- Equivariant functions. -/
-@[nolint has_inhabited_instance]
+@[nolint has_nonempty_instance]
 structure mul_action_hom :=
 (to_fun : X → Y)
 (map_smul' : ∀ (m : M') (x : X), to_fun (m • x) = m • to_fun x)
@@ -258,7 +258,7 @@ end semiring
 end distrib_mul_action_hom
 
 /-- Equivariant ring homomorphisms. -/
-@[nolint has_inhabited_instance]
+@[nolint has_nonempty_instance]
 structure mul_semiring_action_hom extends R →+[M] S, R →+* S.
 
 /-- Reinterpret an equivariant ring homomorphism as a ring homomorphism. -/

formal/lean/mathlib/algebra/hom/group_instances.lean

@@ -69,10 +69,24 @@ instance [add_comm_monoid M] : semiring (add_monoid.End M) :=
   .. add_monoid.End.monoid M,
   .. add_monoid_hom.add_comm_monoid }
 
+/-- See also `add_monoid.End.nat_cast_def`. -/
+@[simp] lemma add_monoid.End.nat_cast_apply [add_comm_monoid M] (n : ℕ) (m : M) :
+  (↑n : add_monoid.End M) m = n • m := rfl
+
+instance [add_comm_group M] : add_comm_group (add_monoid.End M) :=
+add_monoid_hom.add_comm_group
+
 instance [add_comm_group M] : ring (add_monoid.End M) :=
-{ .. add_monoid.End.semiring,
+{ int_cast := λ z, z • 1,
+  int_cast_of_nat := of_nat_zsmul _,
+  int_cast_neg_succ_of_nat  := zsmul_neg_succ_of_nat _,
+  .. add_monoid.End.semiring,
   .. add_monoid_hom.add_comm_group }
 
+/-- See also `add_monoid.End.int_cast_def`. -/
+@[simp] lemma add_monoid.End.int_cast_apply [add_comm_group M] (z : ℤ) (m : M) :
+  (↑z : add_monoid.End M) m = z • m := rfl
+
 /-!
 ### Morphisms of morphisms
 
@@ -208,7 +222,8 @@ variables {R S : Type*} [non_unital_non_assoc_semiring R] [non_unital_non_assoc_
 
 This is a more-strongly bundled version of `add_monoid_hom.mul_left` and `add_monoid_hom.mul_right`.
 
-A stronger version of this exists for algebras as `algebra.lmul`.
+Stronger versions of this exists for algebras as `linear_map.mul`, `non_unital_alg_hom.mul`
+and `algebra.lmul`.
 -/
 def add_monoid_hom.mul : R →+ R →+ R :=
 { to_fun := add_monoid_hom.mul_left,

formal/lean/mathlib/algebra/hom/ring.lean

@@ -413,6 +413,10 @@ mt f.codomain_trivial_iff_map_one_eq_zero.mpr zero_ne_one
 lemma domain_nontrivial [nontrivial β] : nontrivial α :=
 ⟨⟨1, 0, mt (λ h, show f 1 = 0, by rw [h, map_zero]) f.map_one_ne_zero⟩⟩
 
+lemma codomain_trivial (f : α →+* β) [h : subsingleton α] : subsingleton β :=
+(subsingleton_or_nontrivial β).resolve_right
+  (λ _, by exactI not_nontrivial_iff_subsingleton.mpr h f.domain_nontrivial)
+
 end
 
 /-- Ring homomorphisms preserve additive inverse. -/

formal/lean/mathlib/algebra/hom/units.lean

@@ -76,7 +76,7 @@ variables [division_monoid α]
 @[simp, norm_cast, to_additive] lemma coe_zpow : ∀ (u : αˣ) (n : ℤ), ((u ^ n : αˣ) : α) = u ^ n :=
 (units.coe_hom α).map_zpow
 
-lemma _root_.divp_eq_div (a : α) (u : αˣ) : a /ₚ u = a / u :=
+@[field_simps] lemma _root_.divp_eq_div (a : α) (u : αˣ) : a /ₚ u = a / u :=
 by rw [div_eq_mul_inv, divp, u.coe_inv]
 
 end division_monoid

formal/lean/mathlib/algebra/homology/complex_shape.lean

@@ -55,7 +55,7 @@ This means that the shape consists of some union of lines, rays, intervals, and
 
 Below we define `c.next` and `c.prev` which provide these related elements.
 -/
-@[ext, nolint has_inhabited_instance]
+@[ext, nolint has_nonempty_instance]
 structure complex_shape (ι : Type*) :=
 (rel : ι → ι → Prop)
 (next_eq : ∀ {i j j'}, rel i j → rel i j' → j = j')

formal/lean/mathlib/algebra/homology/homological_complex.lean

@@ -27,7 +27,7 @@ and similarly `cochain_complex V α`, with `i = j + 1`.
 There is a category structure, where morphisms are chain maps.
 
 For `C : homological_complex V c`, we define `C.X_next i`, which is either `C.X j` for some
-arbitrarily chosen `j` such that `c.r i j`, or the zero object if there is no such `j`.
+arbitrarily chosen `j` such that `c.r i j`, or `C.X i` if there is no such `j`.
 Similarly we have `C.X_prev j`.
 Defined in terms of these we have `C.d_from i : C.X i ⟶ C.X_next i` and
 `C.d_to j : C.X_prev j ⟶ C.X j`, which are either defined as `C.d i j`, or zero, as needed.
@@ -299,7 +299,7 @@ def X_prev_iso {i j : ι} (r : c.rel i j) :
 eq_to_iso $ by rw ← c.prev_eq' r
 
 /-- If there is no `i` so `c.rel i j`, then `C.X_prev j` is isomorphic to `C.X j`. -/
-def X_prev_iso_zero {j : ι} (h : ¬c.rel (c.prev j) j) :
+def X_prev_iso_self {j : ι} (h : ¬c.rel (c.prev j) j) :
   C.X_prev j ≅ C.X j :=
 eq_to_iso $ congr_arg C.X begin
   dsimp [complex_shape.prev],
@@ -308,7 +308,7 @@ eq_to_iso $ congr_arg C.X begin
   rw this at h, contradiction,
 end
 
-/-- Either `C.X j`, if there is some `j` with `c.rel i j`, or `C.X j`. -/
+/-- Either `C.X j`, if there is some `j` with `c.rel i j`, or `C.X i`. -/
 abbreviation X_next (i : ι) : V := C.X (c.next i)
 
 /-- If `c.rel i j`, then `C.X_next i` is isomorphic to `C.X j`. -/
@@ -316,8 +316,8 @@ def X_next_iso {i j : ι} (r : c.rel i j) :
   C.X_next i ≅ C.X j :=
 eq_to_iso $ by rw ← c.next_eq' r
 
-/-- If there is no `j` so `c.rel i j`, then `C.X_next i` is isomorphic to `0`. -/
-def X_next_iso_zero {i : ι} (h : ¬c.rel i (c.next i)) :
+/-- If there is no `j` so `c.rel i j`, then `C.X_next i` is isomorphic to `C.X i`. -/
+def X_next_iso_self {i : ι} (h : ¬c.rel i (c.next i)) :
   C.X_next i ≅ C.X i :=
 eq_to_iso $ congr_arg C.X begin
   dsimp [complex_shape.next],
@@ -364,16 +364,16 @@ C.shape _ _ h
   (C.X_prev_iso r).inv ≫ C.d_to j = C.d i j :=
 by simp [C.d_to_eq r]
 
-@[simp, reassoc] lemma X_prev_iso_zero_comp_d_to {j : ι} (h : ¬c.rel (c.prev j) j) :
-  (C.X_prev_iso_zero h).inv ≫ C.d_to j = 0 :=
+@[simp, reassoc] lemma X_prev_iso_self_comp_d_to {j : ι} (h : ¬c.rel (c.prev j) j) :
+  (C.X_prev_iso_self h).inv ≫ C.d_to j = 0 :=
 by simp [h]
 
 @[simp, reassoc] lemma d_from_comp_X_next_iso {i j : ι} (r : c.rel i j) :
   C.d_from i ≫ (C.X_next_iso r).hom = C.d i j :=
 by simp [C.d_from_eq r]
 
-@[simp, reassoc] lemma d_from_comp_X_next_iso_zero {i : ι} (h : ¬c.rel i (c.next i)) :
-  C.d_from i ≫ (C.X_next_iso_zero h).hom = 0 :=
+@[simp, reassoc] lemma d_from_comp_X_next_iso_self {i : ι} (h : ¬c.rel i (c.next i)) :
+  C.d_from i ≫ (C.X_next_iso_self h).hom = 0 :=
 by simp [h]
 
 @[simp]
@@ -430,7 +430,7 @@ by { ext, simp, }
 
 /-! Lemmas relating chain maps and `d_to`/`d_from`. -/
 
-/-- `f.prev j` is `f.f i` if there is some `r i j`, and zero otherwise. -/
+/-- `f.prev j` is `f.f i` if there is some `r i j`, and `f.f j` otherwise. -/
 abbreviation prev (f : hom C₁ C₂) (j : ι) : C₁.X_prev j ⟶ C₂.X_prev j := f.f _
 
 lemma prev_eq (f : hom C₁ C₂) {i j : ι} (w : c.rel i j) :
@@ -440,7 +440,7 @@ begin
   simp only [X_prev_iso, eq_to_iso_refl, iso.refl_hom, iso.refl_inv, id_comp, comp_id],
 end
 
-/-- `f.next i` is `f.f j` if there is some `r i j`, and zero otherwise. -/
+/-- `f.next i` is `f.f j` if there is some `r i j`, and `f.f j` otherwise. -/
 abbreviation next (f : hom C₁ C₂) (i : ι) : C₁.X_next i ⟶ C₂.X_next i := f.f _
 
 lemma next_eq (f : hom C₁ C₂) {i j : ι} (w : c.rel i j) :
@@ -552,7 +552,7 @@ Auxiliary structure for setting up the recursion in `mk`.
 This is purely an implementation detail: for some reason just using the dependent 6-tuple directly
 results in `mk_aux` taking much longer (well over the `-T100000` limit) to elaborate.
 -/
-@[nolint has_inhabited_instance]
+@[nolint has_nonempty_instance]
 structure mk_struct :=
 (X₀ X₁ X₂ : V)
 (d₀ : X₁ ⟶ X₀)
@@ -745,7 +745,7 @@ Auxiliary structure for setting up the recursion in `mk`.
 This is purely an implementation detail: for some reason just using the dependent 6-tuple directly
 results in `mk_aux` taking much longer (well over the `-T100000` limit) to elaborate.
 -/
-@[nolint has_inhabited_instance]
+@[nolint has_nonempty_instance]
 structure mk_struct :=
 (X₀ X₁ X₂ : V)
 (d₀ : X₀ ⟶ X₁)

formal/lean/mathlib/algebra/homology/homotopy.lean

@@ -113,7 +113,7 @@ end
 A homotopy `h` between chain maps `f` and `g` consists of components `h i j : C.X i ⟶ D.X j`
 which are zero unless `c.rel j i`, satisfying the homotopy condition.
 -/
-@[ext, nolint has_inhabited_instance]
+@[ext, nolint has_nonempty_instance]
 structure homotopy (f g : C ⟶ D) :=
 (hom : Π i j, C.X i ⟶ D.X j)
 (zero' : ∀ i j, ¬ c.rel j i → hom i j = 0 . obviously)

formal/lean/mathlib/algebra/homology/short_exact/preadditive.lean

@@ -167,7 +167,7 @@ end preadditive
 /-- A *splitting* of a sequence `A -f⟶ B -g⟶ C` is an isomorphism
 to the short exact sequence `0 ⟶ A ⟶ A ⊞ C ⟶ C ⟶ 0` such that
 the vertical maps on the left and the right are the identity. -/
-@[nolint has_inhabited_instance]
+@[nolint has_nonempty_instance]
 structure splitting [has_zero_morphisms 𝒜] [has_binary_biproducts 𝒜] :=
 (iso : B ≅ A ⊞ C)
 (comp_iso_eq_inl : f ≫ iso.hom = biprod.inl)

formal/lean/mathlib/algebra/indicator_function.lean

@@ -457,12 +457,8 @@ lemma inter_indicator_one {s t : set α} :
 funext (λ _, by simpa only [← inter_indicator_mul, pi.mul_apply, pi.one_apply, one_mul])
 
 lemma indicator_prod_one {s : set α} {t : set β} {x : α} {y : β} :
-  (s ×ˢ t : set _).indicator (1 : _ → M) (x, y) = s.indicator 1 x * t.indicator 1 y :=
-begin
-  letI := classical.dec_pred (∈ s),
-  letI := classical.dec_pred (∈ t),
-  simp [indicator_apply, ← ite_and],
-end
+  (s ×ˢ t).indicator (1 : _ → M) (x, y) = s.indicator 1 x * t.indicator 1 y :=
+by { classical, simp [indicator_apply, ←ite_and] }
 
 variables (M) [nontrivial M]
 

formal/lean/mathlib/algebra/lie/base_change.lean

@@ -40,7 +40,7 @@ support in the tensor product library, it is far easier to bootstrap like this,
 definition below. -/
 private def bracket' : (A ⊗[R] L) →ₗ[R] (A ⊗[R] L) →ₗ[R] A ⊗[R] L :=
 tensor_product.curry $
-  (tensor_product.map (algebra.lmul' R) (lie_module.to_module_hom R L L : L ⊗[R] L →ₗ[R] L))
+  (tensor_product.map (linear_map.mul' R _) (lie_module.to_module_hom R L L : L ⊗[R] L →ₗ[R] L))
   ∘ₗ ↑(tensor_product.tensor_tensor_tensor_comm R A L A L)
 
 @[simp] private lemma bracket'_tmul (s t : A) (x y : L) :
@@ -115,8 +115,8 @@ begin
     { simp only [lie_zero, smul_zero], },
     { intros a₂ l₂,
       simp only [bracket_def, bracket', tensor_product.smul_tmul', mul_left_comm a₁ a a₂,
-        tensor_product.curry_apply, algebra.lmul'_apply, algebra.id.smul_eq_mul, function.comp_app,
-        linear_equiv.coe_coe, linear_map.coe_comp, tensor_product.map_tmul,
+        tensor_product.curry_apply, linear_map.mul'_apply, algebra.id.smul_eq_mul,
+        function.comp_app, linear_equiv.coe_coe, linear_map.coe_comp, tensor_product.map_tmul,
         tensor_product.tensor_tensor_tensor_comm_tmul], },
     { intros z₁ z₂ h₁ h₂,
       simp only [h₁, h₂, smul_add, lie_add], }, },

formal/lean/mathlib/algebra/lie/nilpotent.lean

@@ -691,9 +691,12 @@ lemma lie_algebra.ad_nilpotent_of_nilpotent {a : A} (h : is_nilpotent a) :
   is_nilpotent (lie_algebra.ad R A a) :=
 begin
   rw lie_algebra.ad_eq_lmul_left_sub_lmul_right,
-  have hl : is_nilpotent (algebra.lmul_left R a), { rwa algebra.is_nilpotent_lmul_left_iff, },
-  have hr : is_nilpotent (algebra.lmul_right R a), { rwa algebra.is_nilpotent_lmul_right_iff, },
-  exact (algebra.commute_lmul_left_right R a a).is_nilpotent_sub hl hr,
+  have hl : is_nilpotent (linear_map.mul_left R a),
+  { rwa linear_map.is_nilpotent_mul_left_iff, },
+  have hr : is_nilpotent (linear_map.mul_right R a),
+  { rwa linear_map.is_nilpotent_mul_right_iff, },
+  have := @linear_map.commute_mul_left_right R A _ _ _ _ _ a a,
+  exact this.is_nilpotent_sub hl hr,
 end
 
 variables {R}

formal/lean/mathlib/algebra/lie/of_associative.lean

@@ -234,7 +234,7 @@ end lie_submodule
 open lie_algebra
 
 lemma lie_algebra.ad_eq_lmul_left_sub_lmul_right (A : Type v) [ring A] [algebra R A] :
-  (ad R A : A → module.End R A) = algebra.lmul_left R - algebra.lmul_right R :=
+  (ad R A : A → module.End R A) = linear_map.mul_left R - linear_map.mul_right R :=
 by { ext a b, simp [lie_ring.of_associative_ring_bracket], }
 
 lemma lie_subalgebra.ad_comp_incl_eq (K : lie_subalgebra R L) (x : K) :

formal/lean/mathlib/algebra/module/basic.lean

@@ -71,6 +71,9 @@ instance add_comm_monoid.nat_module : module ℕ M :=
   zero_smul := zero_nsmul,
   add_smul := λ r s x, add_nsmul x r s }
 
+lemma add_monoid.End.nat_cast_def (n : ℕ) :
+  (↑n : add_monoid.End M) = distrib_mul_action.to_add_monoid_End ℕ M n := rfl
+
 theorem add_smul : (r + s) • x = r • x + s • x := module.add_smul r s x
 
 lemma convex.combo_self {a b : R} (h : a + b = 1) (x : M) : a • x + b • x = x :=
@@ -197,11 +200,14 @@ instance add_comm_group.int_module : module ℤ M :=
   zero_smul := zero_zsmul,
   add_smul := λ r s x, add_zsmul x r s }
 
+lemma add_monoid.End.int_cast_def (z : ℤ) :
+  (↑z : add_monoid.End M) = distrib_mul_action.to_add_monoid_End ℤ M z := rfl
+
 /-- A structure containing most informations as in a module, except the fields `zero_smul`
 and `smul_zero`. As these fields can be deduced from the other ones when `M` is an `add_comm_group`,
 this provides a way to construct a module structure by checking less properties, in
 `module.of_core`. -/
-@[nolint has_inhabited_instance]
+@[nolint has_nonempty_instance]
 structure module.core extends has_smul R M :=
 (smul_add : ∀(r : R) (x y : M), r • (x + y) = r • x + r • y)
 (add_smul : ∀(r s : R) (x : M), (r + s) • x = r • x + s • x)

formal/lean/mathlib/algebra/module/bimodule.lean

@@ -0,0 +1,136 @@
+/-
+Copyright (c) 2022 Oliver Nash. All rights reserved.
+Released under Apache 2.0 license as described in the file LICENSE.
+Authors: Oliver Nash
+-/
+import ring_theory.tensor_product
+
+/-!
+# Bimodules
+
+One frequently encounters situations in which several sets of scalars act on a single space, subject
+to compatibility condition(s). A distinguished instance of this is the theory of bimodules: one has
+two rings `R`, `S` acting on an additive group `M`, with `R` acting covariantly ("on the left")
+and `S` acting contravariantly ("on the right"). The compatibility condition is just:
+`(r • m) • s = r • (m • s)` for all `r : R`, `s : S`, `m : M`.
+
+This situation can be set up in Mathlib as:
+```lean
+variables (R S M : Type*) [ring R] [ring S]
+variables [add_comm_group M] [module R M] [module Sᵐᵒᵖ M] [smul_comm_class R Sᵐᵒᵖ M]
+```
+The key fact is:
+```lean
+example : module (R ⊗[ℕ] Sᵐᵒᵖ) M := tensor_product.algebra.module
+```
+Note that the corresponding result holds for the canonically isomorphic ring `R ⊗[ℤ] Sᵐᵒᵖ` but it is
+preferable to use the `R ⊗[ℕ] Sᵐᵒᵖ` instance since it works without additive inverses.
+
+Bimodules are thus just a special case of `module`s and most of their properties follow from the
+theory of `module`s`. In particular a two-sided submodule of a bimodule is simply a term of type
+`submodule (R ⊗[ℕ] Sᵐᵒᵖ) M`.
+
+This file is a place to collect results which are specific to bimodules.
+
+## Main definitions
+
+ * `subbimodule.mk`
+ * `subbimodule.smul_mem`
+ * `subbimodule.smul_mem'`
+ * `subbimodule.to_submodule`
+ * `subbimodule.to_submodule'`
+
+## Implementation details
+
+For many definitions and lemmas it is preferable to set things up without opposites, i.e., as:
+`[module S M] [smul_comm_class R S M]` rather than `[module Sᵐᵒᵖ M] [smul_comm_class R Sᵐᵒᵖ M]`.
+The corresponding results for opposites then follow automatically and do not require taking
+advantage of the fact that `(Sᵐᵒᵖ)ᵐᵒᵖ` is defeq to `S`.
+
+## TODO
+
+Develop the theory of two-sided ideals, which have type `submodule (R ⊗[ℕ] Rᵐᵒᵖ) R`.
+
+-/
+
+open_locale tensor_product
+
+local attribute [instance] tensor_product.algebra.module
+
+namespace subbimodule
+
+section algebra
+
+variables {R A B M : Type*}
+variables [comm_semiring R] [add_comm_monoid M] [module R M]
+variables [semiring A] [semiring B] [module A M] [module B M]
+variables [algebra R A] [algebra R B]
+variables [is_scalar_tower R A M] [is_scalar_tower R B M]
+variables [smul_comm_class A B M]
+
+/-- A constructor for a subbimodule which demands closure under the two sets of scalars
+individually, rather than jointly via their tensor product.
+
+Note that `R` plays no role but it is convenient to make this generalisation to support the cases
+`R = ℕ` and `R = ℤ` which both show up naturally. See also `base_change`. -/
+@[simps] def mk (p : add_submonoid M)
+  (hA : ∀ (a : A) {m : M}, m ∈ p → a • m ∈ p)
+  (hB : ∀ (b : B) {m : M}, m ∈ p → b • m ∈ p) : submodule (A ⊗[R] B) M :=
+{ carrier := p,
+  smul_mem' := λ ab m, tensor_product.induction_on ab
+   (λ hm, by simpa only [zero_smul] using p.zero_mem)
+   (λ a b hm, by simpa only [tensor_product.algebra.smul_def] using hA a (hB b hm))
+   (λ z w hz hw hm, by simpa only [add_smul] using p.add_mem (hz hm) (hw hm)),
+  .. p }
+
+lemma smul_mem (p : submodule (A ⊗[R] B) M) (a : A) {m : M} (hm : m ∈ p) : a • m ∈ p :=
+begin
+  suffices : a • m = a ⊗ₜ[R] (1 : B) • m, { exact this.symm ▸ p.smul_mem _ hm, },
+  simp [tensor_product.algebra.smul_def],
+end
+
+lemma smul_mem' (p : submodule (A ⊗[R] B) M) (b : B) {m : M} (hm : m ∈ p) : b • m ∈ p :=
+begin
+  suffices : b • m = (1 : A) ⊗ₜ[R] b • m, { exact this.symm ▸ p.smul_mem _ hm, },
+  simp [tensor_product.algebra.smul_def],
+end
+
+/-- If `A` and `B` are also `algebra`s over yet another set of scalars `S` then we may "base change"
+from `R` to `S`. -/
+@[simps] def base_change (S : Type*) [comm_semiring S] [module S M] [algebra S A] [algebra S B]
+  [is_scalar_tower S A M] [is_scalar_tower S B M] (p : submodule (A ⊗[R] B) M) :
+  submodule (A ⊗[S] B) M :=
+mk p.to_add_submonoid (smul_mem p) (smul_mem' p)
+
+/-- Forgetting the `B` action, a `submodule` over `A ⊗[R] B` is just a `submodule` over `A`. -/
+@[simps] def to_submodule (p : submodule (A ⊗[R] B) M) : submodule A M :=
+{ carrier := p,
+  smul_mem' := smul_mem p,
+  .. p }
+
+/-- Forgetting the `A` action, a `submodule` over `A ⊗[R] B` is just a `submodule` over `B`. -/
+@[simps] def to_submodule' (p : submodule (A ⊗[R] B) M) : submodule B M :=
+{ carrier := p,
+  smul_mem' := smul_mem' p,
+  .. p }
+
+end algebra
+
+section ring
+
+variables (R S M : Type*) [ring R] [ring S]
+variables [add_comm_group M] [module R M] [module S M] [smul_comm_class R S M]
+
+/-- A `submodule` over `R ⊗[ℕ] S` is naturally also a `submodule` over the canonically-isomorphic
+ring `R ⊗[ℤ] S`. -/
+@[simps] def to_subbimodule_int (p : submodule (R ⊗[ℕ] S) M) : submodule (R ⊗[ℤ] S) M :=
+base_change ℤ p
+
+/-- A `submodule` over `R ⊗[ℤ] S` is naturally also a `submodule` over the canonically-isomorphic
+ring `R ⊗[ℕ] S`. -/
+@[simps] def to_subbimodule_nat (p : submodule (R ⊗[ℤ] S) M) : submodule (R ⊗[ℕ] S) M :=
+base_change ℕ p
+
+end ring
+
+end subbimodule

formal/lean/mathlib/algebra/module/equiv.lean

@@ -45,13 +45,12 @@ section
 set_option old_structure_cmd true
 
 /-- A linear equivalence is an invertible linear map. -/
-@[nolint has_inhabited_instance]
+@[nolint has_nonempty_instance]
 structure linear_equiv {R : Type*} {S : Type*} [semiring R] [semiring S] (σ : R →+* S)
   {σ' : S →+* R} [ring_hom_inv_pair σ σ'] [ring_hom_inv_pair σ' σ]
   (M : Type*) (M₂ : Type*)
   [add_comm_monoid M] [add_comm_monoid M₂] [module R M] [module S M₂]
   extends linear_map σ M M₂, M ≃+ M₂
-end
 
 attribute [nolint doc_blame] linear_equiv.to_linear_map
 attribute [nolint doc_blame] linear_equiv.to_add_equiv
@@ -60,6 +59,49 @@ notation M ` ≃ₛₗ[`:50 σ `] ` M₂ := linear_equiv σ M M₂
 notation M ` ≃ₗ[`:50 R `] ` M₂ := linear_equiv (ring_hom.id R) M M₂
 notation M ` ≃ₗ⋆[`:50 R `] ` M₂ := linear_equiv (star_ring_end R) M M₂
 
+/-- `semilinear_equiv_class F σ M M₂` asserts `F` is a type of bundled `σ`-semilinear equivs
+`M → M₂`.
+
+See also `linear_equiv_class F R M M₂` for the case where `σ` is the identity map on `R`.
+
+A map `f` between an `R`-module and an `S`-module over a ring homomorphism `σ : R →+* S`
+is semilinear if it satisfies the two properties `f (x + y) = f x + f y` and
+`f (c • x) = (σ c) • f x`. -/
+class semilinear_equiv_class (F : Type*) {R S : out_param Type*} [semiring R] [semiring S]
+  (σ : out_param $ R →+* S) {σ' : out_param $ S →+* R}
+  [ring_hom_inv_pair σ σ'] [ring_hom_inv_pair σ' σ] (M M₂ : out_param Type*)
+  [add_comm_monoid M] [add_comm_monoid M₂] [module R M] [module S M₂]
+  extends add_equiv_class F M M₂ :=
+(map_smulₛₗ : ∀ (f : F) (r : R) (x : M), f (r • x) = (σ r) • f x)
+
+-- `R, S, σ, σ'` become metavars, but it's OK since they are outparams.
+attribute [nolint dangerous_instance] semilinear_equiv_class.to_add_equiv_class
+
+/-- `linear_equiv_class F R M M₂` asserts `F` is a type of bundled `R`-linear equivs `M → M₂`.
+This is an abbreviation for `semilinear_equiv_class F (ring_hom.id R) M M₂`.
+-/
+abbreviation linear_equiv_class (F : Type*) (R M M₂ : out_param Type*)
+  [semiring R] [add_comm_monoid M] [add_comm_monoid M₂] [module R M] [module R M₂] :=
+semilinear_equiv_class F (ring_hom.id R) M M₂
+
+end
+
+namespace semilinear_equiv_class
+
+variables (F : Type*) [semiring R] [semiring S]
+variables [add_comm_monoid M] [add_comm_monoid M₁] [add_comm_monoid M₂]
+variables [module R M] [module S M₂] {σ : R →+* S} {σ' : S →+* R}
+
+-- `σ'` becomes a metavariable, but it's OK since it's an outparam
+@[priority 100, nolint dangerous_instance]
+instance [ring_hom_inv_pair σ σ'] [ring_hom_inv_pair σ' σ] [s : semilinear_equiv_class F σ M M₂] :
+  semilinear_map_class F σ M M₂ :=
+{ coe := (coe : F → M → M₂),
+  coe_injective' := @fun_like.coe_injective F _ _ _,
+  ..s }
+
+end semilinear_equiv_class
+
 namespace linear_equiv
 
 section add_comm_monoid
@@ -101,9 +143,12 @@ lemma to_linear_map_injective :
   (e₁ : M →ₛₗ[σ] M₂) = e₂ ↔ e₁ = e₂ :=
 to_linear_map_injective.eq_iff
 
-instance : semilinear_map_class (M ≃ₛₗ[σ] M₂) σ M M₂ :=
+instance : semilinear_equiv_class (M ≃ₛₗ[σ] M₂) σ M M₂ :=
 { coe := linear_equiv.to_fun,
-  coe_injective' := λ f g h, to_linear_map_injective (fun_like.coe_injective h),
+  inv := linear_equiv.inv_fun,
+  coe_injective' := λ f g h₁ h₂, by { cases f, cases g, congr' },
+  left_inv := linear_equiv.left_inv,
+  right_inv := linear_equiv.right_inv,
   map_add := map_add',
   map_smulₛₗ := map_smul' }
 

formal/lean/mathlib/algebra/module/linear_map.lean

@@ -811,12 +811,26 @@ instance _root_.module.End.semiring : semiring (module.End R M) :=
   zero_mul := zero_comp,
   left_distrib := λ f g h, comp_add _ _ _,
   right_distrib := λ f g h, add_comp _ _ _,
+  nat_cast := λ n, n • 1,
+  nat_cast_zero := add_monoid.nsmul_zero' _,
+  nat_cast_succ := λ n, (add_monoid.nsmul_succ' n 1).trans (add_comm _ _),
   .. add_monoid_with_one.unary,
   .. _root_.module.End.monoid,
   .. linear_map.add_comm_monoid }
 
+/-- See also `module.End.nat_cast_def`. -/
+@[simp] lemma _root_.module.End.nat_cast_apply (n : ℕ) (m : M) :
+  (↑n : module.End R M) m = n • m := rfl
+
 instance _root_.module.End.ring : ring (module.End R N₁) :=
-{ ..module.End.semiring, ..linear_map.add_comm_group }
+{ int_cast := λ z, z • 1,
+  int_cast_of_nat := of_nat_zsmul _,
+  int_cast_neg_succ_of_nat := zsmul_neg_succ_of_nat _,
+  ..module.End.semiring, ..linear_map.add_comm_group }
+
+/-- See also `module.End.int_cast_def`. -/
+@[simp] lemma _root_.module.End.int_cast_apply (z : ℤ) (m : N₁) :
+  (↑z : module.End R N₁) m = z • m := rfl
 
 section
 variables [monoid S] [distrib_mul_action S M] [smul_comm_class R S M]
@@ -930,4 +944,10 @@ def module_End_self_op : R ≃+* module.End Rᵐᵒᵖ R :=
   right_inv := λ f, linear_map.ext_ring_op $ mul_one _,
   ..module.to_module_End _ _ }
 
+lemma End.nat_cast_def (n : ℕ) [add_comm_monoid N₁] [module R N₁] :
+  (↑n : module.End R N₁) = module.to_module_End R N₁ n := rfl
+
+lemma End.int_cast_def (z : ℤ) [add_comm_group N₁] [module R N₁] :
+  (↑z : module.End R N₁) = module.to_module_End R N₁ z := rfl
+
 end module

formal/lean/mathlib/algebra/module/localized_module.lean

@@ -70,7 +70,7 @@ instance r.setoid : setoid (M × S) :=
 If `S` is a multiplicative subset of a ring `R` and `M` an `R`-module, then
 we can localize `M` by `S`.
 -/
-@[nolint has_inhabited_instance]
+@[nolint has_nonempty_instance]
 def _root_.localized_module : Type (max u v) := quotient (r.setoid S M)
 
 section

formal/lean/mathlib/algebra/monoid_algebra/basic.lean

@@ -183,6 +183,8 @@ instance : non_assoc_semiring (monoid_algebra k G) :=
     single_zero, sum_zero, add_zero, mul_one, sum_single],
   ..monoid_algebra.non_unital_non_assoc_semiring }
 
+lemma nat_cast_def (n : ℕ) : (n : monoid_algebra k G) = single 1 n := rfl
+
 end mul_one_class
 
 /-! #### Semiring structure -/
@@ -244,11 +246,16 @@ instance [ring k] [semigroup G] : non_unital_ring (monoid_algebra k G) :=
   .. monoid_algebra.non_unital_semiring }
 
 instance [ring k] [mul_one_class G] : non_assoc_ring (monoid_algebra k G) :=
-{ .. monoid_algebra.add_comm_group,
+{ int_cast                    := λ z, single 1 (z : k),
+  int_cast_of_nat             := λ n, by simpa,
+  int_cast_neg_succ_of_nat    := λ n, by simpa,
+  .. monoid_algebra.add_comm_group,
   .. monoid_algebra.non_assoc_semiring }
 
+lemma int_cast_def [ring k] [mul_one_class G] (z : ℤ) : (z : monoid_algebra k G) = single 1 z := rfl
+
 instance [ring k] [monoid G] : ring (monoid_algebra k G) :=
-{ .. monoid_algebra.non_unital_non_assoc_ring,
+{ .. monoid_algebra.non_assoc_ring,
   .. monoid_algebra.semiring }
 
 instance [comm_ring k] [comm_semigroup G] : non_unital_comm_ring (monoid_algebra k G) :=
@@ -318,8 +325,8 @@ lemma mul_apply_antidiagonal [has_mul G] (f g : monoid_algebra k G) (x : G) (s :
 let F : G × G → k := λ p, by classical; exact if p.1 * p.2 = x then f p.1 * g p.2 else 0 in
 calc (f * g) x = (∑ a₁ in f.support, ∑ a₂ in g.support, F (a₁, a₂)) :
   mul_apply f g x
-... = ∑ p in f.support.product g.support, F p : finset.sum_product.symm
-... = ∑ p in (f.support.product g.support).filter (λ p : G × G, p.1 * p.2 = x), f p.1 * g p.2 :
+... = ∑ p in f.support ×ˢ g.support, F p : finset.sum_product.symm
+... = ∑ p in (f.support ×ˢ g.support).filter (λ p : G × G, p.1 * p.2 = x), f p.1 * g p.2 :
   (finset.sum_filter _ _).symm
 ... = ∑ p in s.filter (λ p : G × G, p.1 ∈ f.support ∧ p.2 ∈ g.support), f p.1 * g p.2 :
   sum_congr (by { ext, simp only [mem_filter, mem_product, hs, and_comm] }) (λ _ _, rfl)
@@ -1029,6 +1036,8 @@ instance : non_assoc_semiring (add_monoid_algebra k G) :=
     single_zero, sum_zero, add_zero, mul_one, sum_single],
   .. add_monoid_algebra.non_unital_non_assoc_semiring }
 
+lemma nat_cast_def (n : ℕ) : (n : add_monoid_algebra k G) = single 0 n := rfl
+
 end mul_one_class
 
 /-! #### Semiring structure -/
@@ -1091,11 +1100,17 @@ instance [ring k] [add_semigroup G] : non_unital_ring (add_monoid_algebra k G) :
   .. add_monoid_algebra.non_unital_semiring }
 
 instance [ring k] [add_zero_class G] : non_assoc_ring (add_monoid_algebra k G) :=
-{ .. add_monoid_algebra.add_comm_group,
+{ int_cast                    := λ z, single 0 (z : k),
+  int_cast_of_nat             := λ n, by simpa,
+  int_cast_neg_succ_of_nat    := λ n, by simpa,
+  .. add_monoid_algebra.add_comm_group,
   .. add_monoid_algebra.non_assoc_semiring }
 
+lemma int_cast_def [ring k] [add_zero_class G] (z : ℤ) :
+  (z : add_monoid_algebra k G) = single 0 z := rfl
+
 instance [ring k] [add_monoid G] : ring (add_monoid_algebra k G) :=
-{ .. add_monoid_algebra.non_unital_non_assoc_ring,
+{ .. add_monoid_algebra.non_assoc_ring,
   .. add_monoid_algebra.semiring }
 
 instance [comm_ring k] [add_comm_semigroup G] : non_unital_comm_ring (add_monoid_algebra k G) :=

formal/lean/mathlib/algebra/monoid_algebra/degree.lean

@@ -0,0 +1,154 @@
+/-
+Copyright (c) 2022 Damiano Testa. All rights reserved.
+Released under Apache 2.0 license as described in the file LICENSE.
+Authors: Damiano Testa
+-/
+import algebra.monoid_algebra.basic
+
+/-!
+# Lemmas about the `sup` and `inf` of the support of `add_monoid_algebra`
+
+## TODO
+The current plan is to state and prove lemmas about `finset.sup (finsupp.support f) D` with a
+"generic" degree/weight function `D` from the grading Type `A` to a somewhat ordered Type `B`.
+
+Next, the general lemmas get specialized for some yet-to-be-defined `degree`s.
+-/
+
+variables {R A T B ι : Type*}
+
+namespace add_monoid_algebra
+open_locale classical big_operators
+
+/-! ### Results about the `finset.sup` and `finset.inf` of `finsupp.support` -/
+
+section general_results_assuming_semilattice_sup
+variables [semilattice_sup B] [order_bot B] [semilattice_inf T] [order_top T]
+
+section semiring
+variables [semiring R]
+
+section explicit_degrees
+/-!
+
+In this section, we use `degb` and `degt` to denote "degree functions" on `A` with values in
+a type with *b*ot or *t*op respectively.
+-/
+variables (degb : A → B) (degt : A → T) (f g : add_monoid_algebra R A)
+
+lemma sup_support_add_le : (f + g).support.sup degb ≤ (f.support.sup degb) ⊔ (g.support.sup degb) :=
+(finset.sup_mono finsupp.support_add).trans_eq finset.sup_union
+
+lemma le_inf_support_add : f.support.inf degt ⊓ g.support.inf degt ≤ (f + g).support.inf degt :=
+sup_support_add_le (λ a : A, order_dual.to_dual (degt a)) f g
+
+end explicit_degrees
+
+section add_only
+variables [has_add A] [has_add B] [has_add T]
+  [covariant_class B B (+) (≤)] [covariant_class B B (function.swap (+)) (≤)]
+  [covariant_class T T (+) (≤)] [covariant_class T T (function.swap (+)) (≤)]
+
+lemma sup_support_mul_le {degb : A → B} (degbm : ∀ {a b}, degb (a + b) ≤ degb a + degb b)
+  (f g : add_monoid_algebra R A) :
+  (f * g).support.sup degb ≤ f.support.sup degb + g.support.sup degb :=
+begin
+  refine (finset.sup_mono $ support_mul _ _).trans _,
+  simp_rw [finset.sup_bUnion, finset.sup_singleton],
+  refine (finset.sup_le $ λ fd fds, finset.sup_le $ λ gd gds, degbm.trans $ add_le_add _ _);
+  exact finset.le_sup ‹_›,
+end
+
+lemma le_inf_support_mul {degt : A → T} (degtm : ∀ {a b}, degt a + degt b ≤ degt (a + b))
+  (f g : add_monoid_algebra R A) :
+  f.support.inf degt + g.support.inf degt ≤ (f * g).support.inf degt :=
+order_dual.of_dual_le_of_dual.mpr $
+  sup_support_mul_le (λ a b, order_dual.of_dual_le_of_dual.mp degtm) f g
+
+end add_only
+
+section add_monoids
+variables [add_monoid A]
+  [add_monoid B] [covariant_class B B (+) (≤)] [covariant_class B B (function.swap (+)) (≤)]
+  [add_monoid T] [covariant_class T T (+) (≤)] [covariant_class T T (function.swap (+)) (≤)]
+  {degb : A → B} {degt : A → T}
+
+lemma sup_support_list_prod_le (degb0 : degb 0 ≤ 0)
+  (degbm : ∀ a b, degb (a + b) ≤ degb a + degb b) :
+  ∀ l : list (add_monoid_algebra R A),
+    l.prod.support.sup degb ≤ (l.map (λ f : add_monoid_algebra R A, f.support.sup degb)).sum
+| [] := begin
+    rw [list.map_nil, finset.sup_le_iff, list.prod_nil, list.sum_nil],
+    exact λ a ha, by rwa [finset.mem_singleton.mp (finsupp.support_single_subset ha)]
+  end
+| (f::fs) := begin
+    rw [list.prod_cons, list.map_cons, list.sum_cons],
+    exact (sup_support_mul_le degbm _ _).trans (add_le_add_left (sup_support_list_prod_le _) _)
+  end
+
+lemma le_inf_support_list_prod (degt0 : 0 ≤ degt 0) (degtm : ∀ a b, degt a + degt b ≤ degt (a + b))
+  (l : list (add_monoid_algebra R A)) :
+  (l.map (λ f : add_monoid_algebra R A, f.support.inf degt)).sum ≤ l.prod.support.inf degt :=
+order_dual.of_dual_le_of_dual.mpr $ sup_support_list_prod_le
+  (order_dual.of_dual_le_of_dual.mp degt0) (λ a b, order_dual.of_dual_le_of_dual.mp (degtm _ _)) l
+
+lemma sup_support_pow_le (degb0 : degb 0 ≤ 0) (degbm : ∀ a b, degb (a + b) ≤ degb a + degb b)
+  (n : ℕ) (f : add_monoid_algebra R A) :
+  (f ^ n).support.sup degb ≤ n • (f.support.sup degb) :=
+begin
+  rw [← list.prod_repeat, ←list.sum_repeat],
+  refine (sup_support_list_prod_le degb0 degbm _).trans_eq _,
+  rw list.map_repeat,
+end
+
+lemma le_inf_support_pow (degt0 : 0 ≤ degt 0) (degtm : ∀ a b, degt a + degt b ≤ degt (a + b))
+  (n : ℕ) (f : add_monoid_algebra R A) :
+  n • (f.support.inf degt) ≤ (f ^ n).support.inf degt :=
+order_dual.of_dual_le_of_dual.mpr $ sup_support_pow_le (order_dual.of_dual_le_of_dual.mp degt0)
+  (λ a b, order_dual.of_dual_le_of_dual.mp (degtm _ _)) n f
+
+end add_monoids
+
+end semiring
+
+section commutative_lemmas
+variables [comm_semiring R] [add_comm_monoid A]
+  [add_comm_monoid B] [covariant_class B B (+) (≤)] [covariant_class B B (function.swap (+)) (≤)]
+  [add_comm_monoid T] [covariant_class T T (+) (≤)] [covariant_class T T (function.swap (+)) (≤)]
+  {degb : A → B} {degt : A → T}
+
+lemma sup_support_multiset_prod_le
+  (degb0 : degb 0 ≤ 0) (degbm : ∀ a b, degb (a + b) ≤ degb a + degb b)
+  (m : multiset (add_monoid_algebra R A)) :
+  m.prod.support.sup degb ≤ (m.map (λ f : add_monoid_algebra R A, f.support.sup degb)).sum :=
+begin
+  induction m using quot.induction_on,
+  rw [multiset.quot_mk_to_coe'', multiset.coe_map, multiset.coe_sum, multiset.coe_prod],
+  exact sup_support_list_prod_le degb0 degbm m,
+end
+
+lemma le_inf_support_multiset_prod
+  (degt0 : 0 ≤ degt 0) (degtm : ∀ a b, degt a + degt b ≤ degt (a + b))
+  (m : multiset (add_monoid_algebra R A)) :
+  (m.map (λ f : add_monoid_algebra R A, f.support.inf degt)).sum ≤ m.prod.support.inf degt :=
+order_dual.of_dual_le_of_dual.mpr $
+  sup_support_multiset_prod_le (order_dual.of_dual_le_of_dual.mp degt0)
+    (λ a b, order_dual.of_dual_le_of_dual.mp (degtm _ _)) m
+
+lemma sup_support_finset_prod_le
+  (degb0 : degb 0 ≤ 0) (degbm : ∀ a b, degb (a + b) ≤ degb a + degb b)
+  (s : finset ι) (f : ι → add_monoid_algebra R A) :
+  (∏ i in s, f i).support.sup degb ≤ ∑ i in s, (f i).support.sup degb :=
+(sup_support_multiset_prod_le degb0 degbm _).trans_eq $ congr_arg _ $ multiset.map_map _ _ _
+
+lemma le_inf_support_finset_prod
+  (degt0 : 0 ≤ degt 0) (degtm : ∀ a b, degt a + degt b ≤ degt (a + b))
+  (s : finset ι) (f : ι → add_monoid_algebra R A) :
+  ∑ i in s, (f i).support.inf degt ≤ (∏ i in s, f i).support.inf degt :=
+le_of_eq_of_le (by rw [multiset.map_map]; refl) (le_inf_support_multiset_prod degt0 degtm _)
+
+end commutative_lemmas
+
+end general_results_assuming_semilattice_sup
+
+end add_monoid_algebra

formal/lean/mathlib/algebra/order/archimedean.lean

@@ -109,26 +109,13 @@ let ⟨n, h⟩ := archimedean.arch x hy in
                              (add_nonneg zero_le_two hy.le) _
        ... = (y + 1) ^ n : by rw [add_comm]⟩
 
-section linear_ordered_ring
-variables [linear_ordered_ring α] [archimedean α]
+section ordered_ring
+variables [ordered_ring α] [nontrivial α] [archimedean α]
 
 lemma pow_unbounded_of_one_lt (x : α) {y : α} (hy1 : 1 < y) :
   ∃ n : ℕ, x < y ^ n :=
 sub_add_cancel y 1 ▸ add_one_pow_unbounded_of_pos _ (sub_pos.2 hy1)
 
-/-- Every x greater than or equal to 1 is between two successive
-natural-number powers of every y greater than one. -/
-lemma exists_nat_pow_near {x : α} {y : α} (hx : 1 ≤ x) (hy : 1 < y) :
-  ∃ n : ℕ, y ^ n ≤ x ∧ x < y ^ (n + 1) :=
-have h : ∃ n : ℕ, x < y ^ n, from pow_unbounded_of_one_lt _ hy,
-by classical; exact let n := nat.find h in
-  have hn  : x < y ^ n, from nat.find_spec h,
-  have hnp : 0 < n,     from pos_iff_ne_zero.2 (λ hn0,
-    by rw [hn0, pow_zero] at hn; exact (not_le_of_gt hn hx)),
-  have hnsp : nat.pred n + 1 = n,     from nat.succ_pred_eq_of_pos hnp,
-  have hltn : nat.pred n < n,         from nat.pred_lt (ne_of_gt hnp),
-  ⟨nat.pred n, le_of_not_lt (nat.find_min h hltn), by rwa hnsp⟩
-
 theorem exists_int_gt (x : α) : ∃ n : ℤ, x < n :=
 let ⟨n, h⟩ := exists_nat_gt x in ⟨n, by rwa int.cast_coe_nat⟩
 
@@ -149,6 +136,24 @@ begin
   exact ⟨λ h, le_trans (int.cast_le.2 h) h₁, h₂ z⟩,
 end
 
+end ordered_ring
+
+section linear_ordered_ring
+variables [linear_ordered_ring α] [archimedean α]
+
+/-- Every x greater than or equal to 1 is between two successive
+natural-number powers of every y greater than one. -/
+lemma exists_nat_pow_near {x : α} {y : α} (hx : 1 ≤ x) (hy : 1 < y) :
+  ∃ n : ℕ, y ^ n ≤ x ∧ x < y ^ (n + 1) :=
+have h : ∃ n : ℕ, x < y ^ n, from pow_unbounded_of_one_lt _ hy,
+by classical; exact let n := nat.find h in
+  have hn  : x < y ^ n, from nat.find_spec h,
+  have hnp : 0 < n,     from pos_iff_ne_zero.2 (λ hn0,
+    by rw [hn0, pow_zero] at hn; exact (not_le_of_gt hn hx)),
+  have hnsp : nat.pred n + 1 = n,     from nat.succ_pred_eq_of_pos hnp,
+  have hltn : nat.pred n < n,         from nat.pred_lt (ne_of_gt hnp),
+  ⟨nat.pred n, le_of_not_lt (nat.find_min h hltn), by rwa hnsp⟩
+
 end linear_ordered_ring
 
 section linear_ordered_field
@@ -276,6 +281,22 @@ archimedean_iff_nat_lt.trans
  λ H x, let ⟨n, h⟩ := H x in ⟨n+1,
    lt_of_le_of_lt h (nat.cast_lt.2 (lt_add_one _))⟩⟩
 
+lemma archimedean_iff_int_lt : archimedean α ↔ ∀ x : α, ∃ n : ℤ, x < n :=
+⟨@exists_int_gt α _ _,
+begin
+  rw archimedean_iff_nat_lt,
+  intros h x,
+  obtain ⟨n, h⟩ := h x,
+  refine ⟨n.to_nat, h.trans_le _⟩,
+  exact_mod_cast int.le_to_nat _,
+end⟩
+
+lemma archimedean_iff_int_le : archimedean α ↔ ∀ x : α, ∃ n : ℤ, x ≤ n :=
+archimedean_iff_int_lt.trans
+⟨λ H x, (H x).imp $ λ _, le_of_lt,
+ λ H x, let ⟨n, h⟩ := H x in ⟨n+1,
+   lt_of_le_of_lt h (int.cast_lt.2 (lt_add_one _))⟩⟩
+
 lemma archimedean_iff_rat_lt : archimedean α ↔ ∀ x : α, ∃ q : ℚ, x < q :=
 ⟨@exists_rat_gt α _,
   λ H, archimedean_iff_nat_lt.2 $ λ x,
@@ -308,3 +329,10 @@ noncomputable def archimedean.floor_ring (α) [linear_ordered_ring α] [archimed
   floor_ring α :=
 floor_ring.of_floor α (λ a, classical.some (exists_floor a))
   (λ z a, (classical.some_spec (exists_floor a) z).symm)
+
+/-- A linear ordered field that is a floor ring is archimedean. -/
+lemma floor_ring.archimedean (α) [linear_ordered_field α] [floor_ring α] : archimedean α :=
+begin
+  rw archimedean_iff_int_le,
+  exact λ x, ⟨⌈x⌉, int.le_ceil x⟩
+end