ring_theory.free_ring | Mathlib porting status

Changes since the initial port

The following section lists changes to this file in mathlib3 and mathlib4 that occured after the initial port. Most recent changes are shown first. Hovering over a commit will show all commits associated with the same mathlib3 commit.

Changes in mathlib3

d6814c58

(last sync)

Changes in mathlib3port

mathlib3

mathlib3port

93287238

bump to nightly-2023-09-24-06

mathlib commit https://github.com/leanprover-community/mathlib/commit/ce64cd319bb6b3e82f31c2d38e79080d377be451

5655435f

Diff

@@ -3,7 +3,7 @@ Copyright (c) 2019 Kenny Lau. All rights reserved.
 Released under Apache 2.0 license as described in the file LICENSE.
 Authors: Kenny Lau, Johan Commelin
 -/
-import Mathbin.GroupTheory.FreeAbelianGroup
+import GroupTheory.FreeAbelianGroup
 
 #align_import ring_theory.free_ring from "leanprover-community/mathlib"@"932872382355f00112641d305ba0619305dc8642"

93287238

bump to nightly-2023-07-20-09

mathlib commit https://github.com/leanprover-community/mathlib/commit/8ea5598db6caeddde6cb734aa179cc2408dbd345

9c56d0dd

Diff

@@ -2,14 +2,11 @@
 Copyright (c) 2019 Kenny Lau. All rights reserved.
 Released under Apache 2.0 license as described in the file LICENSE.
 Authors: Kenny Lau, Johan Commelin
-
-! This file was ported from Lean 3 source module ring_theory.free_ring
-! leanprover-community/mathlib commit 932872382355f00112641d305ba0619305dc8642
-! Please do not edit these lines, except to modify the commit id
-! if you have ported upstream changes.
 -/
 import Mathbin.GroupTheory.FreeAbelianGroup
 
+#align_import ring_theory.free_ring from "leanprover-community/mathlib"@"932872382355f00112641d305ba0619305dc8642"
+
 /-!
 # Free rings

93287238

bump to nightly-2023-06-13-21

mathlib commit https://github.com/leanprover-community/mathlib/commit/9fb8964792b4237dac6200193a0d533f1b3f7423

829520ac

Diff

@@ -62,6 +62,7 @@ theorem of_injective : Function.Injective (of : α → FreeRing α) :=
 #align free_ring.of_injective FreeRing.of_injective
 -/
 
+#print FreeRing.induction_on /-
 @[elab_as_elim]
 protected theorem induction_on {C : FreeRing α → Prop} (z : FreeRing α) (hn1 : C (-1))
     (hb : ∀ b, C (of b)) (ha : ∀ x y, C x → C y → C (x + y)) (hm : ∀ x y, C x → C y → C (x * y)) :
@@ -71,6 +72,7 @@ protected theorem induction_on {C : FreeRing α → Prop} (z : FreeRing α) (hn1
   FreeAbelianGroup.induction_on z (add_left_neg (1 : FreeRing α) ▸ ha _ _ hn1 h1)
     (fun m => List.recOn m h1 fun a m ih => hm _ _ (hb a) ih) (fun m ih => hn _ ih) ha
 #align free_ring.induction_on FreeRing.induction_on
+-/
 
 section lift
 
@@ -83,10 +85,12 @@ def lift : (α → R) ≃ (FreeRing α →+* R) :=
 #align free_ring.lift FreeRing.lift
 -/
 
+#print FreeRing.lift_of /-
 @[simp]
 theorem lift_of (x : α) : lift f (of x) = f x :=
   congr_fun (lift.left_inv f) x
 #align free_ring.lift_of FreeRing.lift_of
+-/
 
 #print FreeRing.lift_comp_of /-
 @[simp]
@@ -113,10 +117,12 @@ def map : FreeRing α →+* FreeRing β :=
 #align free_ring.map FreeRing.map
 -/
 
+#print FreeRing.map_of /-
 @[simp]
 theorem map_of (x : α) : map f (of x) = of (f x) :=
   lift_of _ _
 #align free_ring.map_of FreeRing.map_of
+-/
 
 end FreeRing

93287238

bump to nightly-2023-06-01-16

mathlib commit https://github.com/leanprover-community/mathlib/commit/cca40788df1b8755d5baf17ab2f27dacc2e17acb

b9c87c70

Diff

@@ -40,7 +40,8 @@ universe u v
 #print FreeRing /-
 /-- The free ring over a type `α`. -/
 def FreeRing (α : Type u) : Type u :=
-  FreeAbelianGroup <| FreeMonoid α deriving Ring, Inhabited
+  FreeAbelianGroup <| FreeMonoid α
+deriving Ring, Inhabited
 #align free_ring FreeRing
 -/

93287238

bump to nightly-2023-05-28-06

mathlib commit https://github.com/leanprover-community/mathlib/commit/917c3c072e487b3cccdbfeff17e75b40e45f66cb

ba5d8b97

Diff

@@ -61,12 +61,6 @@ theorem of_injective : Function.Injective (of : α → FreeRing α) :=
 #align free_ring.of_injective FreeRing.of_injective
 -/
 
-/- warning: free_ring.induction_on -> FreeRing.induction_on is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {C : (FreeRing.{u1} α) -> Prop} (z : FreeRing.{u1} α), (C (Neg.neg.{u1} (FreeRing.{u1} α) (SubNegMonoid.toHasNeg.{u1} (FreeRing.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeRing.{u1} α) (AddGroupWithOne.toAddGroup.{u1} (FreeRing.{u1} α) (AddCommGroupWithOne.toAddGroupWithOne.{u1} (FreeRing.{u1} α) (Ring.toAddCommGroupWithOne.{u1} (FreeRing.{u1} α) (FreeRing.ring.{u1} α)))))) (OfNat.ofNat.{u1} (FreeRing.{u1} α) 1 (OfNat.mk.{u1} (FreeRing.{u1} α) 1 (One.one.{u1} (FreeRing.{u1} α) (AddMonoidWithOne.toOne.{u1} (FreeRing.{u1} α) (AddGroupWithOne.toAddMonoidWithOne.{u1} (FreeRing.{u1} α) (AddCommGroupWithOne.toAddGroupWithOne.{u1} (FreeRing.{u1} α) (Ring.toAddCommGroupWithOne.{u1} (FreeRing.{u1} α) (FreeRing.ring.{u1} α)))))))))) -> (forall (b : α), C (FreeRing.of.{u1} α b)) -> (forall (x : FreeRing.{u1} α) (y : FreeRing.{u1} α), (C x) -> (C y) -> (C (HAdd.hAdd.{u1, u1, u1} (FreeRing.{u1} α) (FreeRing.{u1} α) (FreeRing.{u1} α) (instHAdd.{u1} (FreeRing.{u1} α) (Distrib.toHasAdd.{u1} (FreeRing.{u1} α) (Ring.toDistrib.{u1} (FreeRing.{u1} α) (FreeRing.ring.{u1} α)))) x y))) -> (forall (x : FreeRing.{u1} α) (y : FreeRing.{u1} α), (C x) -> (C y) -> (C (HMul.hMul.{u1, u1, u1} (FreeRing.{u1} α) (FreeRing.{u1} α) (FreeRing.{u1} α) (instHMul.{u1} (FreeRing.{u1} α) (Distrib.toHasMul.{u1} (FreeRing.{u1} α) (Ring.toDistrib.{u1} (FreeRing.{u1} α) (FreeRing.ring.{u1} α)))) x y))) -> (C z)
-but is expected to have type
-  forall {α : Type.{u1}} {C : (FreeRing.{u1} α) -> Prop} (z : FreeRing.{u1} α), (C (Neg.neg.{u1} (FreeRing.{u1} α) (Ring.toNeg.{u1} (FreeRing.{u1} α) (instRingFreeRing.{u1} α)) (OfNat.ofNat.{u1} (FreeRing.{u1} α) 1 (One.toOfNat1.{u1} (FreeRing.{u1} α) (Semiring.toOne.{u1} (FreeRing.{u1} α) (Ring.toSemiring.{u1} (FreeRing.{u1} α) (instRingFreeRing.{u1} α))))))) -> (forall (b : α), C (FreeRing.of.{u1} α b)) -> (forall (x : FreeRing.{u1} α) (y : FreeRing.{u1} α), (C x) -> (C y) -> (C (HAdd.hAdd.{u1, u1, u1} (FreeRing.{u1} α) (FreeRing.{u1} α) (FreeRing.{u1} α) (instHAdd.{u1} (FreeRing.{u1} α) (Distrib.toAdd.{u1} (FreeRing.{u1} α) (NonUnitalNonAssocSemiring.toDistrib.{u1} (FreeRing.{u1} α) (NonUnitalNonAssocRing.toNonUnitalNonAssocSemiring.{u1} (FreeRing.{u1} α) (NonAssocRing.toNonUnitalNonAssocRing.{u1} (FreeRing.{u1} α) (Ring.toNonAssocRing.{u1} (FreeRing.{u1} α) (instRingFreeRing.{u1} α))))))) x y))) -> (forall (x : FreeRing.{u1} α) (y : FreeRing.{u1} α), (C x) -> (C y) -> (C (HMul.hMul.{u1, u1, u1} (FreeRing.{u1} α) (FreeRing.{u1} α) (FreeRing.{u1} α) (instHMul.{u1} (FreeRing.{u1} α) (NonUnitalNonAssocRing.toMul.{u1} (FreeRing.{u1} α) (NonAssocRing.toNonUnitalNonAssocRing.{u1} (FreeRing.{u1} α) (Ring.toNonAssocRing.{u1} (FreeRing.{u1} α) (instRingFreeRing.{u1} α))))) x y))) -> (C z)
-Case conversion may be inaccurate. Consider using '#align free_ring.induction_on FreeRing.induction_onₓ'. -/
 @[elab_as_elim]
 protected theorem induction_on {C : FreeRing α → Prop} (z : FreeRing α) (hn1 : C (-1))
     (hb : ∀ b, C (of b)) (ha : ∀ x y, C x → C y → C (x + y)) (hm : ∀ x y, C x → C y → C (x * y)) :
@@ -88,12 +82,6 @@ def lift : (α → R) ≃ (FreeRing α →+* R) :=
 #align free_ring.lift FreeRing.lift
 -/
 
-/- warning: free_ring.lift_of -> FreeRing.lift_of is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {R : Type.{u2}} [_inst_1 : Ring.{u2} R] (f : α -> R) (x : α), Eq.{succ u2} R (coeFn.{max (succ u1) (succ u2), max (succ u1) (succ u2)} (RingHom.{u1, u2} (FreeRing.{u1} α) R (NonAssocRing.toNonAssocSemiring.{u1} (FreeRing.{u1} α) (Ring.toNonAssocRing.{u1} (FreeRing.{u1} α) (FreeRing.ring.{u1} α))) (NonAssocRing.toNonAssocSemiring.{u2} R (Ring.toNonAssocRing.{u2} R _inst_1))) (fun (_x : RingHom.{u1, u2} (FreeRing.{u1} α) R (NonAssocRing.toNonAssocSemiring.{u1} (FreeRing.{u1} α) (Ring.toNonAssocRing.{u1} (FreeRing.{u1} α) (FreeRing.ring.{u1} α))) (NonAssocRing.toNonAssocSemiring.{u2} R (Ring.toNonAssocRing.{u2} R _inst_1))) => (FreeRing.{u1} α) -> R) (RingHom.hasCoeToFun.{u1, u2} (FreeRing.{u1} α) R (NonAssocRing.toNonAssocSemiring.{u1} (FreeRing.{u1} α) (Ring.toNonAssocRing.{u1} (FreeRing.{u1} α) (FreeRing.ring.{u1} α))) (NonAssocRing.toNonAssocSemiring.{u2} R (Ring.toNonAssocRing.{u2} R _inst_1))) (coeFn.{max 1 (succ u1) (succ u2), max (succ u1) (succ u2)} (Equiv.{max (succ u1) (succ u2), max (succ u1) (succ u2)} (α -> R) (RingHom.{u1, u2} (FreeRing.{u1} α) R (NonAssocRing.toNonAssocSemiring.{u1} (FreeRing.{u1} α) (Ring.toNonAssocRing.{u1} (FreeRing.{u1} α) (FreeRing.ring.{u1} α))) (NonAssocRing.toNonAssocSemiring.{u2} R (Ring.toNonAssocRing.{u2} R _inst_1)))) (fun (_x : Equiv.{max (succ u1) (succ u2), max (succ u1) (succ u2)} (α -> R) (RingHom.{u1, u2} (FreeRing.{u1} α) R (NonAssocRing.toNonAssocSemiring.{u1} (FreeRing.{u1} α) (Ring.toNonAssocRing.{u1} (FreeRing.{u1} α) (FreeRing.ring.{u1} α))) (NonAssocRing.toNonAssocSemiring.{u2} R (Ring.toNonAssocRing.{u2} R _inst_1)))) => (α -> R) -> (RingHom.{u1, u2} (FreeRing.{u1} α) R (NonAssocRing.toNonAssocSemiring.{u1} (FreeRing.{u1} α) (Ring.toNonAssocRing.{u1} (FreeRing.{u1} α) (FreeRing.ring.{u1} α))) (NonAssocRing.toNonAssocSemiring.{u2} R (Ring.toNonAssocRing.{u2} R _inst_1)))) (Equiv.hasCoeToFun.{max (succ u1) (succ u2), max (succ u1) (succ u2)} (α -> R) (RingHom.{u1, u2} (FreeRing.{u1} α) R (NonAssocRing.toNonAssocSemiring.{u1} (FreeRing.{u1} α) (Ring.toNonAssocRing.{u1} (FreeRing.{u1} α) (FreeRing.ring.{u1} α))) (NonAssocRing.toNonAssocSemiring.{u2} R (Ring.toNonAssocRing.{u2} R _inst_1)))) (FreeRing.lift.{u1, u2} α R _inst_1) f) (FreeRing.of.{u1} α x)) (f x)
-but is expected to have type
-  forall {α : Type.{u1}} {R : Type.{u2}} [_inst_1 : Ring.{u2} R] (f : α -> R) (x : α), Eq.{succ u2} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2397 : FreeRing.{u1} α) => R) (FreeRing.of.{u1} α x)) (FunLike.coe.{max (succ u1) (succ u2), succ u1, succ u2} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : α -> R) => RingHom.{u1, u2} (FreeRing.{u1} α) R (Semiring.toNonAssocSemiring.{u1} (FreeRing.{u1} α) (Ring.toSemiring.{u1} (FreeRing.{u1} α) (instRingFreeRing.{u1} α))) (Semiring.toNonAssocSemiring.{u2} R (Ring.toSemiring.{u2} R _inst_1))) f) (FreeRing.{u1} α) (fun (_x : FreeRing.{u1} α) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2397 : FreeRing.{u1} α) => R) _x) (MulHomClass.toFunLike.{max u1 u2, u1, u2} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : α -> R) => RingHom.{u1, u2} (FreeRing.{u1} α) R (Semiring.toNonAssocSemiring.{u1} (FreeRing.{u1} α) (Ring.toSemiring.{u1} (FreeRing.{u1} α) (instRingFreeRing.{u1} α))) (Semiring.toNonAssocSemiring.{u2} R (Ring.toSemiring.{u2} R _inst_1))) f) (FreeRing.{u1} α) R (NonUnitalNonAssocSemiring.toMul.{u1} (FreeRing.{u1} α) (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u1} (FreeRing.{u1} α) (Semiring.toNonAssocSemiring.{u1} (FreeRing.{u1} α) (Ring.toSemiring.{u1} (FreeRing.{u1} α) (instRingFreeRing.{u1} α))))) (NonUnitalNonAssocSemiring.toMul.{u2} R (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u2} R (Semiring.toNonAssocSemiring.{u2} R (Ring.toSemiring.{u2} R _inst_1)))) (NonUnitalRingHomClass.toMulHomClass.{max u1 u2, u1, u2} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : α -> R) => RingHom.{u1, u2} (FreeRing.{u1} α) R (Semiring.toNonAssocSemiring.{u1} (FreeRing.{u1} α) (Ring.toSemiring.{u1} (FreeRing.{u1} α) (instRingFreeRing.{u1} α))) (Semiring.toNonAssocSemiring.{u2} R (Ring.toSemiring.{u2} R _inst_1))) f) (FreeRing.{u1} α) R (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u1} (FreeRing.{u1} α) (Semiring.toNonAssocSemiring.{u1} (FreeRing.{u1} α) (Ring.toSemiring.{u1} (FreeRing.{u1} α) (instRingFreeRing.{u1} α)))) (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u2} R (Semiring.toNonAssocSemiring.{u2} R (Ring.toSemiring.{u2} R _inst_1))) (RingHomClass.toNonUnitalRingHomClass.{max u1 u2, u1, u2} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : α -> R) => RingHom.{u1, u2} (FreeRing.{u1} α) R (Semiring.toNonAssocSemiring.{u1} (FreeRing.{u1} α) (Ring.toSemiring.{u1} (FreeRing.{u1} α) (instRingFreeRing.{u1} α))) (Semiring.toNonAssocSemiring.{u2} R (Ring.toSemiring.{u2} R _inst_1))) f) (FreeRing.{u1} α) R (Semiring.toNonAssocSemiring.{u1} (FreeRing.{u1} α) (Ring.toSemiring.{u1} (FreeRing.{u1} α) (instRingFreeRing.{u1} α))) (Semiring.toNonAssocSemiring.{u2} R (Ring.toSemiring.{u2} R _inst_1)) (RingHom.instRingHomClassRingHom.{u1, u2} (FreeRing.{u1} α) R (Semiring.toNonAssocSemiring.{u1} (FreeRing.{u1} α) (Ring.toSemiring.{u1} (FreeRing.{u1} α) (instRingFreeRing.{u1} α))) (Semiring.toNonAssocSemiring.{u2} R (Ring.toSemiring.{u2} R _inst_1)))))) (FunLike.coe.{max (succ u2) (succ u1), max (succ u2) (succ u1), max (succ u2) (succ u1)} (Equiv.{max (succ u1) (succ u2), max (succ u2) (succ u1)} (α -> R) (RingHom.{u1, u2} (FreeRing.{u1} α) R (Semiring.toNonAssocSemiring.{u1} (FreeRing.{u1} α) (Ring.toSemiring.{u1} (FreeRing.{u1} α) (instRingFreeRing.{u1} α))) (Semiring.toNonAssocSemiring.{u2} R (Ring.toSemiring.{u2} R _inst_1)))) (α -> R) (fun (_x : α -> R) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : α -> R) => RingHom.{u1, u2} (FreeRing.{u1} α) R (Semiring.toNonAssocSemiring.{u1} (FreeRing.{u1} α) (Ring.toSemiring.{u1} (FreeRing.{u1} α) (instRingFreeRing.{u1} α))) (Semiring.toNonAssocSemiring.{u2} R (Ring.toSemiring.{u2} R _inst_1))) _x) (Equiv.instFunLikeEquiv.{max (succ u2) (succ u1), max (succ u2) (succ u1)} (α -> R) (RingHom.{u1, u2} (FreeRing.{u1} α) R (Semiring.toNonAssocSemiring.{u1} (FreeRing.{u1} α) (Ring.toSemiring.{u1} (FreeRing.{u1} α) (instRingFreeRing.{u1} α))) (Semiring.toNonAssocSemiring.{u2} R (Ring.toSemiring.{u2} R _inst_1)))) (FreeRing.lift.{u1, u2} α R _inst_1) f) (FreeRing.of.{u1} α x)) (f x)
-Case conversion may be inaccurate. Consider using '#align free_ring.lift_of FreeRing.lift_ofₓ'. -/
 @[simp]
 theorem lift_of (x : α) : lift f (of x) = f x :=
   congr_fun (lift.left_inv f) x
@@ -124,12 +112,6 @@ def map : FreeRing α →+* FreeRing β :=
 #align free_ring.map FreeRing.map
 -/
 
-/- warning: free_ring.map_of -> FreeRing.map_of is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {β : Type.{u2}} (f : α -> β) (x : α), Eq.{succ u2} (FreeRing.{u2} β) (coeFn.{max (succ u1) (succ u2), max (succ u1) (succ u2)} (RingHom.{u1, u2} (FreeRing.{u1} α) (FreeRing.{u2} β) (NonAssocRing.toNonAssocSemiring.{u1} (FreeRing.{u1} α) (Ring.toNonAssocRing.{u1} (FreeRing.{u1} α) (FreeRing.ring.{u1} α))) (NonAssocRing.toNonAssocSemiring.{u2} (FreeRing.{u2} β) (Ring.toNonAssocRing.{u2} (FreeRing.{u2} β) (FreeRing.ring.{u2} β)))) (fun (_x : RingHom.{u1, u2} (FreeRing.{u1} α) (FreeRing.{u2} β) (NonAssocRing.toNonAssocSemiring.{u1} (FreeRing.{u1} α) (Ring.toNonAssocRing.{u1} (FreeRing.{u1} α) (FreeRing.ring.{u1} α))) (NonAssocRing.toNonAssocSemiring.{u2} (FreeRing.{u2} β) (Ring.toNonAssocRing.{u2} (FreeRing.{u2} β) (FreeRing.ring.{u2} β)))) => (FreeRing.{u1} α) -> (FreeRing.{u2} β)) (RingHom.hasCoeToFun.{u1, u2} (FreeRing.{u1} α) (FreeRing.{u2} β) (NonAssocRing.toNonAssocSemiring.{u1} (FreeRing.{u1} α) (Ring.toNonAssocRing.{u1} (FreeRing.{u1} α) (FreeRing.ring.{u1} α))) (NonAssocRing.toNonAssocSemiring.{u2} (FreeRing.{u2} β) (Ring.toNonAssocRing.{u2} (FreeRing.{u2} β) (FreeRing.ring.{u2} β)))) (FreeRing.map.{u1, u2} α β f) (FreeRing.of.{u1} α x)) (FreeRing.of.{u2} β (f x))
-but is expected to have type
-  forall {α : Type.{u1}} {β : Type.{u2}} (f : α -> β) (x : α), Eq.{succ u2} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2397 : FreeRing.{u1} α) => FreeRing.{u2} β) (FreeRing.of.{u1} α x)) (FunLike.coe.{max (succ u1) (succ u2), succ u1, succ u2} (RingHom.{u1, u2} (FreeRing.{u1} α) (FreeRing.{u2} β) (Semiring.toNonAssocSemiring.{u1} (FreeRing.{u1} α) (Ring.toSemiring.{u1} (FreeRing.{u1} α) (instRingFreeRing.{u1} α))) (Semiring.toNonAssocSemiring.{u2} (FreeRing.{u2} β) (Ring.toSemiring.{u2} (FreeRing.{u2} β) (instRingFreeRing.{u2} β)))) (FreeRing.{u1} α) (fun (_x : FreeRing.{u1} α) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2397 : FreeRing.{u1} α) => FreeRing.{u2} β) _x) (MulHomClass.toFunLike.{max u1 u2, u1, u2} (RingHom.{u1, u2} (FreeRing.{u1} α) (FreeRing.{u2} β) (Semiring.toNonAssocSemiring.{u1} (FreeRing.{u1} α) (Ring.toSemiring.{u1} (FreeRing.{u1} α) (instRingFreeRing.{u1} α))) (Semiring.toNonAssocSemiring.{u2} (FreeRing.{u2} β) (Ring.toSemiring.{u2} (FreeRing.{u2} β) (instRingFreeRing.{u2} β)))) (FreeRing.{u1} α) (FreeRing.{u2} β) (NonUnitalNonAssocSemiring.toMul.{u1} (FreeRing.{u1} α) (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u1} (FreeRing.{u1} α) (Semiring.toNonAssocSemiring.{u1} (FreeRing.{u1} α) (Ring.toSemiring.{u1} (FreeRing.{u1} α) (instRingFreeRing.{u1} α))))) (NonUnitalNonAssocSemiring.toMul.{u2} (FreeRing.{u2} β) (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u2} (FreeRing.{u2} β) (Semiring.toNonAssocSemiring.{u2} (FreeRing.{u2} β) (Ring.toSemiring.{u2} (FreeRing.{u2} β) (instRingFreeRing.{u2} β))))) (NonUnitalRingHomClass.toMulHomClass.{max u1 u2, u1, u2} (RingHom.{u1, u2} (FreeRing.{u1} α) (FreeRing.{u2} β) (Semiring.toNonAssocSemiring.{u1} (FreeRing.{u1} α) (Ring.toSemiring.{u1} (FreeRing.{u1} α) (instRingFreeRing.{u1} α))) (Semiring.toNonAssocSemiring.{u2} (FreeRing.{u2} β) (Ring.toSemiring.{u2} (FreeRing.{u2} β) (instRingFreeRing.{u2} β)))) (FreeRing.{u1} α) (FreeRing.{u2} β) (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u1} (FreeRing.{u1} α) (Semiring.toNonAssocSemiring.{u1} (FreeRing.{u1} α) (Ring.toSemiring.{u1} (FreeRing.{u1} α) (instRingFreeRing.{u1} α)))) (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u2} (FreeRing.{u2} β) (Semiring.toNonAssocSemiring.{u2} (FreeRing.{u2} β) (Ring.toSemiring.{u2} (FreeRing.{u2} β) (instRingFreeRing.{u2} β)))) (RingHomClass.toNonUnitalRingHomClass.{max u1 u2, u1, u2} (RingHom.{u1, u2} (FreeRing.{u1} α) (FreeRing.{u2} β) (Semiring.toNonAssocSemiring.{u1} (FreeRing.{u1} α) (Ring.toSemiring.{u1} (FreeRing.{u1} α) (instRingFreeRing.{u1} α))) (Semiring.toNonAssocSemiring.{u2} (FreeRing.{u2} β) (Ring.toSemiring.{u2} (FreeRing.{u2} β) (instRingFreeRing.{u2} β)))) (FreeRing.{u1} α) (FreeRing.{u2} β) (Semiring.toNonAssocSemiring.{u1} (FreeRing.{u1} α) (Ring.toSemiring.{u1} (FreeRing.{u1} α) (instRingFreeRing.{u1} α))) (Semiring.toNonAssocSemiring.{u2} (FreeRing.{u2} β) (Ring.toSemiring.{u2} (FreeRing.{u2} β) (instRingFreeRing.{u2} β))) (RingHom.instRingHomClassRingHom.{u1, u2} (FreeRing.{u1} α) (FreeRing.{u2} β) (Semiring.toNonAssocSemiring.{u1} (FreeRing.{u1} α) (Ring.toSemiring.{u1} (FreeRing.{u1} α) (instRingFreeRing.{u1} α))) (Semiring.toNonAssocSemiring.{u2} (FreeRing.{u2} β) (Ring.toSemiring.{u2} (FreeRing.{u2} β) (instRingFreeRing.{u2} β))))))) (FreeRing.map.{u1, u2} α β f) (FreeRing.of.{u1} α x)) (FreeRing.of.{u2} β (f x))
-Case conversion may be inaccurate. Consider using '#align free_ring.map_of FreeRing.map_ofₓ'. -/
 @[simp]
 theorem map_of (x : α) : map f (of x) = of (f x) :=
   lift_of _ _

93287238

bump to nightly-2023-05-19-16

mathlib commit https://github.com/leanprover-community/mathlib/commit/95a87616d63b3cb49d3fe678d416fbe9c4217bf4

a31df521

Diff

@@ -92,7 +92,7 @@ def lift : (α → R) ≃ (FreeRing α →+* R) :=
 lean 3 declaration is
   forall {α : Type.{u1}} {R : Type.{u2}} [_inst_1 : Ring.{u2} R] (f : α -> R) (x : α), Eq.{succ u2} R (coeFn.{max (succ u1) (succ u2), max (succ u1) (succ u2)} (RingHom.{u1, u2} (FreeRing.{u1} α) R (NonAssocRing.toNonAssocSemiring.{u1} (FreeRing.{u1} α) (Ring.toNonAssocRing.{u1} (FreeRing.{u1} α) (FreeRing.ring.{u1} α))) (NonAssocRing.toNonAssocSemiring.{u2} R (Ring.toNonAssocRing.{u2} R _inst_1))) (fun (_x : RingHom.{u1, u2} (FreeRing.{u1} α) R (NonAssocRing.toNonAssocSemiring.{u1} (FreeRing.{u1} α) (Ring.toNonAssocRing.{u1} (FreeRing.{u1} α) (FreeRing.ring.{u1} α))) (NonAssocRing.toNonAssocSemiring.{u2} R (Ring.toNonAssocRing.{u2} R _inst_1))) => (FreeRing.{u1} α) -> R) (RingHom.hasCoeToFun.{u1, u2} (FreeRing.{u1} α) R (NonAssocRing.toNonAssocSemiring.{u1} (FreeRing.{u1} α) (Ring.toNonAssocRing.{u1} (FreeRing.{u1} α) (FreeRing.ring.{u1} α))) (NonAssocRing.toNonAssocSemiring.{u2} R (Ring.toNonAssocRing.{u2} R _inst_1))) (coeFn.{max 1 (succ u1) (succ u2), max (succ u1) (succ u2)} (Equiv.{max (succ u1) (succ u2), max (succ u1) (succ u2)} (α -> R) (RingHom.{u1, u2} (FreeRing.{u1} α) R (NonAssocRing.toNonAssocSemiring.{u1} (FreeRing.{u1} α) (Ring.toNonAssocRing.{u1} (FreeRing.{u1} α) (FreeRing.ring.{u1} α))) (NonAssocRing.toNonAssocSemiring.{u2} R (Ring.toNonAssocRing.{u2} R _inst_1)))) (fun (_x : Equiv.{max (succ u1) (succ u2), max (succ u1) (succ u2)} (α -> R) (RingHom.{u1, u2} (FreeRing.{u1} α) R (NonAssocRing.toNonAssocSemiring.{u1} (FreeRing.{u1} α) (Ring.toNonAssocRing.{u1} (FreeRing.{u1} α) (FreeRing.ring.{u1} α))) (NonAssocRing.toNonAssocSemiring.{u2} R (Ring.toNonAssocRing.{u2} R _inst_1)))) => (α -> R) -> (RingHom.{u1, u2} (FreeRing.{u1} α) R (NonAssocRing.toNonAssocSemiring.{u1} (FreeRing.{u1} α) (Ring.toNonAssocRing.{u1} (FreeRing.{u1} α) (FreeRing.ring.{u1} α))) (NonAssocRing.toNonAssocSemiring.{u2} R (Ring.toNonAssocRing.{u2} R _inst_1)))) (Equiv.hasCoeToFun.{max (succ u1) (succ u2), max (succ u1) (succ u2)} (α -> R) (RingHom.{u1, u2} (FreeRing.{u1} α) R (NonAssocRing.toNonAssocSemiring.{u1} (FreeRing.{u1} α) (Ring.toNonAssocRing.{u1} (FreeRing.{u1} α) (FreeRing.ring.{u1} α))) (NonAssocRing.toNonAssocSemiring.{u2} R (Ring.toNonAssocRing.{u2} R _inst_1)))) (FreeRing.lift.{u1, u2} α R _inst_1) f) (FreeRing.of.{u1} α x)) (f x)
 but is expected to have type
-  forall {α : Type.{u1}} {R : Type.{u2}} [_inst_1 : Ring.{u2} R] (f : α -> R) (x : α), Eq.{succ u2} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : FreeRing.{u1} α) => R) (FreeRing.of.{u1} α x)) (FunLike.coe.{max (succ u1) (succ u2), succ u1, succ u2} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : α -> R) => RingHom.{u1, u2} (FreeRing.{u1} α) R (Semiring.toNonAssocSemiring.{u1} (FreeRing.{u1} α) (Ring.toSemiring.{u1} (FreeRing.{u1} α) (instRingFreeRing.{u1} α))) (Semiring.toNonAssocSemiring.{u2} R (Ring.toSemiring.{u2} R _inst_1))) f) (FreeRing.{u1} α) (fun (_x : FreeRing.{u1} α) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : FreeRing.{u1} α) => R) _x) (MulHomClass.toFunLike.{max u1 u2, u1, u2} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : α -> R) => RingHom.{u1, u2} (FreeRing.{u1} α) R (Semiring.toNonAssocSemiring.{u1} (FreeRing.{u1} α) (Ring.toSemiring.{u1} (FreeRing.{u1} α) (instRingFreeRing.{u1} α))) (Semiring.toNonAssocSemiring.{u2} R (Ring.toSemiring.{u2} R _inst_1))) f) (FreeRing.{u1} α) R (NonUnitalNonAssocSemiring.toMul.{u1} (FreeRing.{u1} α) (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u1} (FreeRing.{u1} α) (Semiring.toNonAssocSemiring.{u1} (FreeRing.{u1} α) (Ring.toSemiring.{u1} (FreeRing.{u1} α) (instRingFreeRing.{u1} α))))) (NonUnitalNonAssocSemiring.toMul.{u2} R (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u2} R (Semiring.toNonAssocSemiring.{u2} R (Ring.toSemiring.{u2} R _inst_1)))) (NonUnitalRingHomClass.toMulHomClass.{max u1 u2, u1, u2} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : α -> R) => RingHom.{u1, u2} (FreeRing.{u1} α) R (Semiring.toNonAssocSemiring.{u1} (FreeRing.{u1} α) (Ring.toSemiring.{u1} (FreeRing.{u1} α) (instRingFreeRing.{u1} α))) (Semiring.toNonAssocSemiring.{u2} R (Ring.toSemiring.{u2} R _inst_1))) f) (FreeRing.{u1} α) R (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u1} (FreeRing.{u1} α) (Semiring.toNonAssocSemiring.{u1} (FreeRing.{u1} α) (Ring.toSemiring.{u1} (FreeRing.{u1} α) (instRingFreeRing.{u1} α)))) (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u2} R (Semiring.toNonAssocSemiring.{u2} R (Ring.toSemiring.{u2} R _inst_1))) (RingHomClass.toNonUnitalRingHomClass.{max u1 u2, u1, u2} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : α -> R) => RingHom.{u1, u2} (FreeRing.{u1} α) R (Semiring.toNonAssocSemiring.{u1} (FreeRing.{u1} α) (Ring.toSemiring.{u1} (FreeRing.{u1} α) (instRingFreeRing.{u1} α))) (Semiring.toNonAssocSemiring.{u2} R (Ring.toSemiring.{u2} R _inst_1))) f) (FreeRing.{u1} α) R (Semiring.toNonAssocSemiring.{u1} (FreeRing.{u1} α) (Ring.toSemiring.{u1} (FreeRing.{u1} α) (instRingFreeRing.{u1} α))) (Semiring.toNonAssocSemiring.{u2} R (Ring.toSemiring.{u2} R _inst_1)) (RingHom.instRingHomClassRingHom.{u1, u2} (FreeRing.{u1} α) R (Semiring.toNonAssocSemiring.{u1} (FreeRing.{u1} α) (Ring.toSemiring.{u1} (FreeRing.{u1} α) (instRingFreeRing.{u1} α))) (Semiring.toNonAssocSemiring.{u2} R (Ring.toSemiring.{u2} R _inst_1)))))) (FunLike.coe.{max (succ u2) (succ u1), max (succ u2) (succ u1), max (succ u2) (succ u1)} (Equiv.{max (succ u1) (succ u2), max (succ u2) (succ u1)} (α -> R) (RingHom.{u1, u2} (FreeRing.{u1} α) R (Semiring.toNonAssocSemiring.{u1} (FreeRing.{u1} α) (Ring.toSemiring.{u1} (FreeRing.{u1} α) (instRingFreeRing.{u1} α))) (Semiring.toNonAssocSemiring.{u2} R (Ring.toSemiring.{u2} R _inst_1)))) (α -> R) (fun (_x : α -> R) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : α -> R) => RingHom.{u1, u2} (FreeRing.{u1} α) R (Semiring.toNonAssocSemiring.{u1} (FreeRing.{u1} α) (Ring.toSemiring.{u1} (FreeRing.{u1} α) (instRingFreeRing.{u1} α))) (Semiring.toNonAssocSemiring.{u2} R (Ring.toSemiring.{u2} R _inst_1))) _x) (Equiv.instFunLikeEquiv.{max (succ u2) (succ u1), max (succ u2) (succ u1)} (α -> R) (RingHom.{u1, u2} (FreeRing.{u1} α) R (Semiring.toNonAssocSemiring.{u1} (FreeRing.{u1} α) (Ring.toSemiring.{u1} (FreeRing.{u1} α) (instRingFreeRing.{u1} α))) (Semiring.toNonAssocSemiring.{u2} R (Ring.toSemiring.{u2} R _inst_1)))) (FreeRing.lift.{u1, u2} α R _inst_1) f) (FreeRing.of.{u1} α x)) (f x)
+  forall {α : Type.{u1}} {R : Type.{u2}} [_inst_1 : Ring.{u2} R] (f : α -> R) (x : α), Eq.{succ u2} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2397 : FreeRing.{u1} α) => R) (FreeRing.of.{u1} α x)) (FunLike.coe.{max (succ u1) (succ u2), succ u1, succ u2} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : α -> R) => RingHom.{u1, u2} (FreeRing.{u1} α) R (Semiring.toNonAssocSemiring.{u1} (FreeRing.{u1} α) (Ring.toSemiring.{u1} (FreeRing.{u1} α) (instRingFreeRing.{u1} α))) (Semiring.toNonAssocSemiring.{u2} R (Ring.toSemiring.{u2} R _inst_1))) f) (FreeRing.{u1} α) (fun (_x : FreeRing.{u1} α) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2397 : FreeRing.{u1} α) => R) _x) (MulHomClass.toFunLike.{max u1 u2, u1, u2} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : α -> R) => RingHom.{u1, u2} (FreeRing.{u1} α) R (Semiring.toNonAssocSemiring.{u1} (FreeRing.{u1} α) (Ring.toSemiring.{u1} (FreeRing.{u1} α) (instRingFreeRing.{u1} α))) (Semiring.toNonAssocSemiring.{u2} R (Ring.toSemiring.{u2} R _inst_1))) f) (FreeRing.{u1} α) R (NonUnitalNonAssocSemiring.toMul.{u1} (FreeRing.{u1} α) (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u1} (FreeRing.{u1} α) (Semiring.toNonAssocSemiring.{u1} (FreeRing.{u1} α) (Ring.toSemiring.{u1} (FreeRing.{u1} α) (instRingFreeRing.{u1} α))))) (NonUnitalNonAssocSemiring.toMul.{u2} R (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u2} R (Semiring.toNonAssocSemiring.{u2} R (Ring.toSemiring.{u2} R _inst_1)))) (NonUnitalRingHomClass.toMulHomClass.{max u1 u2, u1, u2} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : α -> R) => RingHom.{u1, u2} (FreeRing.{u1} α) R (Semiring.toNonAssocSemiring.{u1} (FreeRing.{u1} α) (Ring.toSemiring.{u1} (FreeRing.{u1} α) (instRingFreeRing.{u1} α))) (Semiring.toNonAssocSemiring.{u2} R (Ring.toSemiring.{u2} R _inst_1))) f) (FreeRing.{u1} α) R (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u1} (FreeRing.{u1} α) (Semiring.toNonAssocSemiring.{u1} (FreeRing.{u1} α) (Ring.toSemiring.{u1} (FreeRing.{u1} α) (instRingFreeRing.{u1} α)))) (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u2} R (Semiring.toNonAssocSemiring.{u2} R (Ring.toSemiring.{u2} R _inst_1))) (RingHomClass.toNonUnitalRingHomClass.{max u1 u2, u1, u2} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : α -> R) => RingHom.{u1, u2} (FreeRing.{u1} α) R (Semiring.toNonAssocSemiring.{u1} (FreeRing.{u1} α) (Ring.toSemiring.{u1} (FreeRing.{u1} α) (instRingFreeRing.{u1} α))) (Semiring.toNonAssocSemiring.{u2} R (Ring.toSemiring.{u2} R _inst_1))) f) (FreeRing.{u1} α) R (Semiring.toNonAssocSemiring.{u1} (FreeRing.{u1} α) (Ring.toSemiring.{u1} (FreeRing.{u1} α) (instRingFreeRing.{u1} α))) (Semiring.toNonAssocSemiring.{u2} R (Ring.toSemiring.{u2} R _inst_1)) (RingHom.instRingHomClassRingHom.{u1, u2} (FreeRing.{u1} α) R (Semiring.toNonAssocSemiring.{u1} (FreeRing.{u1} α) (Ring.toSemiring.{u1} (FreeRing.{u1} α) (instRingFreeRing.{u1} α))) (Semiring.toNonAssocSemiring.{u2} R (Ring.toSemiring.{u2} R _inst_1)))))) (FunLike.coe.{max (succ u2) (succ u1), max (succ u2) (succ u1), max (succ u2) (succ u1)} (Equiv.{max (succ u1) (succ u2), max (succ u2) (succ u1)} (α -> R) (RingHom.{u1, u2} (FreeRing.{u1} α) R (Semiring.toNonAssocSemiring.{u1} (FreeRing.{u1} α) (Ring.toSemiring.{u1} (FreeRing.{u1} α) (instRingFreeRing.{u1} α))) (Semiring.toNonAssocSemiring.{u2} R (Ring.toSemiring.{u2} R _inst_1)))) (α -> R) (fun (_x : α -> R) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : α -> R) => RingHom.{u1, u2} (FreeRing.{u1} α) R (Semiring.toNonAssocSemiring.{u1} (FreeRing.{u1} α) (Ring.toSemiring.{u1} (FreeRing.{u1} α) (instRingFreeRing.{u1} α))) (Semiring.toNonAssocSemiring.{u2} R (Ring.toSemiring.{u2} R _inst_1))) _x) (Equiv.instFunLikeEquiv.{max (succ u2) (succ u1), max (succ u2) (succ u1)} (α -> R) (RingHom.{u1, u2} (FreeRing.{u1} α) R (Semiring.toNonAssocSemiring.{u1} (FreeRing.{u1} α) (Ring.toSemiring.{u1} (FreeRing.{u1} α) (instRingFreeRing.{u1} α))) (Semiring.toNonAssocSemiring.{u2} R (Ring.toSemiring.{u2} R _inst_1)))) (FreeRing.lift.{u1, u2} α R _inst_1) f) (FreeRing.of.{u1} α x)) (f x)
 Case conversion may be inaccurate. Consider using '#align free_ring.lift_of FreeRing.lift_ofₓ'. -/
 @[simp]
 theorem lift_of (x : α) : lift f (of x) = f x :=
@@ -128,7 +128,7 @@ def map : FreeRing α →+* FreeRing β :=
 lean 3 declaration is
   forall {α : Type.{u1}} {β : Type.{u2}} (f : α -> β) (x : α), Eq.{succ u2} (FreeRing.{u2} β) (coeFn.{max (succ u1) (succ u2), max (succ u1) (succ u2)} (RingHom.{u1, u2} (FreeRing.{u1} α) (FreeRing.{u2} β) (NonAssocRing.toNonAssocSemiring.{u1} (FreeRing.{u1} α) (Ring.toNonAssocRing.{u1} (FreeRing.{u1} α) (FreeRing.ring.{u1} α))) (NonAssocRing.toNonAssocSemiring.{u2} (FreeRing.{u2} β) (Ring.toNonAssocRing.{u2} (FreeRing.{u2} β) (FreeRing.ring.{u2} β)))) (fun (_x : RingHom.{u1, u2} (FreeRing.{u1} α) (FreeRing.{u2} β) (NonAssocRing.toNonAssocSemiring.{u1} (FreeRing.{u1} α) (Ring.toNonAssocRing.{u1} (FreeRing.{u1} α) (FreeRing.ring.{u1} α))) (NonAssocRing.toNonAssocSemiring.{u2} (FreeRing.{u2} β) (Ring.toNonAssocRing.{u2} (FreeRing.{u2} β) (FreeRing.ring.{u2} β)))) => (FreeRing.{u1} α) -> (FreeRing.{u2} β)) (RingHom.hasCoeToFun.{u1, u2} (FreeRing.{u1} α) (FreeRing.{u2} β) (NonAssocRing.toNonAssocSemiring.{u1} (FreeRing.{u1} α) (Ring.toNonAssocRing.{u1} (FreeRing.{u1} α) (FreeRing.ring.{u1} α))) (NonAssocRing.toNonAssocSemiring.{u2} (FreeRing.{u2} β) (Ring.toNonAssocRing.{u2} (FreeRing.{u2} β) (FreeRing.ring.{u2} β)))) (FreeRing.map.{u1, u2} α β f) (FreeRing.of.{u1} α x)) (FreeRing.of.{u2} β (f x))
 but is expected to have type
-  forall {α : Type.{u1}} {β : Type.{u2}} (f : α -> β) (x : α), Eq.{succ u2} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : FreeRing.{u1} α) => FreeRing.{u2} β) (FreeRing.of.{u1} α x)) (FunLike.coe.{max (succ u1) (succ u2), succ u1, succ u2} (RingHom.{u1, u2} (FreeRing.{u1} α) (FreeRing.{u2} β) (Semiring.toNonAssocSemiring.{u1} (FreeRing.{u1} α) (Ring.toSemiring.{u1} (FreeRing.{u1} α) (instRingFreeRing.{u1} α))) (Semiring.toNonAssocSemiring.{u2} (FreeRing.{u2} β) (Ring.toSemiring.{u2} (FreeRing.{u2} β) (instRingFreeRing.{u2} β)))) (FreeRing.{u1} α) (fun (_x : FreeRing.{u1} α) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : FreeRing.{u1} α) => FreeRing.{u2} β) _x) (MulHomClass.toFunLike.{max u1 u2, u1, u2} (RingHom.{u1, u2} (FreeRing.{u1} α) (FreeRing.{u2} β) (Semiring.toNonAssocSemiring.{u1} (FreeRing.{u1} α) (Ring.toSemiring.{u1} (FreeRing.{u1} α) (instRingFreeRing.{u1} α))) (Semiring.toNonAssocSemiring.{u2} (FreeRing.{u2} β) (Ring.toSemiring.{u2} (FreeRing.{u2} β) (instRingFreeRing.{u2} β)))) (FreeRing.{u1} α) (FreeRing.{u2} β) (NonUnitalNonAssocSemiring.toMul.{u1} (FreeRing.{u1} α) (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u1} (FreeRing.{u1} α) (Semiring.toNonAssocSemiring.{u1} (FreeRing.{u1} α) (Ring.toSemiring.{u1} (FreeRing.{u1} α) (instRingFreeRing.{u1} α))))) (NonUnitalNonAssocSemiring.toMul.{u2} (FreeRing.{u2} β) (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u2} (FreeRing.{u2} β) (Semiring.toNonAssocSemiring.{u2} (FreeRing.{u2} β) (Ring.toSemiring.{u2} (FreeRing.{u2} β) (instRingFreeRing.{u2} β))))) (NonUnitalRingHomClass.toMulHomClass.{max u1 u2, u1, u2} (RingHom.{u1, u2} (FreeRing.{u1} α) (FreeRing.{u2} β) (Semiring.toNonAssocSemiring.{u1} (FreeRing.{u1} α) (Ring.toSemiring.{u1} (FreeRing.{u1} α) (instRingFreeRing.{u1} α))) (Semiring.toNonAssocSemiring.{u2} (FreeRing.{u2} β) (Ring.toSemiring.{u2} (FreeRing.{u2} β) (instRingFreeRing.{u2} β)))) (FreeRing.{u1} α) (FreeRing.{u2} β) (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u1} (FreeRing.{u1} α) (Semiring.toNonAssocSemiring.{u1} (FreeRing.{u1} α) (Ring.toSemiring.{u1} (FreeRing.{u1} α) (instRingFreeRing.{u1} α)))) (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u2} (FreeRing.{u2} β) (Semiring.toNonAssocSemiring.{u2} (FreeRing.{u2} β) (Ring.toSemiring.{u2} (FreeRing.{u2} β) (instRingFreeRing.{u2} β)))) (RingHomClass.toNonUnitalRingHomClass.{max u1 u2, u1, u2} (RingHom.{u1, u2} (FreeRing.{u1} α) (FreeRing.{u2} β) (Semiring.toNonAssocSemiring.{u1} (FreeRing.{u1} α) (Ring.toSemiring.{u1} (FreeRing.{u1} α) (instRingFreeRing.{u1} α))) (Semiring.toNonAssocSemiring.{u2} (FreeRing.{u2} β) (Ring.toSemiring.{u2} (FreeRing.{u2} β) (instRingFreeRing.{u2} β)))) (FreeRing.{u1} α) (FreeRing.{u2} β) (Semiring.toNonAssocSemiring.{u1} (FreeRing.{u1} α) (Ring.toSemiring.{u1} (FreeRing.{u1} α) (instRingFreeRing.{u1} α))) (Semiring.toNonAssocSemiring.{u2} (FreeRing.{u2} β) (Ring.toSemiring.{u2} (FreeRing.{u2} β) (instRingFreeRing.{u2} β))) (RingHom.instRingHomClassRingHom.{u1, u2} (FreeRing.{u1} α) (FreeRing.{u2} β) (Semiring.toNonAssocSemiring.{u1} (FreeRing.{u1} α) (Ring.toSemiring.{u1} (FreeRing.{u1} α) (instRingFreeRing.{u1} α))) (Semiring.toNonAssocSemiring.{u2} (FreeRing.{u2} β) (Ring.toSemiring.{u2} (FreeRing.{u2} β) (instRingFreeRing.{u2} β))))))) (FreeRing.map.{u1, u2} α β f) (FreeRing.of.{u1} α x)) (FreeRing.of.{u2} β (f x))
+  forall {α : Type.{u1}} {β : Type.{u2}} (f : α -> β) (x : α), Eq.{succ u2} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2397 : FreeRing.{u1} α) => FreeRing.{u2} β) (FreeRing.of.{u1} α x)) (FunLike.coe.{max (succ u1) (succ u2), succ u1, succ u2} (RingHom.{u1, u2} (FreeRing.{u1} α) (FreeRing.{u2} β) (Semiring.toNonAssocSemiring.{u1} (FreeRing.{u1} α) (Ring.toSemiring.{u1} (FreeRing.{u1} α) (instRingFreeRing.{u1} α))) (Semiring.toNonAssocSemiring.{u2} (FreeRing.{u2} β) (Ring.toSemiring.{u2} (FreeRing.{u2} β) (instRingFreeRing.{u2} β)))) (FreeRing.{u1} α) (fun (_x : FreeRing.{u1} α) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2397 : FreeRing.{u1} α) => FreeRing.{u2} β) _x) (MulHomClass.toFunLike.{max u1 u2, u1, u2} (RingHom.{u1, u2} (FreeRing.{u1} α) (FreeRing.{u2} β) (Semiring.toNonAssocSemiring.{u1} (FreeRing.{u1} α) (Ring.toSemiring.{u1} (FreeRing.{u1} α) (instRingFreeRing.{u1} α))) (Semiring.toNonAssocSemiring.{u2} (FreeRing.{u2} β) (Ring.toSemiring.{u2} (FreeRing.{u2} β) (instRingFreeRing.{u2} β)))) (FreeRing.{u1} α) (FreeRing.{u2} β) (NonUnitalNonAssocSemiring.toMul.{u1} (FreeRing.{u1} α) (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u1} (FreeRing.{u1} α) (Semiring.toNonAssocSemiring.{u1} (FreeRing.{u1} α) (Ring.toSemiring.{u1} (FreeRing.{u1} α) (instRingFreeRing.{u1} α))))) (NonUnitalNonAssocSemiring.toMul.{u2} (FreeRing.{u2} β) (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u2} (FreeRing.{u2} β) (Semiring.toNonAssocSemiring.{u2} (FreeRing.{u2} β) (Ring.toSemiring.{u2} (FreeRing.{u2} β) (instRingFreeRing.{u2} β))))) (NonUnitalRingHomClass.toMulHomClass.{max u1 u2, u1, u2} (RingHom.{u1, u2} (FreeRing.{u1} α) (FreeRing.{u2} β) (Semiring.toNonAssocSemiring.{u1} (FreeRing.{u1} α) (Ring.toSemiring.{u1} (FreeRing.{u1} α) (instRingFreeRing.{u1} α))) (Semiring.toNonAssocSemiring.{u2} (FreeRing.{u2} β) (Ring.toSemiring.{u2} (FreeRing.{u2} β) (instRingFreeRing.{u2} β)))) (FreeRing.{u1} α) (FreeRing.{u2} β) (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u1} (FreeRing.{u1} α) (Semiring.toNonAssocSemiring.{u1} (FreeRing.{u1} α) (Ring.toSemiring.{u1} (FreeRing.{u1} α) (instRingFreeRing.{u1} α)))) (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u2} (FreeRing.{u2} β) (Semiring.toNonAssocSemiring.{u2} (FreeRing.{u2} β) (Ring.toSemiring.{u2} (FreeRing.{u2} β) (instRingFreeRing.{u2} β)))) (RingHomClass.toNonUnitalRingHomClass.{max u1 u2, u1, u2} (RingHom.{u1, u2} (FreeRing.{u1} α) (FreeRing.{u2} β) (Semiring.toNonAssocSemiring.{u1} (FreeRing.{u1} α) (Ring.toSemiring.{u1} (FreeRing.{u1} α) (instRingFreeRing.{u1} α))) (Semiring.toNonAssocSemiring.{u2} (FreeRing.{u2} β) (Ring.toSemiring.{u2} (FreeRing.{u2} β) (instRingFreeRing.{u2} β)))) (FreeRing.{u1} α) (FreeRing.{u2} β) (Semiring.toNonAssocSemiring.{u1} (FreeRing.{u1} α) (Ring.toSemiring.{u1} (FreeRing.{u1} α) (instRingFreeRing.{u1} α))) (Semiring.toNonAssocSemiring.{u2} (FreeRing.{u2} β) (Ring.toSemiring.{u2} (FreeRing.{u2} β) (instRingFreeRing.{u2} β))) (RingHom.instRingHomClassRingHom.{u1, u2} (FreeRing.{u1} α) (FreeRing.{u2} β) (Semiring.toNonAssocSemiring.{u1} (FreeRing.{u1} α) (Ring.toSemiring.{u1} (FreeRing.{u1} α) (instRingFreeRing.{u1} α))) (Semiring.toNonAssocSemiring.{u2} (FreeRing.{u2} β) (Ring.toSemiring.{u2} (FreeRing.{u2} β) (instRingFreeRing.{u2} β))))))) (FreeRing.map.{u1, u2} α β f) (FreeRing.of.{u1} α x)) (FreeRing.of.{u2} β (f x))
 Case conversion may be inaccurate. Consider using '#align free_ring.map_of FreeRing.map_ofₓ'. -/
 @[simp]
 theorem map_of (x : α) : map f (of x) = of (f x) :=

93287238

bump to nightly-2023-05-08-22

mathlib commit https://github.com/leanprover-community/mathlib/commit/08e1d8d4d989df3a6df86f385e9053ec8a372cc1

63e712c6

Diff

@@ -65,7 +65,7 @@ theorem of_injective : Function.Injective (of : α → FreeRing α) :=
 lean 3 declaration is
   forall {α : Type.{u1}} {C : (FreeRing.{u1} α) -> Prop} (z : FreeRing.{u1} α), (C (Neg.neg.{u1} (FreeRing.{u1} α) (SubNegMonoid.toHasNeg.{u1} (FreeRing.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeRing.{u1} α) (AddGroupWithOne.toAddGroup.{u1} (FreeRing.{u1} α) (AddCommGroupWithOne.toAddGroupWithOne.{u1} (FreeRing.{u1} α) (Ring.toAddCommGroupWithOne.{u1} (FreeRing.{u1} α) (FreeRing.ring.{u1} α)))))) (OfNat.ofNat.{u1} (FreeRing.{u1} α) 1 (OfNat.mk.{u1} (FreeRing.{u1} α) 1 (One.one.{u1} (FreeRing.{u1} α) (AddMonoidWithOne.toOne.{u1} (FreeRing.{u1} α) (AddGroupWithOne.toAddMonoidWithOne.{u1} (FreeRing.{u1} α) (AddCommGroupWithOne.toAddGroupWithOne.{u1} (FreeRing.{u1} α) (Ring.toAddCommGroupWithOne.{u1} (FreeRing.{u1} α) (FreeRing.ring.{u1} α)))))))))) -> (forall (b : α), C (FreeRing.of.{u1} α b)) -> (forall (x : FreeRing.{u1} α) (y : FreeRing.{u1} α), (C x) -> (C y) -> (C (HAdd.hAdd.{u1, u1, u1} (FreeRing.{u1} α) (FreeRing.{u1} α) (FreeRing.{u1} α) (instHAdd.{u1} (FreeRing.{u1} α) (Distrib.toHasAdd.{u1} (FreeRing.{u1} α) (Ring.toDistrib.{u1} (FreeRing.{u1} α) (FreeRing.ring.{u1} α)))) x y))) -> (forall (x : FreeRing.{u1} α) (y : FreeRing.{u1} α), (C x) -> (C y) -> (C (HMul.hMul.{u1, u1, u1} (FreeRing.{u1} α) (FreeRing.{u1} α) (FreeRing.{u1} α) (instHMul.{u1} (FreeRing.{u1} α) (Distrib.toHasMul.{u1} (FreeRing.{u1} α) (Ring.toDistrib.{u1} (FreeRing.{u1} α) (FreeRing.ring.{u1} α)))) x y))) -> (C z)
 but is expected to have type
-  forall {α : Type.{u1}} {C : (FreeRing.{u1} α) -> Prop} (z : FreeRing.{u1} α), (C (Neg.neg.{u1} (FreeRing.{u1} α) (Ring.toNeg.{u1} (FreeRing.{u1} α) (instRingFreeRing.{u1} α)) (OfNat.ofNat.{u1} (FreeRing.{u1} α) 1 (One.toOfNat1.{u1} (FreeRing.{u1} α) (NonAssocRing.toOne.{u1} (FreeRing.{u1} α) (Ring.toNonAssocRing.{u1} (FreeRing.{u1} α) (instRingFreeRing.{u1} α))))))) -> (forall (b : α), C (FreeRing.of.{u1} α b)) -> (forall (x : FreeRing.{u1} α) (y : FreeRing.{u1} α), (C x) -> (C y) -> (C (HAdd.hAdd.{u1, u1, u1} (FreeRing.{u1} α) (FreeRing.{u1} α) (FreeRing.{u1} α) (instHAdd.{u1} (FreeRing.{u1} α) (Distrib.toAdd.{u1} (FreeRing.{u1} α) (NonUnitalNonAssocSemiring.toDistrib.{u1} (FreeRing.{u1} α) (NonUnitalNonAssocRing.toNonUnitalNonAssocSemiring.{u1} (FreeRing.{u1} α) (NonAssocRing.toNonUnitalNonAssocRing.{u1} (FreeRing.{u1} α) (Ring.toNonAssocRing.{u1} (FreeRing.{u1} α) (instRingFreeRing.{u1} α))))))) x y))) -> (forall (x : FreeRing.{u1} α) (y : FreeRing.{u1} α), (C x) -> (C y) -> (C (HMul.hMul.{u1, u1, u1} (FreeRing.{u1} α) (FreeRing.{u1} α) (FreeRing.{u1} α) (instHMul.{u1} (FreeRing.{u1} α) (NonUnitalNonAssocRing.toMul.{u1} (FreeRing.{u1} α) (NonAssocRing.toNonUnitalNonAssocRing.{u1} (FreeRing.{u1} α) (Ring.toNonAssocRing.{u1} (FreeRing.{u1} α) (instRingFreeRing.{u1} α))))) x y))) -> (C z)
+  forall {α : Type.{u1}} {C : (FreeRing.{u1} α) -> Prop} (z : FreeRing.{u1} α), (C (Neg.neg.{u1} (FreeRing.{u1} α) (Ring.toNeg.{u1} (FreeRing.{u1} α) (instRingFreeRing.{u1} α)) (OfNat.ofNat.{u1} (FreeRing.{u1} α) 1 (One.toOfNat1.{u1} (FreeRing.{u1} α) (Semiring.toOne.{u1} (FreeRing.{u1} α) (Ring.toSemiring.{u1} (FreeRing.{u1} α) (instRingFreeRing.{u1} α))))))) -> (forall (b : α), C (FreeRing.of.{u1} α b)) -> (forall (x : FreeRing.{u1} α) (y : FreeRing.{u1} α), (C x) -> (C y) -> (C (HAdd.hAdd.{u1, u1, u1} (FreeRing.{u1} α) (FreeRing.{u1} α) (FreeRing.{u1} α) (instHAdd.{u1} (FreeRing.{u1} α) (Distrib.toAdd.{u1} (FreeRing.{u1} α) (NonUnitalNonAssocSemiring.toDistrib.{u1} (FreeRing.{u1} α) (NonUnitalNonAssocRing.toNonUnitalNonAssocSemiring.{u1} (FreeRing.{u1} α) (NonAssocRing.toNonUnitalNonAssocRing.{u1} (FreeRing.{u1} α) (Ring.toNonAssocRing.{u1} (FreeRing.{u1} α) (instRingFreeRing.{u1} α))))))) x y))) -> (forall (x : FreeRing.{u1} α) (y : FreeRing.{u1} α), (C x) -> (C y) -> (C (HMul.hMul.{u1, u1, u1} (FreeRing.{u1} α) (FreeRing.{u1} α) (FreeRing.{u1} α) (instHMul.{u1} (FreeRing.{u1} α) (NonUnitalNonAssocRing.toMul.{u1} (FreeRing.{u1} α) (NonAssocRing.toNonUnitalNonAssocRing.{u1} (FreeRing.{u1} α) (Ring.toNonAssocRing.{u1} (FreeRing.{u1} α) (instRingFreeRing.{u1} α))))) x y))) -> (C z)
 Case conversion may be inaccurate. Consider using '#align free_ring.induction_on FreeRing.induction_onₓ'. -/
 @[elab_as_elim]
 protected theorem induction_on {C : FreeRing α → Prop} (z : FreeRing α) (hn1 : C (-1))
@@ -92,7 +92,7 @@ def lift : (α → R) ≃ (FreeRing α →+* R) :=
 lean 3 declaration is
   forall {α : Type.{u1}} {R : Type.{u2}} [_inst_1 : Ring.{u2} R] (f : α -> R) (x : α), Eq.{succ u2} R (coeFn.{max (succ u1) (succ u2), max (succ u1) (succ u2)} (RingHom.{u1, u2} (FreeRing.{u1} α) R (NonAssocRing.toNonAssocSemiring.{u1} (FreeRing.{u1} α) (Ring.toNonAssocRing.{u1} (FreeRing.{u1} α) (FreeRing.ring.{u1} α))) (NonAssocRing.toNonAssocSemiring.{u2} R (Ring.toNonAssocRing.{u2} R _inst_1))) (fun (_x : RingHom.{u1, u2} (FreeRing.{u1} α) R (NonAssocRing.toNonAssocSemiring.{u1} (FreeRing.{u1} α) (Ring.toNonAssocRing.{u1} (FreeRing.{u1} α) (FreeRing.ring.{u1} α))) (NonAssocRing.toNonAssocSemiring.{u2} R (Ring.toNonAssocRing.{u2} R _inst_1))) => (FreeRing.{u1} α) -> R) (RingHom.hasCoeToFun.{u1, u2} (FreeRing.{u1} α) R (NonAssocRing.toNonAssocSemiring.{u1} (FreeRing.{u1} α) (Ring.toNonAssocRing.{u1} (FreeRing.{u1} α) (FreeRing.ring.{u1} α))) (NonAssocRing.toNonAssocSemiring.{u2} R (Ring.toNonAssocRing.{u2} R _inst_1))) (coeFn.{max 1 (succ u1) (succ u2), max (succ u1) (succ u2)} (Equiv.{max (succ u1) (succ u2), max (succ u1) (succ u2)} (α -> R) (RingHom.{u1, u2} (FreeRing.{u1} α) R (NonAssocRing.toNonAssocSemiring.{u1} (FreeRing.{u1} α) (Ring.toNonAssocRing.{u1} (FreeRing.{u1} α) (FreeRing.ring.{u1} α))) (NonAssocRing.toNonAssocSemiring.{u2} R (Ring.toNonAssocRing.{u2} R _inst_1)))) (fun (_x : Equiv.{max (succ u1) (succ u2), max (succ u1) (succ u2)} (α -> R) (RingHom.{u1, u2} (FreeRing.{u1} α) R (NonAssocRing.toNonAssocSemiring.{u1} (FreeRing.{u1} α) (Ring.toNonAssocRing.{u1} (FreeRing.{u1} α) (FreeRing.ring.{u1} α))) (NonAssocRing.toNonAssocSemiring.{u2} R (Ring.toNonAssocRing.{u2} R _inst_1)))) => (α -> R) -> (RingHom.{u1, u2} (FreeRing.{u1} α) R (NonAssocRing.toNonAssocSemiring.{u1} (FreeRing.{u1} α) (Ring.toNonAssocRing.{u1} (FreeRing.{u1} α) (FreeRing.ring.{u1} α))) (NonAssocRing.toNonAssocSemiring.{u2} R (Ring.toNonAssocRing.{u2} R _inst_1)))) (Equiv.hasCoeToFun.{max (succ u1) (succ u2), max (succ u1) (succ u2)} (α -> R) (RingHom.{u1, u2} (FreeRing.{u1} α) R (NonAssocRing.toNonAssocSemiring.{u1} (FreeRing.{u1} α) (Ring.toNonAssocRing.{u1} (FreeRing.{u1} α) (FreeRing.ring.{u1} α))) (NonAssocRing.toNonAssocSemiring.{u2} R (Ring.toNonAssocRing.{u2} R _inst_1)))) (FreeRing.lift.{u1, u2} α R _inst_1) f) (FreeRing.of.{u1} α x)) (f x)
 but is expected to have type
-  forall {α : Type.{u1}} {R : Type.{u2}} [_inst_1 : Ring.{u2} R] (f : α -> R) (x : α), Eq.{succ u2} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : FreeRing.{u1} α) => R) (FreeRing.of.{u1} α x)) (FunLike.coe.{max (succ u1) (succ u2), succ u1, succ u2} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : α -> R) => RingHom.{u1, u2} (FreeRing.{u1} α) R (NonAssocRing.toNonAssocSemiring.{u1} (FreeRing.{u1} α) (Ring.toNonAssocRing.{u1} (FreeRing.{u1} α) (instRingFreeRing.{u1} α))) (NonAssocRing.toNonAssocSemiring.{u2} R (Ring.toNonAssocRing.{u2} R _inst_1))) f) (FreeRing.{u1} α) (fun (_x : FreeRing.{u1} α) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : FreeRing.{u1} α) => R) _x) (MulHomClass.toFunLike.{max u1 u2, u1, u2} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : α -> R) => RingHom.{u1, u2} (FreeRing.{u1} α) R (NonAssocRing.toNonAssocSemiring.{u1} (FreeRing.{u1} α) (Ring.toNonAssocRing.{u1} (FreeRing.{u1} α) (instRingFreeRing.{u1} α))) (NonAssocRing.toNonAssocSemiring.{u2} R (Ring.toNonAssocRing.{u2} R _inst_1))) f) (FreeRing.{u1} α) R (NonUnitalNonAssocSemiring.toMul.{u1} (FreeRing.{u1} α) (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u1} (FreeRing.{u1} α) (NonAssocRing.toNonAssocSemiring.{u1} (FreeRing.{u1} α) (Ring.toNonAssocRing.{u1} (FreeRing.{u1} α) (instRingFreeRing.{u1} α))))) (NonUnitalNonAssocSemiring.toMul.{u2} R (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u2} R (NonAssocRing.toNonAssocSemiring.{u2} R (Ring.toNonAssocRing.{u2} R _inst_1)))) (NonUnitalRingHomClass.toMulHomClass.{max u1 u2, u1, u2} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : α -> R) => RingHom.{u1, u2} (FreeRing.{u1} α) R (NonAssocRing.toNonAssocSemiring.{u1} (FreeRing.{u1} α) (Ring.toNonAssocRing.{u1} (FreeRing.{u1} α) (instRingFreeRing.{u1} α))) (NonAssocRing.toNonAssocSemiring.{u2} R (Ring.toNonAssocRing.{u2} R _inst_1))) f) (FreeRing.{u1} α) R (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u1} (FreeRing.{u1} α) (NonAssocRing.toNonAssocSemiring.{u1} (FreeRing.{u1} α) (Ring.toNonAssocRing.{u1} (FreeRing.{u1} α) (instRingFreeRing.{u1} α)))) (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u2} R (NonAssocRing.toNonAssocSemiring.{u2} R (Ring.toNonAssocRing.{u2} R _inst_1))) (RingHomClass.toNonUnitalRingHomClass.{max u1 u2, u1, u2} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : α -> R) => RingHom.{u1, u2} (FreeRing.{u1} α) R (NonAssocRing.toNonAssocSemiring.{u1} (FreeRing.{u1} α) (Ring.toNonAssocRing.{u1} (FreeRing.{u1} α) (instRingFreeRing.{u1} α))) (NonAssocRing.toNonAssocSemiring.{u2} R (Ring.toNonAssocRing.{u2} R _inst_1))) f) (FreeRing.{u1} α) R (NonAssocRing.toNonAssocSemiring.{u1} (FreeRing.{u1} α) (Ring.toNonAssocRing.{u1} (FreeRing.{u1} α) (instRingFreeRing.{u1} α))) (NonAssocRing.toNonAssocSemiring.{u2} R (Ring.toNonAssocRing.{u2} R _inst_1)) (RingHom.instRingHomClassRingHom.{u1, u2} (FreeRing.{u1} α) R (NonAssocRing.toNonAssocSemiring.{u1} (FreeRing.{u1} α) (Ring.toNonAssocRing.{u1} (FreeRing.{u1} α) (instRingFreeRing.{u1} α))) (NonAssocRing.toNonAssocSemiring.{u2} R (Ring.toNonAssocRing.{u2} R _inst_1)))))) (FunLike.coe.{max (succ u2) (succ u1), max (succ u2) (succ u1), max (succ u2) (succ u1)} (Equiv.{max (succ u1) (succ u2), max (succ u2) (succ u1)} (α -> R) (RingHom.{u1, u2} (FreeRing.{u1} α) R (NonAssocRing.toNonAssocSemiring.{u1} (FreeRing.{u1} α) (Ring.toNonAssocRing.{u1} (FreeRing.{u1} α) (instRingFreeRing.{u1} α))) (NonAssocRing.toNonAssocSemiring.{u2} R (Ring.toNonAssocRing.{u2} R _inst_1)))) (α -> R) (fun (_x : α -> R) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : α -> R) => RingHom.{u1, u2} (FreeRing.{u1} α) R (NonAssocRing.toNonAssocSemiring.{u1} (FreeRing.{u1} α) (Ring.toNonAssocRing.{u1} (FreeRing.{u1} α) (instRingFreeRing.{u1} α))) (NonAssocRing.toNonAssocSemiring.{u2} R (Ring.toNonAssocRing.{u2} R _inst_1))) _x) (Equiv.instFunLikeEquiv.{max (succ u2) (succ u1), max (succ u2) (succ u1)} (α -> R) (RingHom.{u1, u2} (FreeRing.{u1} α) R (NonAssocRing.toNonAssocSemiring.{u1} (FreeRing.{u1} α) (Ring.toNonAssocRing.{u1} (FreeRing.{u1} α) (instRingFreeRing.{u1} α))) (NonAssocRing.toNonAssocSemiring.{u2} R (Ring.toNonAssocRing.{u2} R _inst_1)))) (FreeRing.lift.{u1, u2} α R _inst_1) f) (FreeRing.of.{u1} α x)) (f x)
+  forall {α : Type.{u1}} {R : Type.{u2}} [_inst_1 : Ring.{u2} R] (f : α -> R) (x : α), Eq.{succ u2} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : FreeRing.{u1} α) => R) (FreeRing.of.{u1} α x)) (FunLike.coe.{max (succ u1) (succ u2), succ u1, succ u2} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : α -> R) => RingHom.{u1, u2} (FreeRing.{u1} α) R (Semiring.toNonAssocSemiring.{u1} (FreeRing.{u1} α) (Ring.toSemiring.{u1} (FreeRing.{u1} α) (instRingFreeRing.{u1} α))) (Semiring.toNonAssocSemiring.{u2} R (Ring.toSemiring.{u2} R _inst_1))) f) (FreeRing.{u1} α) (fun (_x : FreeRing.{u1} α) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : FreeRing.{u1} α) => R) _x) (MulHomClass.toFunLike.{max u1 u2, u1, u2} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : α -> R) => RingHom.{u1, u2} (FreeRing.{u1} α) R (Semiring.toNonAssocSemiring.{u1} (FreeRing.{u1} α) (Ring.toSemiring.{u1} (FreeRing.{u1} α) (instRingFreeRing.{u1} α))) (Semiring.toNonAssocSemiring.{u2} R (Ring.toSemiring.{u2} R _inst_1))) f) (FreeRing.{u1} α) R (NonUnitalNonAssocSemiring.toMul.{u1} (FreeRing.{u1} α) (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u1} (FreeRing.{u1} α) (Semiring.toNonAssocSemiring.{u1} (FreeRing.{u1} α) (Ring.toSemiring.{u1} (FreeRing.{u1} α) (instRingFreeRing.{u1} α))))) (NonUnitalNonAssocSemiring.toMul.{u2} R (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u2} R (Semiring.toNonAssocSemiring.{u2} R (Ring.toSemiring.{u2} R _inst_1)))) (NonUnitalRingHomClass.toMulHomClass.{max u1 u2, u1, u2} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : α -> R) => RingHom.{u1, u2} (FreeRing.{u1} α) R (Semiring.toNonAssocSemiring.{u1} (FreeRing.{u1} α) (Ring.toSemiring.{u1} (FreeRing.{u1} α) (instRingFreeRing.{u1} α))) (Semiring.toNonAssocSemiring.{u2} R (Ring.toSemiring.{u2} R _inst_1))) f) (FreeRing.{u1} α) R (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u1} (FreeRing.{u1} α) (Semiring.toNonAssocSemiring.{u1} (FreeRing.{u1} α) (Ring.toSemiring.{u1} (FreeRing.{u1} α) (instRingFreeRing.{u1} α)))) (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u2} R (Semiring.toNonAssocSemiring.{u2} R (Ring.toSemiring.{u2} R _inst_1))) (RingHomClass.toNonUnitalRingHomClass.{max u1 u2, u1, u2} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : α -> R) => RingHom.{u1, u2} (FreeRing.{u1} α) R (Semiring.toNonAssocSemiring.{u1} (FreeRing.{u1} α) (Ring.toSemiring.{u1} (FreeRing.{u1} α) (instRingFreeRing.{u1} α))) (Semiring.toNonAssocSemiring.{u2} R (Ring.toSemiring.{u2} R _inst_1))) f) (FreeRing.{u1} α) R (Semiring.toNonAssocSemiring.{u1} (FreeRing.{u1} α) (Ring.toSemiring.{u1} (FreeRing.{u1} α) (instRingFreeRing.{u1} α))) (Semiring.toNonAssocSemiring.{u2} R (Ring.toSemiring.{u2} R _inst_1)) (RingHom.instRingHomClassRingHom.{u1, u2} (FreeRing.{u1} α) R (Semiring.toNonAssocSemiring.{u1} (FreeRing.{u1} α) (Ring.toSemiring.{u1} (FreeRing.{u1} α) (instRingFreeRing.{u1} α))) (Semiring.toNonAssocSemiring.{u2} R (Ring.toSemiring.{u2} R _inst_1)))))) (FunLike.coe.{max (succ u2) (succ u1), max (succ u2) (succ u1), max (succ u2) (succ u1)} (Equiv.{max (succ u1) (succ u2), max (succ u2) (succ u1)} (α -> R) (RingHom.{u1, u2} (FreeRing.{u1} α) R (Semiring.toNonAssocSemiring.{u1} (FreeRing.{u1} α) (Ring.toSemiring.{u1} (FreeRing.{u1} α) (instRingFreeRing.{u1} α))) (Semiring.toNonAssocSemiring.{u2} R (Ring.toSemiring.{u2} R _inst_1)))) (α -> R) (fun (_x : α -> R) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : α -> R) => RingHom.{u1, u2} (FreeRing.{u1} α) R (Semiring.toNonAssocSemiring.{u1} (FreeRing.{u1} α) (Ring.toSemiring.{u1} (FreeRing.{u1} α) (instRingFreeRing.{u1} α))) (Semiring.toNonAssocSemiring.{u2} R (Ring.toSemiring.{u2} R _inst_1))) _x) (Equiv.instFunLikeEquiv.{max (succ u2) (succ u1), max (succ u2) (succ u1)} (α -> R) (RingHom.{u1, u2} (FreeRing.{u1} α) R (Semiring.toNonAssocSemiring.{u1} (FreeRing.{u1} α) (Ring.toSemiring.{u1} (FreeRing.{u1} α) (instRingFreeRing.{u1} α))) (Semiring.toNonAssocSemiring.{u2} R (Ring.toSemiring.{u2} R _inst_1)))) (FreeRing.lift.{u1, u2} α R _inst_1) f) (FreeRing.of.{u1} α x)) (f x)
 Case conversion may be inaccurate. Consider using '#align free_ring.lift_of FreeRing.lift_ofₓ'. -/
 @[simp]
 theorem lift_of (x : α) : lift f (of x) = f x :=
@@ -128,7 +128,7 @@ def map : FreeRing α →+* FreeRing β :=
 lean 3 declaration is
   forall {α : Type.{u1}} {β : Type.{u2}} (f : α -> β) (x : α), Eq.{succ u2} (FreeRing.{u2} β) (coeFn.{max (succ u1) (succ u2), max (succ u1) (succ u2)} (RingHom.{u1, u2} (FreeRing.{u1} α) (FreeRing.{u2} β) (NonAssocRing.toNonAssocSemiring.{u1} (FreeRing.{u1} α) (Ring.toNonAssocRing.{u1} (FreeRing.{u1} α) (FreeRing.ring.{u1} α))) (NonAssocRing.toNonAssocSemiring.{u2} (FreeRing.{u2} β) (Ring.toNonAssocRing.{u2} (FreeRing.{u2} β) (FreeRing.ring.{u2} β)))) (fun (_x : RingHom.{u1, u2} (FreeRing.{u1} α) (FreeRing.{u2} β) (NonAssocRing.toNonAssocSemiring.{u1} (FreeRing.{u1} α) (Ring.toNonAssocRing.{u1} (FreeRing.{u1} α) (FreeRing.ring.{u1} α))) (NonAssocRing.toNonAssocSemiring.{u2} (FreeRing.{u2} β) (Ring.toNonAssocRing.{u2} (FreeRing.{u2} β) (FreeRing.ring.{u2} β)))) => (FreeRing.{u1} α) -> (FreeRing.{u2} β)) (RingHom.hasCoeToFun.{u1, u2} (FreeRing.{u1} α) (FreeRing.{u2} β) (NonAssocRing.toNonAssocSemiring.{u1} (FreeRing.{u1} α) (Ring.toNonAssocRing.{u1} (FreeRing.{u1} α) (FreeRing.ring.{u1} α))) (NonAssocRing.toNonAssocSemiring.{u2} (FreeRing.{u2} β) (Ring.toNonAssocRing.{u2} (FreeRing.{u2} β) (FreeRing.ring.{u2} β)))) (FreeRing.map.{u1, u2} α β f) (FreeRing.of.{u1} α x)) (FreeRing.of.{u2} β (f x))
 but is expected to have type
-  forall {α : Type.{u1}} {β : Type.{u2}} (f : α -> β) (x : α), Eq.{succ u2} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : FreeRing.{u1} α) => FreeRing.{u2} β) (FreeRing.of.{u1} α x)) (FunLike.coe.{max (succ u1) (succ u2), succ u1, succ u2} (RingHom.{u1, u2} (FreeRing.{u1} α) (FreeRing.{u2} β) (NonAssocRing.toNonAssocSemiring.{u1} (FreeRing.{u1} α) (Ring.toNonAssocRing.{u1} (FreeRing.{u1} α) (instRingFreeRing.{u1} α))) (NonAssocRing.toNonAssocSemiring.{u2} (FreeRing.{u2} β) (Ring.toNonAssocRing.{u2} (FreeRing.{u2} β) (instRingFreeRing.{u2} β)))) (FreeRing.{u1} α) (fun (_x : FreeRing.{u1} α) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : FreeRing.{u1} α) => FreeRing.{u2} β) _x) (MulHomClass.toFunLike.{max u1 u2, u1, u2} (RingHom.{u1, u2} (FreeRing.{u1} α) (FreeRing.{u2} β) (NonAssocRing.toNonAssocSemiring.{u1} (FreeRing.{u1} α) (Ring.toNonAssocRing.{u1} (FreeRing.{u1} α) (instRingFreeRing.{u1} α))) (NonAssocRing.toNonAssocSemiring.{u2} (FreeRing.{u2} β) (Ring.toNonAssocRing.{u2} (FreeRing.{u2} β) (instRingFreeRing.{u2} β)))) (FreeRing.{u1} α) (FreeRing.{u2} β) (NonUnitalNonAssocSemiring.toMul.{u1} (FreeRing.{u1} α) (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u1} (FreeRing.{u1} α) (NonAssocRing.toNonAssocSemiring.{u1} (FreeRing.{u1} α) (Ring.toNonAssocRing.{u1} (FreeRing.{u1} α) (instRingFreeRing.{u1} α))))) (NonUnitalNonAssocSemiring.toMul.{u2} (FreeRing.{u2} β) (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u2} (FreeRing.{u2} β) (NonAssocRing.toNonAssocSemiring.{u2} (FreeRing.{u2} β) (Ring.toNonAssocRing.{u2} (FreeRing.{u2} β) (instRingFreeRing.{u2} β))))) (NonUnitalRingHomClass.toMulHomClass.{max u1 u2, u1, u2} (RingHom.{u1, u2} (FreeRing.{u1} α) (FreeRing.{u2} β) (NonAssocRing.toNonAssocSemiring.{u1} (FreeRing.{u1} α) (Ring.toNonAssocRing.{u1} (FreeRing.{u1} α) (instRingFreeRing.{u1} α))) (NonAssocRing.toNonAssocSemiring.{u2} (FreeRing.{u2} β) (Ring.toNonAssocRing.{u2} (FreeRing.{u2} β) (instRingFreeRing.{u2} β)))) (FreeRing.{u1} α) (FreeRing.{u2} β) (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u1} (FreeRing.{u1} α) (NonAssocRing.toNonAssocSemiring.{u1} (FreeRing.{u1} α) (Ring.toNonAssocRing.{u1} (FreeRing.{u1} α) (instRingFreeRing.{u1} α)))) (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u2} (FreeRing.{u2} β) (NonAssocRing.toNonAssocSemiring.{u2} (FreeRing.{u2} β) (Ring.toNonAssocRing.{u2} (FreeRing.{u2} β) (instRingFreeRing.{u2} β)))) (RingHomClass.toNonUnitalRingHomClass.{max u1 u2, u1, u2} (RingHom.{u1, u2} (FreeRing.{u1} α) (FreeRing.{u2} β) (NonAssocRing.toNonAssocSemiring.{u1} (FreeRing.{u1} α) (Ring.toNonAssocRing.{u1} (FreeRing.{u1} α) (instRingFreeRing.{u1} α))) (NonAssocRing.toNonAssocSemiring.{u2} (FreeRing.{u2} β) (Ring.toNonAssocRing.{u2} (FreeRing.{u2} β) (instRingFreeRing.{u2} β)))) (FreeRing.{u1} α) (FreeRing.{u2} β) (NonAssocRing.toNonAssocSemiring.{u1} (FreeRing.{u1} α) (Ring.toNonAssocRing.{u1} (FreeRing.{u1} α) (instRingFreeRing.{u1} α))) (NonAssocRing.toNonAssocSemiring.{u2} (FreeRing.{u2} β) (Ring.toNonAssocRing.{u2} (FreeRing.{u2} β) (instRingFreeRing.{u2} β))) (RingHom.instRingHomClassRingHom.{u1, u2} (FreeRing.{u1} α) (FreeRing.{u2} β) (NonAssocRing.toNonAssocSemiring.{u1} (FreeRing.{u1} α) (Ring.toNonAssocRing.{u1} (FreeRing.{u1} α) (instRingFreeRing.{u1} α))) (NonAssocRing.toNonAssocSemiring.{u2} (FreeRing.{u2} β) (Ring.toNonAssocRing.{u2} (FreeRing.{u2} β) (instRingFreeRing.{u2} β))))))) (FreeRing.map.{u1, u2} α β f) (FreeRing.of.{u1} α x)) (FreeRing.of.{u2} β (f x))
+  forall {α : Type.{u1}} {β : Type.{u2}} (f : α -> β) (x : α), Eq.{succ u2} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : FreeRing.{u1} α) => FreeRing.{u2} β) (FreeRing.of.{u1} α x)) (FunLike.coe.{max (succ u1) (succ u2), succ u1, succ u2} (RingHom.{u1, u2} (FreeRing.{u1} α) (FreeRing.{u2} β) (Semiring.toNonAssocSemiring.{u1} (FreeRing.{u1} α) (Ring.toSemiring.{u1} (FreeRing.{u1} α) (instRingFreeRing.{u1} α))) (Semiring.toNonAssocSemiring.{u2} (FreeRing.{u2} β) (Ring.toSemiring.{u2} (FreeRing.{u2} β) (instRingFreeRing.{u2} β)))) (FreeRing.{u1} α) (fun (_x : FreeRing.{u1} α) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : FreeRing.{u1} α) => FreeRing.{u2} β) _x) (MulHomClass.toFunLike.{max u1 u2, u1, u2} (RingHom.{u1, u2} (FreeRing.{u1} α) (FreeRing.{u2} β) (Semiring.toNonAssocSemiring.{u1} (FreeRing.{u1} α) (Ring.toSemiring.{u1} (FreeRing.{u1} α) (instRingFreeRing.{u1} α))) (Semiring.toNonAssocSemiring.{u2} (FreeRing.{u2} β) (Ring.toSemiring.{u2} (FreeRing.{u2} β) (instRingFreeRing.{u2} β)))) (FreeRing.{u1} α) (FreeRing.{u2} β) (NonUnitalNonAssocSemiring.toMul.{u1} (FreeRing.{u1} α) (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u1} (FreeRing.{u1} α) (Semiring.toNonAssocSemiring.{u1} (FreeRing.{u1} α) (Ring.toSemiring.{u1} (FreeRing.{u1} α) (instRingFreeRing.{u1} α))))) (NonUnitalNonAssocSemiring.toMul.{u2} (FreeRing.{u2} β) (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u2} (FreeRing.{u2} β) (Semiring.toNonAssocSemiring.{u2} (FreeRing.{u2} β) (Ring.toSemiring.{u2} (FreeRing.{u2} β) (instRingFreeRing.{u2} β))))) (NonUnitalRingHomClass.toMulHomClass.{max u1 u2, u1, u2} (RingHom.{u1, u2} (FreeRing.{u1} α) (FreeRing.{u2} β) (Semiring.toNonAssocSemiring.{u1} (FreeRing.{u1} α) (Ring.toSemiring.{u1} (FreeRing.{u1} α) (instRingFreeRing.{u1} α))) (Semiring.toNonAssocSemiring.{u2} (FreeRing.{u2} β) (Ring.toSemiring.{u2} (FreeRing.{u2} β) (instRingFreeRing.{u2} β)))) (FreeRing.{u1} α) (FreeRing.{u2} β) (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u1} (FreeRing.{u1} α) (Semiring.toNonAssocSemiring.{u1} (FreeRing.{u1} α) (Ring.toSemiring.{u1} (FreeRing.{u1} α) (instRingFreeRing.{u1} α)))) (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u2} (FreeRing.{u2} β) (Semiring.toNonAssocSemiring.{u2} (FreeRing.{u2} β) (Ring.toSemiring.{u2} (FreeRing.{u2} β) (instRingFreeRing.{u2} β)))) (RingHomClass.toNonUnitalRingHomClass.{max u1 u2, u1, u2} (RingHom.{u1, u2} (FreeRing.{u1} α) (FreeRing.{u2} β) (Semiring.toNonAssocSemiring.{u1} (FreeRing.{u1} α) (Ring.toSemiring.{u1} (FreeRing.{u1} α) (instRingFreeRing.{u1} α))) (Semiring.toNonAssocSemiring.{u2} (FreeRing.{u2} β) (Ring.toSemiring.{u2} (FreeRing.{u2} β) (instRingFreeRing.{u2} β)))) (FreeRing.{u1} α) (FreeRing.{u2} β) (Semiring.toNonAssocSemiring.{u1} (FreeRing.{u1} α) (Ring.toSemiring.{u1} (FreeRing.{u1} α) (instRingFreeRing.{u1} α))) (Semiring.toNonAssocSemiring.{u2} (FreeRing.{u2} β) (Ring.toSemiring.{u2} (FreeRing.{u2} β) (instRingFreeRing.{u2} β))) (RingHom.instRingHomClassRingHom.{u1, u2} (FreeRing.{u1} α) (FreeRing.{u2} β) (Semiring.toNonAssocSemiring.{u1} (FreeRing.{u1} α) (Ring.toSemiring.{u1} (FreeRing.{u1} α) (instRingFreeRing.{u1} α))) (Semiring.toNonAssocSemiring.{u2} (FreeRing.{u2} β) (Ring.toSemiring.{u2} (FreeRing.{u2} β) (instRingFreeRing.{u2} β))))))) (FreeRing.map.{u1, u2} α β f) (FreeRing.of.{u1} α x)) (FreeRing.of.{u2} β (f x))
 Case conversion may be inaccurate. Consider using '#align free_ring.map_of FreeRing.map_ofₓ'. -/
 @[simp]
 theorem map_of (x : α) : map f (of x) = of (f x) :=

93287238

bump to nightly-2023-03-27-02

mathlib commit https://github.com/leanprover-community/mathlib/commit/ce86f4e05e9a9b8da5e316b22c76ce76440c56a1

0e4ebd8c

Diff

@@ -63,7 +63,7 @@ theorem of_injective : Function.Injective (of : α → FreeRing α) :=
 
 /- warning: free_ring.induction_on -> FreeRing.induction_on is a dubious translation:
 lean 3 declaration is
-  forall {α : Type.{u1}} {C : (FreeRing.{u1} α) -> Prop} (z : FreeRing.{u1} α), (C (Neg.neg.{u1} (FreeRing.{u1} α) (SubNegMonoid.toHasNeg.{u1} (FreeRing.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeRing.{u1} α) (AddGroupWithOne.toAddGroup.{u1} (FreeRing.{u1} α) (NonAssocRing.toAddGroupWithOne.{u1} (FreeRing.{u1} α) (Ring.toNonAssocRing.{u1} (FreeRing.{u1} α) (FreeRing.ring.{u1} α)))))) (OfNat.ofNat.{u1} (FreeRing.{u1} α) 1 (OfNat.mk.{u1} (FreeRing.{u1} α) 1 (One.one.{u1} (FreeRing.{u1} α) (AddMonoidWithOne.toOne.{u1} (FreeRing.{u1} α) (AddGroupWithOne.toAddMonoidWithOne.{u1} (FreeRing.{u1} α) (NonAssocRing.toAddGroupWithOne.{u1} (FreeRing.{u1} α) (Ring.toNonAssocRing.{u1} (FreeRing.{u1} α) (FreeRing.ring.{u1} α)))))))))) -> (forall (b : α), C (FreeRing.of.{u1} α b)) -> (forall (x : FreeRing.{u1} α) (y : FreeRing.{u1} α), (C x) -> (C y) -> (C (HAdd.hAdd.{u1, u1, u1} (FreeRing.{u1} α) (FreeRing.{u1} α) (FreeRing.{u1} α) (instHAdd.{u1} (FreeRing.{u1} α) (Distrib.toHasAdd.{u1} (FreeRing.{u1} α) (Ring.toDistrib.{u1} (FreeRing.{u1} α) (FreeRing.ring.{u1} α)))) x y))) -> (forall (x : FreeRing.{u1} α) (y : FreeRing.{u1} α), (C x) -> (C y) -> (C (HMul.hMul.{u1, u1, u1} (FreeRing.{u1} α) (FreeRing.{u1} α) (FreeRing.{u1} α) (instHMul.{u1} (FreeRing.{u1} α) (Distrib.toHasMul.{u1} (FreeRing.{u1} α) (Ring.toDistrib.{u1} (FreeRing.{u1} α) (FreeRing.ring.{u1} α)))) x y))) -> (C z)
+  forall {α : Type.{u1}} {C : (FreeRing.{u1} α) -> Prop} (z : FreeRing.{u1} α), (C (Neg.neg.{u1} (FreeRing.{u1} α) (SubNegMonoid.toHasNeg.{u1} (FreeRing.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeRing.{u1} α) (AddGroupWithOne.toAddGroup.{u1} (FreeRing.{u1} α) (AddCommGroupWithOne.toAddGroupWithOne.{u1} (FreeRing.{u1} α) (Ring.toAddCommGroupWithOne.{u1} (FreeRing.{u1} α) (FreeRing.ring.{u1} α)))))) (OfNat.ofNat.{u1} (FreeRing.{u1} α) 1 (OfNat.mk.{u1} (FreeRing.{u1} α) 1 (One.one.{u1} (FreeRing.{u1} α) (AddMonoidWithOne.toOne.{u1} (FreeRing.{u1} α) (AddGroupWithOne.toAddMonoidWithOne.{u1} (FreeRing.{u1} α) (AddCommGroupWithOne.toAddGroupWithOne.{u1} (FreeRing.{u1} α) (Ring.toAddCommGroupWithOne.{u1} (FreeRing.{u1} α) (FreeRing.ring.{u1} α)))))))))) -> (forall (b : α), C (FreeRing.of.{u1} α b)) -> (forall (x : FreeRing.{u1} α) (y : FreeRing.{u1} α), (C x) -> (C y) -> (C (HAdd.hAdd.{u1, u1, u1} (FreeRing.{u1} α) (FreeRing.{u1} α) (FreeRing.{u1} α) (instHAdd.{u1} (FreeRing.{u1} α) (Distrib.toHasAdd.{u1} (FreeRing.{u1} α) (Ring.toDistrib.{u1} (FreeRing.{u1} α) (FreeRing.ring.{u1} α)))) x y))) -> (forall (x : FreeRing.{u1} α) (y : FreeRing.{u1} α), (C x) -> (C y) -> (C (HMul.hMul.{u1, u1, u1} (FreeRing.{u1} α) (FreeRing.{u1} α) (FreeRing.{u1} α) (instHMul.{u1} (FreeRing.{u1} α) (Distrib.toHasMul.{u1} (FreeRing.{u1} α) (Ring.toDistrib.{u1} (FreeRing.{u1} α) (FreeRing.ring.{u1} α)))) x y))) -> (C z)
 but is expected to have type
   forall {α : Type.{u1}} {C : (FreeRing.{u1} α) -> Prop} (z : FreeRing.{u1} α), (C (Neg.neg.{u1} (FreeRing.{u1} α) (Ring.toNeg.{u1} (FreeRing.{u1} α) (instRingFreeRing.{u1} α)) (OfNat.ofNat.{u1} (FreeRing.{u1} α) 1 (One.toOfNat1.{u1} (FreeRing.{u1} α) (NonAssocRing.toOne.{u1} (FreeRing.{u1} α) (Ring.toNonAssocRing.{u1} (FreeRing.{u1} α) (instRingFreeRing.{u1} α))))))) -> (forall (b : α), C (FreeRing.of.{u1} α b)) -> (forall (x : FreeRing.{u1} α) (y : FreeRing.{u1} α), (C x) -> (C y) -> (C (HAdd.hAdd.{u1, u1, u1} (FreeRing.{u1} α) (FreeRing.{u1} α) (FreeRing.{u1} α) (instHAdd.{u1} (FreeRing.{u1} α) (Distrib.toAdd.{u1} (FreeRing.{u1} α) (NonUnitalNonAssocSemiring.toDistrib.{u1} (FreeRing.{u1} α) (NonUnitalNonAssocRing.toNonUnitalNonAssocSemiring.{u1} (FreeRing.{u1} α) (NonAssocRing.toNonUnitalNonAssocRing.{u1} (FreeRing.{u1} α) (Ring.toNonAssocRing.{u1} (FreeRing.{u1} α) (instRingFreeRing.{u1} α))))))) x y))) -> (forall (x : FreeRing.{u1} α) (y : FreeRing.{u1} α), (C x) -> (C y) -> (C (HMul.hMul.{u1, u1, u1} (FreeRing.{u1} α) (FreeRing.{u1} α) (FreeRing.{u1} α) (instHMul.{u1} (FreeRing.{u1} α) (NonUnitalNonAssocRing.toMul.{u1} (FreeRing.{u1} α) (NonAssocRing.toNonUnitalNonAssocRing.{u1} (FreeRing.{u1} α) (Ring.toNonAssocRing.{u1} (FreeRing.{u1} α) (instRingFreeRing.{u1} α))))) x y))) -> (C z)
 Case conversion may be inaccurate. Consider using '#align free_ring.induction_on FreeRing.induction_onₓ'. -/

93287238

bump to nightly-2023-03-19-03

mathlib commit https://github.com/leanprover-community/mathlib/commit/1f4705ccdfe1e557fc54a0ce081a05e33d2e6240

b19efad4

Diff

@@ -4,7 +4,7 @@ Released under Apache 2.0 license as described in the file LICENSE.
 Authors: Kenny Lau, Johan Commelin
 
 ! This file was ported from Lean 3 source module ring_theory.free_ring
-! leanprover-community/mathlib commit d6814c584384ddf2825ff038e868451a7c956f31
+! leanprover-community/mathlib commit 932872382355f00112641d305ba0619305dc8642
 ! Please do not edit these lines, except to modify the commit id
 ! if you have ported upstream changes.
 -/
@@ -13,6 +13,9 @@ import Mathbin.GroupTheory.FreeAbelianGroup
 /-!
 # Free rings
 
+> THIS FILE IS SYNCHRONIZED WITH MATHLIB4.
+> Any changes to this file require a corresponding PR to mathlib4.
+
 The theory of the free ring over a type.
 
 ## Main definitions

d6814c58

bump to nightly-2023-03-15-14

mathlib commit https://github.com/leanprover-community/mathlib/commit/1a313d8bba1bad05faba71a4a4e9742ab5bd9efd

8a291292

Diff

@@ -34,24 +34,36 @@ free ring
 
 universe u v
 
+#print FreeRing /-
 /-- The free ring over a type `α`. -/
 def FreeRing (α : Type u) : Type u :=
   FreeAbelianGroup <| FreeMonoid α deriving Ring, Inhabited
 #align free_ring FreeRing
+-/
 
 namespace FreeRing
 
 variable {α : Type u}
 
+#print FreeRing.of /-
 /-- The canonical map from α to `free_ring α`. -/
 def of (x : α) : FreeRing α :=
   FreeAbelianGroup.of (FreeMonoid.of x)
 #align free_ring.of FreeRing.of
+-/
 
+#print FreeRing.of_injective /-
 theorem of_injective : Function.Injective (of : α → FreeRing α) :=
   FreeAbelianGroup.of_injective.comp FreeMonoid.of_injective
 #align free_ring.of_injective FreeRing.of_injective
+-/
 
+/- warning: free_ring.induction_on -> FreeRing.induction_on is a dubious translation:
+lean 3 declaration is
+  forall {α : Type.{u1}} {C : (FreeRing.{u1} α) -> Prop} (z : FreeRing.{u1} α), (C (Neg.neg.{u1} (FreeRing.{u1} α) (SubNegMonoid.toHasNeg.{u1} (FreeRing.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeRing.{u1} α) (AddGroupWithOne.toAddGroup.{u1} (FreeRing.{u1} α) (NonAssocRing.toAddGroupWithOne.{u1} (FreeRing.{u1} α) (Ring.toNonAssocRing.{u1} (FreeRing.{u1} α) (FreeRing.ring.{u1} α)))))) (OfNat.ofNat.{u1} (FreeRing.{u1} α) 1 (OfNat.mk.{u1} (FreeRing.{u1} α) 1 (One.one.{u1} (FreeRing.{u1} α) (AddMonoidWithOne.toOne.{u1} (FreeRing.{u1} α) (AddGroupWithOne.toAddMonoidWithOne.{u1} (FreeRing.{u1} α) (NonAssocRing.toAddGroupWithOne.{u1} (FreeRing.{u1} α) (Ring.toNonAssocRing.{u1} (FreeRing.{u1} α) (FreeRing.ring.{u1} α)))))))))) -> (forall (b : α), C (FreeRing.of.{u1} α b)) -> (forall (x : FreeRing.{u1} α) (y : FreeRing.{u1} α), (C x) -> (C y) -> (C (HAdd.hAdd.{u1, u1, u1} (FreeRing.{u1} α) (FreeRing.{u1} α) (FreeRing.{u1} α) (instHAdd.{u1} (FreeRing.{u1} α) (Distrib.toHasAdd.{u1} (FreeRing.{u1} α) (Ring.toDistrib.{u1} (FreeRing.{u1} α) (FreeRing.ring.{u1} α)))) x y))) -> (forall (x : FreeRing.{u1} α) (y : FreeRing.{u1} α), (C x) -> (C y) -> (C (HMul.hMul.{u1, u1, u1} (FreeRing.{u1} α) (FreeRing.{u1} α) (FreeRing.{u1} α) (instHMul.{u1} (FreeRing.{u1} α) (Distrib.toHasMul.{u1} (FreeRing.{u1} α) (Ring.toDistrib.{u1} (FreeRing.{u1} α) (FreeRing.ring.{u1} α)))) x y))) -> (C z)
+but is expected to have type
+  forall {α : Type.{u1}} {C : (FreeRing.{u1} α) -> Prop} (z : FreeRing.{u1} α), (C (Neg.neg.{u1} (FreeRing.{u1} α) (Ring.toNeg.{u1} (FreeRing.{u1} α) (instRingFreeRing.{u1} α)) (OfNat.ofNat.{u1} (FreeRing.{u1} α) 1 (One.toOfNat1.{u1} (FreeRing.{u1} α) (NonAssocRing.toOne.{u1} (FreeRing.{u1} α) (Ring.toNonAssocRing.{u1} (FreeRing.{u1} α) (instRingFreeRing.{u1} α))))))) -> (forall (b : α), C (FreeRing.of.{u1} α b)) -> (forall (x : FreeRing.{u1} α) (y : FreeRing.{u1} α), (C x) -> (C y) -> (C (HAdd.hAdd.{u1, u1, u1} (FreeRing.{u1} α) (FreeRing.{u1} α) (FreeRing.{u1} α) (instHAdd.{u1} (FreeRing.{u1} α) (Distrib.toAdd.{u1} (FreeRing.{u1} α) (NonUnitalNonAssocSemiring.toDistrib.{u1} (FreeRing.{u1} α) (NonUnitalNonAssocRing.toNonUnitalNonAssocSemiring.{u1} (FreeRing.{u1} α) (NonAssocRing.toNonUnitalNonAssocRing.{u1} (FreeRing.{u1} α) (Ring.toNonAssocRing.{u1} (FreeRing.{u1} α) (instRingFreeRing.{u1} α))))))) x y))) -> (forall (x : FreeRing.{u1} α) (y : FreeRing.{u1} α), (C x) -> (C y) -> (C (HMul.hMul.{u1, u1, u1} (FreeRing.{u1} α) (FreeRing.{u1} α) (FreeRing.{u1} α) (instHMul.{u1} (FreeRing.{u1} α) (NonUnitalNonAssocRing.toMul.{u1} (FreeRing.{u1} α) (NonAssocRing.toNonUnitalNonAssocRing.{u1} (FreeRing.{u1} α) (Ring.toNonAssocRing.{u1} (FreeRing.{u1} α) (instRingFreeRing.{u1} α))))) x y))) -> (C z)
+Case conversion may be inaccurate. Consider using '#align free_ring.induction_on FreeRing.induction_onₓ'. -/
 @[elab_as_elim]
 protected theorem induction_on {C : FreeRing α → Prop} (z : FreeRing α) (hn1 : C (-1))
     (hb : ∀ b, C (of b)) (ha : ∀ x y, C x → C y → C (x + y)) (hm : ∀ x y, C x → C y → C (x * y)) :
@@ -66,35 +78,55 @@ section lift
 
 variable {R : Type v} [Ring R] (f : α → R)
 
+#print FreeRing.lift /-
 /-- The ring homomorphism `free_ring α →+* R` induced from a map `α → R`. -/
 def lift : (α → R) ≃ (FreeRing α →+* R) :=
   FreeMonoid.lift.trans FreeAbelianGroup.liftMonoid
 #align free_ring.lift FreeRing.lift
+-/
 
+/- warning: free_ring.lift_of -> FreeRing.lift_of is a dubious translation:
+lean 3 declaration is
+  forall {α : Type.{u1}} {R : Type.{u2}} [_inst_1 : Ring.{u2} R] (f : α -> R) (x : α), Eq.{succ u2} R (coeFn.{max (succ u1) (succ u2), max (succ u1) (succ u2)} (RingHom.{u1, u2} (FreeRing.{u1} α) R (NonAssocRing.toNonAssocSemiring.{u1} (FreeRing.{u1} α) (Ring.toNonAssocRing.{u1} (FreeRing.{u1} α) (FreeRing.ring.{u1} α))) (NonAssocRing.toNonAssocSemiring.{u2} R (Ring.toNonAssocRing.{u2} R _inst_1))) (fun (_x : RingHom.{u1, u2} (FreeRing.{u1} α) R (NonAssocRing.toNonAssocSemiring.{u1} (FreeRing.{u1} α) (Ring.toNonAssocRing.{u1} (FreeRing.{u1} α) (FreeRing.ring.{u1} α))) (NonAssocRing.toNonAssocSemiring.{u2} R (Ring.toNonAssocRing.{u2} R _inst_1))) => (FreeRing.{u1} α) -> R) (RingHom.hasCoeToFun.{u1, u2} (FreeRing.{u1} α) R (NonAssocRing.toNonAssocSemiring.{u1} (FreeRing.{u1} α) (Ring.toNonAssocRing.{u1} (FreeRing.{u1} α) (FreeRing.ring.{u1} α))) (NonAssocRing.toNonAssocSemiring.{u2} R (Ring.toNonAssocRing.{u2} R _inst_1))) (coeFn.{max 1 (succ u1) (succ u2), max (succ u1) (succ u2)} (Equiv.{max (succ u1) (succ u2), max (succ u1) (succ u2)} (α -> R) (RingHom.{u1, u2} (FreeRing.{u1} α) R (NonAssocRing.toNonAssocSemiring.{u1} (FreeRing.{u1} α) (Ring.toNonAssocRing.{u1} (FreeRing.{u1} α) (FreeRing.ring.{u1} α))) (NonAssocRing.toNonAssocSemiring.{u2} R (Ring.toNonAssocRing.{u2} R _inst_1)))) (fun (_x : Equiv.{max (succ u1) (succ u2), max (succ u1) (succ u2)} (α -> R) (RingHom.{u1, u2} (FreeRing.{u1} α) R (NonAssocRing.toNonAssocSemiring.{u1} (FreeRing.{u1} α) (Ring.toNonAssocRing.{u1} (FreeRing.{u1} α) (FreeRing.ring.{u1} α))) (NonAssocRing.toNonAssocSemiring.{u2} R (Ring.toNonAssocRing.{u2} R _inst_1)))) => (α -> R) -> (RingHom.{u1, u2} (FreeRing.{u1} α) R (NonAssocRing.toNonAssocSemiring.{u1} (FreeRing.{u1} α) (Ring.toNonAssocRing.{u1} (FreeRing.{u1} α) (FreeRing.ring.{u1} α))) (NonAssocRing.toNonAssocSemiring.{u2} R (Ring.toNonAssocRing.{u2} R _inst_1)))) (Equiv.hasCoeToFun.{max (succ u1) (succ u2), max (succ u1) (succ u2)} (α -> R) (RingHom.{u1, u2} (FreeRing.{u1} α) R (NonAssocRing.toNonAssocSemiring.{u1} (FreeRing.{u1} α) (Ring.toNonAssocRing.{u1} (FreeRing.{u1} α) (FreeRing.ring.{u1} α))) (NonAssocRing.toNonAssocSemiring.{u2} R (Ring.toNonAssocRing.{u2} R _inst_1)))) (FreeRing.lift.{u1, u2} α R _inst_1) f) (FreeRing.of.{u1} α x)) (f x)
+but is expected to have type
+  forall {α : Type.{u1}} {R : Type.{u2}} [_inst_1 : Ring.{u2} R] (f : α -> R) (x : α), Eq.{succ u2} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : FreeRing.{u1} α) => R) (FreeRing.of.{u1} α x)) (FunLike.coe.{max (succ u1) (succ u2), succ u1, succ u2} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : α -> R) => RingHom.{u1, u2} (FreeRing.{u1} α) R (NonAssocRing.toNonAssocSemiring.{u1} (FreeRing.{u1} α) (Ring.toNonAssocRing.{u1} (FreeRing.{u1} α) (instRingFreeRing.{u1} α))) (NonAssocRing.toNonAssocSemiring.{u2} R (Ring.toNonAssocRing.{u2} R _inst_1))) f) (FreeRing.{u1} α) (fun (_x : FreeRing.{u1} α) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : FreeRing.{u1} α) => R) _x) (MulHomClass.toFunLike.{max u1 u2, u1, u2} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : α -> R) => RingHom.{u1, u2} (FreeRing.{u1} α) R (NonAssocRing.toNonAssocSemiring.{u1} (FreeRing.{u1} α) (Ring.toNonAssocRing.{u1} (FreeRing.{u1} α) (instRingFreeRing.{u1} α))) (NonAssocRing.toNonAssocSemiring.{u2} R (Ring.toNonAssocRing.{u2} R _inst_1))) f) (FreeRing.{u1} α) R (NonUnitalNonAssocSemiring.toMul.{u1} (FreeRing.{u1} α) (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u1} (FreeRing.{u1} α) (NonAssocRing.toNonAssocSemiring.{u1} (FreeRing.{u1} α) (Ring.toNonAssocRing.{u1} (FreeRing.{u1} α) (instRingFreeRing.{u1} α))))) (NonUnitalNonAssocSemiring.toMul.{u2} R (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u2} R (NonAssocRing.toNonAssocSemiring.{u2} R (Ring.toNonAssocRing.{u2} R _inst_1)))) (NonUnitalRingHomClass.toMulHomClass.{max u1 u2, u1, u2} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : α -> R) => RingHom.{u1, u2} (FreeRing.{u1} α) R (NonAssocRing.toNonAssocSemiring.{u1} (FreeRing.{u1} α) (Ring.toNonAssocRing.{u1} (FreeRing.{u1} α) (instRingFreeRing.{u1} α))) (NonAssocRing.toNonAssocSemiring.{u2} R (Ring.toNonAssocRing.{u2} R _inst_1))) f) (FreeRing.{u1} α) R (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u1} (FreeRing.{u1} α) (NonAssocRing.toNonAssocSemiring.{u1} (FreeRing.{u1} α) (Ring.toNonAssocRing.{u1} (FreeRing.{u1} α) (instRingFreeRing.{u1} α)))) (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u2} R (NonAssocRing.toNonAssocSemiring.{u2} R (Ring.toNonAssocRing.{u2} R _inst_1))) (RingHomClass.toNonUnitalRingHomClass.{max u1 u2, u1, u2} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : α -> R) => RingHom.{u1, u2} (FreeRing.{u1} α) R (NonAssocRing.toNonAssocSemiring.{u1} (FreeRing.{u1} α) (Ring.toNonAssocRing.{u1} (FreeRing.{u1} α) (instRingFreeRing.{u1} α))) (NonAssocRing.toNonAssocSemiring.{u2} R (Ring.toNonAssocRing.{u2} R _inst_1))) f) (FreeRing.{u1} α) R (NonAssocRing.toNonAssocSemiring.{u1} (FreeRing.{u1} α) (Ring.toNonAssocRing.{u1} (FreeRing.{u1} α) (instRingFreeRing.{u1} α))) (NonAssocRing.toNonAssocSemiring.{u2} R (Ring.toNonAssocRing.{u2} R _inst_1)) (RingHom.instRingHomClassRingHom.{u1, u2} (FreeRing.{u1} α) R (NonAssocRing.toNonAssocSemiring.{u1} (FreeRing.{u1} α) (Ring.toNonAssocRing.{u1} (FreeRing.{u1} α) (instRingFreeRing.{u1} α))) (NonAssocRing.toNonAssocSemiring.{u2} R (Ring.toNonAssocRing.{u2} R _inst_1)))))) (FunLike.coe.{max (succ u2) (succ u1), max (succ u2) (succ u1), max (succ u2) (succ u1)} (Equiv.{max (succ u1) (succ u2), max (succ u2) (succ u1)} (α -> R) (RingHom.{u1, u2} (FreeRing.{u1} α) R (NonAssocRing.toNonAssocSemiring.{u1} (FreeRing.{u1} α) (Ring.toNonAssocRing.{u1} (FreeRing.{u1} α) (instRingFreeRing.{u1} α))) (NonAssocRing.toNonAssocSemiring.{u2} R (Ring.toNonAssocRing.{u2} R _inst_1)))) (α -> R) (fun (_x : α -> R) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : α -> R) => RingHom.{u1, u2} (FreeRing.{u1} α) R (NonAssocRing.toNonAssocSemiring.{u1} (FreeRing.{u1} α) (Ring.toNonAssocRing.{u1} (FreeRing.{u1} α) (instRingFreeRing.{u1} α))) (NonAssocRing.toNonAssocSemiring.{u2} R (Ring.toNonAssocRing.{u2} R _inst_1))) _x) (Equiv.instFunLikeEquiv.{max (succ u2) (succ u1), max (succ u2) (succ u1)} (α -> R) (RingHom.{u1, u2} (FreeRing.{u1} α) R (NonAssocRing.toNonAssocSemiring.{u1} (FreeRing.{u1} α) (Ring.toNonAssocRing.{u1} (FreeRing.{u1} α) (instRingFreeRing.{u1} α))) (NonAssocRing.toNonAssocSemiring.{u2} R (Ring.toNonAssocRing.{u2} R _inst_1)))) (FreeRing.lift.{u1, u2} α R _inst_1) f) (FreeRing.of.{u1} α x)) (f x)
+Case conversion may be inaccurate. Consider using '#align free_ring.lift_of FreeRing.lift_ofₓ'. -/
 @[simp]
 theorem lift_of (x : α) : lift f (of x) = f x :=
   congr_fun (lift.left_inv f) x
 #align free_ring.lift_of FreeRing.lift_of
 
+#print FreeRing.lift_comp_of /-
 @[simp]
 theorem lift_comp_of (f : FreeRing α →+* R) : lift (f ∘ of) = f :=
   lift.right_inv f
 #align free_ring.lift_comp_of FreeRing.lift_comp_of
+-/
 
+#print FreeRing.hom_ext /-
 @[ext]
 theorem hom_ext ⦃f g : FreeRing α →+* R⦄ (h : ∀ x, f (of x) = g (of x)) : f = g :=
   lift.symm.Injective (funext h)
 #align free_ring.hom_ext FreeRing.hom_ext
+-/
 
 end lift
 
 variable {β : Type v} (f : α → β)
 
+#print FreeRing.map /-
 /-- The canonical ring homomorphism `free_ring α →+* free_ring β` generated by a map `α → β`. -/
 def map : FreeRing α →+* FreeRing β :=
   lift <| of ∘ f
 #align free_ring.map FreeRing.map
+-/
 
+/- warning: free_ring.map_of -> FreeRing.map_of is a dubious translation:
+lean 3 declaration is
+  forall {α : Type.{u1}} {β : Type.{u2}} (f : α -> β) (x : α), Eq.{succ u2} (FreeRing.{u2} β) (coeFn.{max (succ u1) (succ u2), max (succ u1) (succ u2)} (RingHom.{u1, u2} (FreeRing.{u1} α) (FreeRing.{u2} β) (NonAssocRing.toNonAssocSemiring.{u1} (FreeRing.{u1} α) (Ring.toNonAssocRing.{u1} (FreeRing.{u1} α) (FreeRing.ring.{u1} α))) (NonAssocRing.toNonAssocSemiring.{u2} (FreeRing.{u2} β) (Ring.toNonAssocRing.{u2} (FreeRing.{u2} β) (FreeRing.ring.{u2} β)))) (fun (_x : RingHom.{u1, u2} (FreeRing.{u1} α) (FreeRing.{u2} β) (NonAssocRing.toNonAssocSemiring.{u1} (FreeRing.{u1} α) (Ring.toNonAssocRing.{u1} (FreeRing.{u1} α) (FreeRing.ring.{u1} α))) (NonAssocRing.toNonAssocSemiring.{u2} (FreeRing.{u2} β) (Ring.toNonAssocRing.{u2} (FreeRing.{u2} β) (FreeRing.ring.{u2} β)))) => (FreeRing.{u1} α) -> (FreeRing.{u2} β)) (RingHom.hasCoeToFun.{u1, u2} (FreeRing.{u1} α) (FreeRing.{u2} β) (NonAssocRing.toNonAssocSemiring.{u1} (FreeRing.{u1} α) (Ring.toNonAssocRing.{u1} (FreeRing.{u1} α) (FreeRing.ring.{u1} α))) (NonAssocRing.toNonAssocSemiring.{u2} (FreeRing.{u2} β) (Ring.toNonAssocRing.{u2} (FreeRing.{u2} β) (FreeRing.ring.{u2} β)))) (FreeRing.map.{u1, u2} α β f) (FreeRing.of.{u1} α x)) (FreeRing.of.{u2} β (f x))
+but is expected to have type
+  forall {α : Type.{u1}} {β : Type.{u2}} (f : α -> β) (x : α), Eq.{succ u2} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : FreeRing.{u1} α) => FreeRing.{u2} β) (FreeRing.of.{u1} α x)) (FunLike.coe.{max (succ u1) (succ u2), succ u1, succ u2} (RingHom.{u1, u2} (FreeRing.{u1} α) (FreeRing.{u2} β) (NonAssocRing.toNonAssocSemiring.{u1} (FreeRing.{u1} α) (Ring.toNonAssocRing.{u1} (FreeRing.{u1} α) (instRingFreeRing.{u1} α))) (NonAssocRing.toNonAssocSemiring.{u2} (FreeRing.{u2} β) (Ring.toNonAssocRing.{u2} (FreeRing.{u2} β) (instRingFreeRing.{u2} β)))) (FreeRing.{u1} α) (fun (_x : FreeRing.{u1} α) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : FreeRing.{u1} α) => FreeRing.{u2} β) _x) (MulHomClass.toFunLike.{max u1 u2, u1, u2} (RingHom.{u1, u2} (FreeRing.{u1} α) (FreeRing.{u2} β) (NonAssocRing.toNonAssocSemiring.{u1} (FreeRing.{u1} α) (Ring.toNonAssocRing.{u1} (FreeRing.{u1} α) (instRingFreeRing.{u1} α))) (NonAssocRing.toNonAssocSemiring.{u2} (FreeRing.{u2} β) (Ring.toNonAssocRing.{u2} (FreeRing.{u2} β) (instRingFreeRing.{u2} β)))) (FreeRing.{u1} α) (FreeRing.{u2} β) (NonUnitalNonAssocSemiring.toMul.{u1} (FreeRing.{u1} α) (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u1} (FreeRing.{u1} α) (NonAssocRing.toNonAssocSemiring.{u1} (FreeRing.{u1} α) (Ring.toNonAssocRing.{u1} (FreeRing.{u1} α) (instRingFreeRing.{u1} α))))) (NonUnitalNonAssocSemiring.toMul.{u2} (FreeRing.{u2} β) (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u2} (FreeRing.{u2} β) (NonAssocRing.toNonAssocSemiring.{u2} (FreeRing.{u2} β) (Ring.toNonAssocRing.{u2} (FreeRing.{u2} β) (instRingFreeRing.{u2} β))))) (NonUnitalRingHomClass.toMulHomClass.{max u1 u2, u1, u2} (RingHom.{u1, u2} (FreeRing.{u1} α) (FreeRing.{u2} β) (NonAssocRing.toNonAssocSemiring.{u1} (FreeRing.{u1} α) (Ring.toNonAssocRing.{u1} (FreeRing.{u1} α) (instRingFreeRing.{u1} α))) (NonAssocRing.toNonAssocSemiring.{u2} (FreeRing.{u2} β) (Ring.toNonAssocRing.{u2} (FreeRing.{u2} β) (instRingFreeRing.{u2} β)))) (FreeRing.{u1} α) (FreeRing.{u2} β) (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u1} (FreeRing.{u1} α) (NonAssocRing.toNonAssocSemiring.{u1} (FreeRing.{u1} α) (Ring.toNonAssocRing.{u1} (FreeRing.{u1} α) (instRingFreeRing.{u1} α)))) (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u2} (FreeRing.{u2} β) (NonAssocRing.toNonAssocSemiring.{u2} (FreeRing.{u2} β) (Ring.toNonAssocRing.{u2} (FreeRing.{u2} β) (instRingFreeRing.{u2} β)))) (RingHomClass.toNonUnitalRingHomClass.{max u1 u2, u1, u2} (RingHom.{u1, u2} (FreeRing.{u1} α) (FreeRing.{u2} β) (NonAssocRing.toNonAssocSemiring.{u1} (FreeRing.{u1} α) (Ring.toNonAssocRing.{u1} (FreeRing.{u1} α) (instRingFreeRing.{u1} α))) (NonAssocRing.toNonAssocSemiring.{u2} (FreeRing.{u2} β) (Ring.toNonAssocRing.{u2} (FreeRing.{u2} β) (instRingFreeRing.{u2} β)))) (FreeRing.{u1} α) (FreeRing.{u2} β) (NonAssocRing.toNonAssocSemiring.{u1} (FreeRing.{u1} α) (Ring.toNonAssocRing.{u1} (FreeRing.{u1} α) (instRingFreeRing.{u1} α))) (NonAssocRing.toNonAssocSemiring.{u2} (FreeRing.{u2} β) (Ring.toNonAssocRing.{u2} (FreeRing.{u2} β) (instRingFreeRing.{u2} β))) (RingHom.instRingHomClassRingHom.{u1, u2} (FreeRing.{u1} α) (FreeRing.{u2} β) (NonAssocRing.toNonAssocSemiring.{u1} (FreeRing.{u1} α) (Ring.toNonAssocRing.{u1} (FreeRing.{u1} α) (instRingFreeRing.{u1} α))) (NonAssocRing.toNonAssocSemiring.{u2} (FreeRing.{u2} β) (Ring.toNonAssocRing.{u2} (FreeRing.{u2} β) (instRingFreeRing.{u2} β))))))) (FreeRing.map.{u1, u2} α β f) (FreeRing.of.{u1} α x)) (FreeRing.of.{u2} β (f x))
+Case conversion may be inaccurate. Consider using '#align free_ring.map_of FreeRing.map_ofₓ'. -/
 @[simp]
 theorem map_of (x : α) : map f (of x) = of (f x) :=
   lift_of _ _

d6814c58

bump to nightly-2023-02-21-16

mathlib commit https://github.com/leanprover-community/mathlib/commit/bd9851ca476957ea4549eb19b40e7b5ade9428cc

1107b979

Changes in mathlib4

mathlib3

mathlib4

d6814c58

style: homogenise porting notes (#11145)

Homogenises porting notes via capitalisation and addition of whitespace.

It makes the following changes:

converts "--porting note" into "-- Porting note";
converts "porting note" into "Porting note".

8be0b69c

Diff

@@ -64,7 +64,7 @@ protected theorem induction_on {C : FreeRing α → Prop} (z : FreeRing α) (hn1
   have h1 : C 1 := neg_neg (1 : FreeRing α) ▸ hn _ hn1
   FreeAbelianGroup.induction_on z (add_left_neg (1 : FreeRing α) ▸ ha _ _ hn1 h1)
     (fun m => List.recOn m h1 fun a m ih => by
-      -- porting note: in mathlib, convert was not necessary, `exact hm _ _ (hb a) ih` worked fine
+      -- Porting note: in mathlib, convert was not necessary, `exact hm _ _ (hb a) ih` worked fine
       convert hm _ _ (hb a) ih
       rw [of, ← FreeAbelianGroup.of_mul]
       rfl)

d6814c58

chore: script to replace headers with #align_import statements (#5979)

depends on: #5966

Co-authored-by: Eric Wieser <wieser.eric@gmail.com> Co-authored-by: Scott Morrison <scott.morrison@gmail.com>

89aa3a3b

Diff

@@ -2,14 +2,11 @@
 Copyright (c) 2019 Kenny Lau. All rights reserved.
 Released under Apache 2.0 license as described in the file LICENSE.
 Authors: Kenny Lau, Johan Commelin
-
-! This file was ported from Lean 3 source module ring_theory.free_ring
-! leanprover-community/mathlib commit d6814c584384ddf2825ff038e868451a7c956f31
-! Please do not edit these lines, except to modify the commit id
-! if you have ported upstream changes.
 -/
 import Mathlib.GroupTheory.FreeAbelianGroup
 
+#align_import ring_theory.free_ring from "leanprover-community/mathlib"@"d6814c584384ddf2825ff038e868451a7c956f31"
+
 /-!
 # Free rings

d6814c58

chore: fix many typos (#4967)

These are all doc fixes

6f9e51c3

Diff

@@ -50,7 +50,7 @@ namespace FreeRing
 
 variable {α : Type u}
 
-/-- The canonical map from α to `FreeRring α`. -/
+/-- The canonical map from α to `FreeRing α`. -/
 def of (x : α) : FreeRing α :=
   FreeAbelianGroup.of (FreeMonoid.of x)
 #align free_ring.of FreeRing.of

d6814c58

feat: port RingTheory.FreeRing (#2885)

4661306a

`ring_theory.free_ring` ⟷ `Mathlib.RingTheory.FreeRing`

Changes since the initial port

Changes in mathlib3

Changes in mathlib3port

Changes in mathlib4

Dependencies 8 + 349

ring_theory.free_ring ⟷ Mathlib.RingTheory.FreeRing

Changes since the initial port

Changes in mathlib3

Changes in mathlib3port

Changes in mathlib4

Dependencies 8 + 349

`ring_theory.free_ring` ⟷ `Mathlib.RingTheory.FreeRing`