ring_theory.free_comm_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

62c0a4ef

(last sync)

Changes in mathlib3port

mathlib3

mathlib3port

50251fd6

bump to nightly-2024-04-19-08

mathlib commit https://github.com/leanprover-community/mathlib/commit/65a1391a0106c9204fe45bc73a039f056558cb83

a9e81450

Diff

@@ -280,7 +280,7 @@ theorem isSupported_of {p} {s : Set α} : IsSupported (of p) s ↔ p ∈ s :=
     · rintro x y ⟨q, hq⟩ ⟨r, hr⟩; refine' ⟨q + r, _⟩; rw [RingHom.map_add, hq, hr]; norm_cast
   specialize this (of p) hps; rw [lift_of] at this; split_ifs at this; · exact h
   exfalso; apply Ne.symm Int.zero_ne_one
-  rcases this with ⟨w, H⟩; rw [← Polynomial.C_eq_int_cast] at H
+  rcases this with ⟨w, H⟩; rw [← Polynomial.C_eq_intCast] at H
   have : polynomial.X.coeff 1 = (Polynomial.C ↑w).coeff 1 := by rw [H]
   rwa [Polynomial.coeff_C, if_neg (one_ne_zero : 1 ≠ 0), Polynomial.coeff_X, if_pos rfl] at this
 #align free_comm_ring.is_supported_of FreeCommRing.isSupported_of

50251fd6

bump to nightly-2024-04-07-08

mathlib commit https://github.com/leanprover-community/mathlib/commit/65a1391a0106c9204fe45bc73a039f056558cb83

b03b8656

Diff

@@ -3,8 +3,8 @@ 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 Data.MvPolynomial.Equiv
-import Data.MvPolynomial.CommRing
+import Algebra.MvPolynomial.Equiv
+import Algebra.MvPolynomial.CommRing
 import Logic.Equiv.Functor
 import RingTheory.FreeRing

50251fd6

bump to nightly-2024-03-17-08

mathlib commit https://github.com/leanprover-community/mathlib/commit/65a1391a0106c9204fe45bc73a039f056558cb83

22f01ce4

Diff

@@ -278,11 +278,11 @@ theorem isSupported_of {p} {s : Set α} : IsSupported (of p) s ↔ p ∈ s :=
       rw [RingHom.map_mul, lift_of, if_pos hzs, MulZeroClass.zero_mul]
       norm_cast
     · rintro x y ⟨q, hq⟩ ⟨r, hr⟩; refine' ⟨q + r, _⟩; rw [RingHom.map_add, hq, hr]; norm_cast
-  specialize this (of p) hps; rw [lift_of] at this ; split_ifs at this ; · exact h
+  specialize this (of p) hps; rw [lift_of] at this; split_ifs at this; · exact h
   exfalso; apply Ne.symm Int.zero_ne_one
-  rcases this with ⟨w, H⟩; rw [← Polynomial.C_eq_int_cast] at H 
+  rcases this with ⟨w, H⟩; rw [← Polynomial.C_eq_int_cast] at H
   have : polynomial.X.coeff 1 = (Polynomial.C ↑w).coeff 1 := by rw [H]
-  rwa [Polynomial.coeff_C, if_neg (one_ne_zero : 1 ≠ 0), Polynomial.coeff_X, if_pos rfl] at this 
+  rwa [Polynomial.coeff_C, if_neg (one_ne_zero : 1 ≠ 0), Polynomial.coeff_X, if_pos rfl] at this
 #align free_comm_ring.is_supported_of FreeCommRing.isSupported_of
 -/

50251fd6

bump to nightly-2023-09-24-06

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

5655435f

Diff

@@ -3,10 +3,10 @@ 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.Data.MvPolynomial.Equiv
-import Mathbin.Data.MvPolynomial.CommRing
-import Mathbin.Logic.Equiv.Functor
-import Mathbin.RingTheory.FreeRing
+import Data.MvPolynomial.Equiv
+import Data.MvPolynomial.CommRing
+import Logic.Equiv.Functor
+import RingTheory.FreeRing
 
 #align_import ring_theory.free_comm_ring from "leanprover-community/mathlib"@"50251fd6309cca5ca2e747882ffecd2729f38c5d"

50251fd6

bump to nightly-2023-08-17-09

mathlib commit https://github.com/leanprover-community/mathlib/commit/32a7e535287f9c73f2e4d2aef306a39190f0b504

60285dcc

Diff

@@ -394,7 +394,7 @@ protected theorem coe_sub (x y : FreeRing α) : ↑(x - y) = (x : FreeCommRing 
 #print FreeRing.coe_mul /-
 @[simp, norm_cast]
 protected theorem coe_mul (x y : FreeRing α) : ↑(x * y) = (x : FreeCommRing α) * y :=
-  (FreeRing.lift _).map_mul _ _
+  (FreeRing.lift _).map_hMul _ _
 #align free_ring.coe_mul FreeRing.coe_mul
 -/
 
@@ -407,7 +407,7 @@ protected theorem coe_surjective : Surjective (coe : FreeRing α → FreeCommRin
   · use-1; rfl
   · intro x; use FreeRing.of x; rfl
   · rintro _ _ ⟨x, rfl⟩ ⟨y, rfl⟩; use x + y; exact (FreeRing.lift _).map_add _ _
-  · rintro _ _ ⟨x, rfl⟩ ⟨y, rfl⟩; use x * y; exact (FreeRing.lift _).map_mul _ _
+  · rintro _ _ ⟨x, rfl⟩ ⟨y, rfl⟩; use x * y; exact (FreeRing.lift _).map_hMul _ _
 #align free_ring.coe_surjective FreeRing.coe_surjective
 -/
 
@@ -419,7 +419,7 @@ theorem coe_eq :
     FreeAbelianGroup.lift.unique _ _ fun L => by simp_rw [FreeAbelianGroup.lift.of, (· ∘ ·)];
       exact
         FreeMonoid.recOn L rfl fun hd tl ih => by
-          rw [(FreeMonoid.lift _).map_mul, FreeMonoid.lift_eval_of, ih]; rfl
+          rw [(FreeMonoid.lift _).map_hMul, FreeMonoid.lift_eval_of, ih]; rfl
 #align free_ring.coe_eq FreeRing.coe_eq
 -/
 
@@ -442,8 +442,8 @@ instance [Subsingleton α] : CommRing (FreeRing α) :=
   { FreeRing.ring α with
     mul_comm := fun x y => by
       rw [← (subsingleton_equiv_free_comm_ring α).symm_apply_apply (y * x),
-        (subsingleton_equiv_free_comm_ring α).map_mul, mul_comm, ←
-        (subsingleton_equiv_free_comm_ring α).map_mul,
+        (subsingleton_equiv_free_comm_ring α).map_hMul, mul_comm, ←
+        (subsingleton_equiv_free_comm_ring α).map_hMul,
         (subsingleton_equiv_free_comm_ring α).symm_apply_apply] }
 
 end FreeRing

50251fd6

bump to nightly-2023-08-02-01

mathlib commit https://github.com/leanprover-community/mathlib/commit/63721b2c3eba6c325ecf8ae8cca27155a4f6306f

7aca3f15

Diff

@@ -273,7 +273,7 @@ theorem isSupported_of {p} {s : Set α} : IsSupported (of p) s ↔ p ∈ s :=
     by
     intro x hx; refine' Subring.InClosure.recOn hx _ _ _ _
     · use 1; rw [RingHom.map_one]; norm_cast
-    · use -1; rw [RingHom.map_neg, RingHom.map_one, Int.cast_neg, Int.cast_one]
+    · use-1; rw [RingHom.map_neg, RingHom.map_one, Int.cast_neg, Int.cast_one]
     · rintro _ ⟨z, hzs, rfl⟩ _ _; use 0;
       rw [RingHom.map_mul, lift_of, if_pos hzs, MulZeroClass.zero_mul]
       norm_cast
@@ -404,7 +404,7 @@ variable (α)
 protected theorem coe_surjective : Surjective (coe : FreeRing α → FreeCommRing α) := fun x =>
   by
   apply FreeCommRing.induction_on x
-  · use -1; rfl
+  · use-1; rfl
   · intro x; use FreeRing.of x; rfl
   · rintro _ _ ⟨x, rfl⟩ ⟨y, rfl⟩; use x + y; exact (FreeRing.lift _).map_add _ _
   · rintro _ _ ⟨x, rfl⟩ ⟨y, rfl⟩; use x * y; exact (FreeRing.lift _).map_mul _ _

50251fd6

bump to nightly-2023-07-20-09

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

9c56d0dd

Diff

@@ -2,17 +2,14 @@
 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_comm_ring
-! leanprover-community/mathlib commit 50251fd6309cca5ca2e747882ffecd2729f38c5d
-! Please do not edit these lines, except to modify the commit id
-! if you have ported upstream changes.
 -/
 import Mathbin.Data.MvPolynomial.Equiv
 import Mathbin.Data.MvPolynomial.CommRing
 import Mathbin.Logic.Equiv.Functor
 import Mathbin.RingTheory.FreeRing
 
+#align_import ring_theory.free_comm_ring from "leanprover-community/mathlib"@"50251fd6309cca5ca2e747882ffecd2729f38c5d"
+
 /-!
 # Free commutative rings

50251fd6

bump to nightly-2023-06-13-21

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

829520ac

Diff

@@ -90,6 +90,7 @@ theorem of_injective : Function.Injective (of : α → FreeCommRing α) :=
 #align free_comm_ring.of_injective FreeCommRing.of_injective
 -/
 
+#print FreeCommRing.induction_on /-
 @[elab_as_elim]
 protected theorem induction_on {C : FreeCommRing α → Prop} (z : FreeCommRing α) (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)) :
@@ -99,6 +100,7 @@ protected theorem induction_on {C : FreeCommRing α → Prop} (z : FreeCommRing
   FreeAbelianGroup.induction_on z (add_left_neg (1 : FreeCommRing α) ▸ ha _ _ hn1 h1)
     (fun m => Multiset.induction_on m h1 fun a m ih => hm _ _ (hb a) ih) (fun m ih => hn _ ih) ha
 #align free_comm_ring.induction_on FreeCommRing.induction_on
+-/
 
 section lift
 
@@ -135,10 +137,12 @@ def lift : (α → R) ≃ (FreeCommRing α →+* R) :=
 #align free_comm_ring.lift FreeCommRing.lift
 -/
 
+#print FreeCommRing.lift_of /-
 @[simp]
 theorem lift_of (x : α) : lift f (of x) = f x :=
   (FreeAbelianGroup.lift.of _ _).trans <| mul_one _
 #align free_comm_ring.lift_of FreeCommRing.lift_of
+-/
 
 #print FreeCommRing.lift_comp_of /-
 @[simp]
@@ -150,10 +154,12 @@ theorem lift_comp_of (f : FreeCommRing α →+* R) : lift (f ∘ of) = f :=
 #align free_comm_ring.lift_comp_of FreeCommRing.lift_comp_of
 -/
 
+#print FreeCommRing.hom_ext /-
 @[ext]
 theorem hom_ext ⦃f g : FreeCommRing α →+* R⦄ (h : ∀ x, f (of x) = g (of x)) : f = g :=
   lift.symm.Injective (funext h)
 #align free_comm_ring.hom_ext FreeCommRing.hom_ext
+-/
 
 end lift
 
@@ -166,10 +172,12 @@ def map : FreeCommRing α →+* FreeCommRing β :=
 #align free_comm_ring.map FreeCommRing.map
 -/
 
+#print FreeCommRing.map_of /-
 @[simp]
 theorem map_of (x : α) : map f (of x) = of (f x) :=
   lift_of _ _
 #align free_comm_ring.map_of FreeCommRing.map_of
+-/
 
 #print FreeCommRing.IsSupported /-
 /-- `is_supported x s` means that all monomials showing up in `x` have variables in `s`. -/
@@ -188,35 +196,49 @@ theorem isSupported_upwards (hs : IsSupported x s) (hst : s ⊆ t) : IsSupported
 #align free_comm_ring.is_supported_upwards FreeCommRing.isSupported_upwards
 -/
 
+#print FreeCommRing.isSupported_add /-
 theorem isSupported_add (hxs : IsSupported x s) (hys : IsSupported y s) : IsSupported (x + y) s :=
   Subring.add_mem _ hxs hys
 #align free_comm_ring.is_supported_add FreeCommRing.isSupported_add
+-/
 
+#print FreeCommRing.isSupported_neg /-
 theorem isSupported_neg (hxs : IsSupported x s) : IsSupported (-x) s :=
   Subring.neg_mem _ hxs
 #align free_comm_ring.is_supported_neg FreeCommRing.isSupported_neg
+-/
 
+#print FreeCommRing.isSupported_sub /-
 theorem isSupported_sub (hxs : IsSupported x s) (hys : IsSupported y s) : IsSupported (x - y) s :=
   Subring.sub_mem _ hxs hys
 #align free_comm_ring.is_supported_sub FreeCommRing.isSupported_sub
+-/
 
+#print FreeCommRing.isSupported_mul /-
 theorem isSupported_mul (hxs : IsSupported x s) (hys : IsSupported y s) : IsSupported (x * y) s :=
   Subring.mul_mem _ hxs hys
 #align free_comm_ring.is_supported_mul FreeCommRing.isSupported_mul
+-/
 
+#print FreeCommRing.isSupported_zero /-
 theorem isSupported_zero : IsSupported 0 s :=
   Subring.zero_mem _
 #align free_comm_ring.is_supported_zero FreeCommRing.isSupported_zero
+-/
 
+#print FreeCommRing.isSupported_one /-
 theorem isSupported_one : IsSupported 1 s :=
   Subring.one_mem _
 #align free_comm_ring.is_supported_one FreeCommRing.isSupported_one
+-/
 
+#print FreeCommRing.isSupported_int /-
 theorem isSupported_int {i : ℤ} {s : Set α} : IsSupported (↑i) s :=
   Int.induction_on i isSupported_zero
     (fun i hi => by rw [Int.cast_add, Int.cast_one] <;> exact is_supported_add hi is_supported_one)
     fun i hi => by rw [Int.cast_sub, Int.cast_one] <;> exact is_supported_sub hi is_supported_one
 #align free_comm_ring.is_supported_int FreeCommRing.isSupported_int
+-/
 
 end IsSupported
 
@@ -232,10 +254,12 @@ section Restriction
 
 variable (s : Set α) [DecidablePred (· ∈ s)] (x y : FreeCommRing α)
 
+#print FreeCommRing.restriction_of /-
 @[simp]
 theorem restriction_of (p) : restriction s (of p) = if H : p ∈ s then of ⟨p, H⟩ else 0 :=
   lift_of _ _
 #align free_comm_ring.restriction_of FreeCommRing.restriction_of
+-/
 
 end Restriction
 
@@ -265,6 +289,7 @@ theorem isSupported_of {p} {s : Set α} : IsSupported (of p) s ↔ p ∈ s :=
 #align free_comm_ring.is_supported_of FreeCommRing.isSupported_of
 -/
 
+#print FreeCommRing.map_subtype_val_restriction /-
 theorem map_subtype_val_restriction {x} (s : Set α) [DecidablePred (· ∈ s)]
     (hxs : IsSupported x s) : map (Subtype.val : s → α) (restriction s x) = x :=
   by
@@ -275,6 +300,7 @@ theorem map_subtype_val_restriction {x} (s : Set α) [DecidablePred (· ∈ s)]
     rw [RingHom.map_mul, restriction_of, dif_pos hps, RingHom.map_mul, map_of, ih]
   · intro x y ihx ihy; rw [RingHom.map_add, RingHom.map_add, ihx, ihy]
 #align free_comm_ring.map_subtype_val_restriction FreeCommRing.map_subtype_val_restriction
+-/
 
 #print FreeCommRing.exists_finite_support /-
 theorem exists_finite_support (x : FreeCommRing α) : ∃ s : Set α, Set.Finite s ∧ IsSupported x s :=
@@ -324,15 +350,19 @@ def coeRingHom : FreeRing α →+* FreeCommRing α :=
 #align free_ring.coe_ring_hom FreeRing.coeRingHom
 -/
 
+#print FreeRing.coe_zero /-
 @[simp, norm_cast]
 protected theorem coe_zero : ↑(0 : FreeRing α) = (0 : FreeCommRing α) :=
   rfl
 #align free_ring.coe_zero FreeRing.coe_zero
+-/
 
+#print FreeRing.coe_one /-
 @[simp, norm_cast]
 protected theorem coe_one : ↑(1 : FreeRing α) = (1 : FreeCommRing α) :=
   rfl
 #align free_ring.coe_one FreeRing.coe_one
+-/
 
 variable {α}
 
@@ -343,25 +373,33 @@ protected theorem coe_of (a : α) : ↑(FreeRing.of a) = FreeCommRing.of a :=
 #align free_ring.coe_of FreeRing.coe_of
 -/
 
+#print FreeRing.coe_neg /-
 @[simp, norm_cast]
 protected theorem coe_neg (x : FreeRing α) : ↑(-x) = -(x : FreeCommRing α) :=
   (FreeRing.lift _).map_neg _
 #align free_ring.coe_neg FreeRing.coe_neg
+-/
 
+#print FreeRing.coe_add /-
 @[simp, norm_cast]
 protected theorem coe_add (x y : FreeRing α) : ↑(x + y) = (x : FreeCommRing α) + y :=
   (FreeRing.lift _).map_add _ _
 #align free_ring.coe_add FreeRing.coe_add
+-/
 
+#print FreeRing.coe_sub /-
 @[simp, norm_cast]
 protected theorem coe_sub (x y : FreeRing α) : ↑(x - y) = (x : FreeCommRing α) - y :=
   (FreeRing.lift _).map_sub _ _
 #align free_ring.coe_sub FreeRing.coe_sub
+-/
 
+#print FreeRing.coe_mul /-
 @[simp, norm_cast]
 protected theorem coe_mul (x y : FreeRing α) : ↑(x * y) = (x : FreeCommRing α) * y :=
   (FreeRing.lift _).map_mul _ _
 #align free_ring.coe_mul FreeRing.coe_mul
+-/
 
 variable (α)
 
@@ -376,6 +414,7 @@ protected theorem coe_surjective : Surjective (coe : FreeRing α → FreeCommRin
 #align free_ring.coe_surjective FreeRing.coe_surjective
 -/
 
+#print FreeRing.coe_eq /-
 theorem coe_eq :
     (coe : FreeRing α → FreeCommRing α) =
       @Functor.map FreeAbelianGroup _ _ _ fun l : List α => (l : Multiset α) :=
@@ -385,7 +424,9 @@ theorem coe_eq :
         FreeMonoid.recOn L rfl fun hd tl ih => by
           rw [(FreeMonoid.lift _).map_mul, FreeMonoid.lift_eval_of, ih]; rfl
 #align free_ring.coe_eq FreeRing.coe_eq
+-/
 
+#print FreeRing.subsingletonEquivFreeCommRing /-
 /-- If α has size at most 1 then the natural map from the free ring on `α` to the
     free commutative ring on `α` is an isomorphism of rings. -/
 def subsingletonEquivFreeCommRing [Subsingleton α] : FreeRing α ≃+* FreeCommRing α :=
@@ -398,6 +439,7 @@ def subsingletonEquivFreeCommRing [Subsingleton α] : FreeRing α ≃+* FreeComm
       rw [this]
       apply Equiv.bijective)
 #align free_ring.subsingleton_equiv_free_comm_ring FreeRing.subsingletonEquivFreeCommRing
+-/
 
 instance [Subsingleton α] : CommRing (FreeRing α) :=
   { FreeRing.ring α with
@@ -409,6 +451,7 @@ instance [Subsingleton α] : CommRing (FreeRing α) :=
 
 end FreeRing
 
+#print freeCommRingEquivMvPolynomialInt /-
 /-- The free commutative ring on `α` is isomorphic to the polynomial ring over ℤ with
     variables in `α` -/
 def freeCommRingEquivMvPolynomialInt : FreeCommRing α ≃+* MvPolynomial α ℤ :=
@@ -416,26 +459,35 @@ def freeCommRingEquivMvPolynomialInt : FreeCommRing α ≃+* MvPolynomial α ℤ
     (MvPolynomial.eval₂Hom (Int.castRingHom (FreeCommRing α)) FreeCommRing.of) (by ext; simp)
     (by ext <;> simp)
 #align free_comm_ring_equiv_mv_polynomial_int freeCommRingEquivMvPolynomialInt
+-/
 
+#print freeCommRingPemptyEquivInt /-
 /-- The free commutative ring on the empty type is isomorphic to `ℤ`. -/
 def freeCommRingPemptyEquivInt : FreeCommRing PEmpty.{u + 1} ≃+* ℤ :=
   RingEquiv.trans (freeCommRingEquivMvPolynomialInt _) (MvPolynomial.isEmptyRingEquiv _ PEmpty)
 #align free_comm_ring_pempty_equiv_int freeCommRingPemptyEquivInt
+-/
 
+#print freeCommRingPunitEquivPolynomialInt /-
 /-- The free commutative ring on a type with one term is isomorphic to `ℤ[X]`. -/
 def freeCommRingPunitEquivPolynomialInt : FreeCommRing PUnit.{u + 1} ≃+* ℤ[X] :=
   (freeCommRingEquivMvPolynomialInt _).trans (MvPolynomial.pUnitAlgEquiv ℤ).toRingEquiv
 #align free_comm_ring_punit_equiv_polynomial_int freeCommRingPunitEquivPolynomialInt
+-/
 
 open FreeRing
 
+#print freeRingPemptyEquivInt /-
 /-- The free ring on the empty type is isomorphic to `ℤ`. -/
 def freeRingPemptyEquivInt : FreeRing PEmpty.{u + 1} ≃+* ℤ :=
   RingEquiv.trans (subsingletonEquivFreeCommRing _) freeCommRingPemptyEquivInt
 #align free_ring_pempty_equiv_int freeRingPemptyEquivInt
+-/
 
+#print freeRingPunitEquivPolynomialInt /-
 /-- The free ring on a type with one term is isomorphic to `ℤ[X]`. -/
 def freeRingPunitEquivPolynomialInt : FreeRing PUnit.{u + 1} ≃+* ℤ[X] :=
   RingEquiv.trans (subsingletonEquivFreeCommRing _) freeCommRingPunitEquivPolynomialInt
 #align free_ring_punit_equiv_polynomial_int freeRingPunitEquivPolynomialInt
+-/

50251fd6

bump to nightly-2023-06-09-07

mathlib commit https://github.com/leanprover-community/mathlib/commit/7e5137f579de09a059a5ce98f364a04e221aabf0

16afdc39

Diff

@@ -115,7 +115,6 @@ private def lift_to_multiset : (α → R) ≃ (Multiplicative (Multiset α) →*
           _ = Multiset.prod (Multiset.map f x + Multiset.map f y) := by congr 1;
             exact Multiset.map_add _ _ _
           _ = _ := Multiset.prod_add _ _
-          
       map_one' := rfl }
   invFun F x := F (Multiplicative.ofAdd ({x} : Multiset α))
   left_inv f := funext fun x => show (Multiset.map f {x}).Prod = _ by simp

50251fd6

bump to nightly-2023-06-04-18

mathlib commit https://github.com/leanprover-community/mathlib/commit/5f25c089cb34db4db112556f23c50d12da81b297

3fb4268b

Diff

@@ -258,7 +258,7 @@ theorem isSupported_of {p} {s : Set α} : IsSupported (of p) s ↔ p ∈ s :=
       rw [RingHom.map_mul, lift_of, if_pos hzs, MulZeroClass.zero_mul]
       norm_cast
     · rintro x y ⟨q, hq⟩ ⟨r, hr⟩; refine' ⟨q + r, _⟩; rw [RingHom.map_add, hq, hr]; norm_cast
-  specialize this (of p) hps; rw [lift_of] at this ; split_ifs  at this ; · exact h
+  specialize this (of p) hps; rw [lift_of] at this ; split_ifs at this ; · exact h
   exfalso; apply Ne.symm Int.zero_ne_one
   rcases this with ⟨w, H⟩; rw [← Polynomial.C_eq_int_cast] at H 
   have : polynomial.X.coeff 1 = (Polynomial.C ↑w).coeff 1 := by rw [H]

50251fd6

bump to nightly-2023-06-01-16

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

b9c87c70

Diff

@@ -67,7 +67,8 @@ variable (α : Type u)
 #print FreeCommRing /-
 /-- `free_comm_ring α` is the free commutative ring on the type `α`. -/
 def FreeCommRing (α : Type u) : Type u :=
-  FreeAbelianGroup <| Multiplicative <| Multiset α deriving CommRing, Inhabited
+  FreeAbelianGroup <| Multiplicative <| Multiset α
+deriving CommRing, Inhabited
 #align free_comm_ring FreeCommRing
 -/
 
@@ -257,11 +258,11 @@ theorem isSupported_of {p} {s : Set α} : IsSupported (of p) s ↔ p ∈ s :=
       rw [RingHom.map_mul, lift_of, if_pos hzs, MulZeroClass.zero_mul]
       norm_cast
     · rintro x y ⟨q, hq⟩ ⟨r, hr⟩; refine' ⟨q + r, _⟩; rw [RingHom.map_add, hq, hr]; norm_cast
-  specialize this (of p) hps; rw [lift_of] at this; split_ifs  at this; · exact h
+  specialize this (of p) hps; rw [lift_of] at this ; split_ifs  at this ; · exact h
   exfalso; apply Ne.symm Int.zero_ne_one
-  rcases this with ⟨w, H⟩; rw [← Polynomial.C_eq_int_cast] at H
+  rcases this with ⟨w, H⟩; rw [← Polynomial.C_eq_int_cast] at H 
   have : polynomial.X.coeff 1 = (Polynomial.C ↑w).coeff 1 := by rw [H]
-  rwa [Polynomial.coeff_C, if_neg (one_ne_zero : 1 ≠ 0), Polynomial.coeff_X, if_pos rfl] at this
+  rwa [Polynomial.coeff_C, if_neg (one_ne_zero : 1 ≠ 0), Polynomial.coeff_X, if_pos rfl] at this 
 #align free_comm_ring.is_supported_of FreeCommRing.isSupported_of
 -/

50251fd6

bump to nightly-2023-05-28-18

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

8d353152

Diff

@@ -58,7 +58,7 @@ free commutative ring, free ring
 
 noncomputable section
 
-open Classical Polynomial
+open scoped Classical Polynomial
 
 universe u v

50251fd6

bump to nightly-2023-05-28-06

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

ba5d8b97

Diff

@@ -89,12 +89,6 @@ theorem of_injective : Function.Injective (of : α → FreeCommRing α) :=
 #align free_comm_ring.of_injective FreeCommRing.of_injective
 -/
 
-/- warning: free_comm_ring.induction_on -> FreeCommRing.induction_on is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {C : (FreeCommRing.{u1} α) -> Prop} (z : FreeCommRing.{u1} α), (C (Neg.neg.{u1} (FreeCommRing.{u1} α) (SubNegMonoid.toHasNeg.{u1} (FreeCommRing.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeCommRing.{u1} α) (AddGroupWithOne.toAddGroup.{u1} (FreeCommRing.{u1} α) (AddCommGroupWithOne.toAddGroupWithOne.{u1} (FreeCommRing.{u1} α) (Ring.toAddCommGroupWithOne.{u1} (FreeCommRing.{u1} α) (CommRing.toRing.{u1} (FreeCommRing.{u1} α) (FreeCommRing.instCommRing.{u1} α))))))) (OfNat.ofNat.{u1} (FreeCommRing.{u1} α) 1 (OfNat.mk.{u1} (FreeCommRing.{u1} α) 1 (One.one.{u1} (FreeCommRing.{u1} α) (AddMonoidWithOne.toOne.{u1} (FreeCommRing.{u1} α) (AddGroupWithOne.toAddMonoidWithOne.{u1} (FreeCommRing.{u1} α) (AddCommGroupWithOne.toAddGroupWithOne.{u1} (FreeCommRing.{u1} α) (Ring.toAddCommGroupWithOne.{u1} (FreeCommRing.{u1} α) (CommRing.toRing.{u1} (FreeCommRing.{u1} α) (FreeCommRing.instCommRing.{u1} α))))))))))) -> (forall (b : α), C (FreeCommRing.of.{u1} α b)) -> (forall (x : FreeCommRing.{u1} α) (y : FreeCommRing.{u1} α), (C x) -> (C y) -> (C (HAdd.hAdd.{u1, u1, u1} (FreeCommRing.{u1} α) (FreeCommRing.{u1} α) (FreeCommRing.{u1} α) (instHAdd.{u1} (FreeCommRing.{u1} α) (Distrib.toHasAdd.{u1} (FreeCommRing.{u1} α) (Ring.toDistrib.{u1} (FreeCommRing.{u1} α) (CommRing.toRing.{u1} (FreeCommRing.{u1} α) (FreeCommRing.instCommRing.{u1} α))))) x y))) -> (forall (x : FreeCommRing.{u1} α) (y : FreeCommRing.{u1} α), (C x) -> (C y) -> (C (HMul.hMul.{u1, u1, u1} (FreeCommRing.{u1} α) (FreeCommRing.{u1} α) (FreeCommRing.{u1} α) (instHMul.{u1} (FreeCommRing.{u1} α) (Distrib.toHasMul.{u1} (FreeCommRing.{u1} α) (Ring.toDistrib.{u1} (FreeCommRing.{u1} α) (CommRing.toRing.{u1} (FreeCommRing.{u1} α) (FreeCommRing.instCommRing.{u1} α))))) x y))) -> (C z)
-but is expected to have type
-  forall {α : Type.{u1}} {C : (FreeCommRing.{u1} α) -> Prop} (z : FreeCommRing.{u1} α), (C (Neg.neg.{u1} (FreeCommRing.{u1} α) (Ring.toNeg.{u1} (FreeCommRing.{u1} α) (CommRing.toRing.{u1} (FreeCommRing.{u1} α) (FreeCommRing.instCommRing.{u1} α))) (OfNat.ofNat.{u1} (FreeCommRing.{u1} α) 1 (One.toOfNat1.{u1} (FreeCommRing.{u1} α) (Semiring.toOne.{u1} (FreeCommRing.{u1} α) (CommSemiring.toSemiring.{u1} (FreeCommRing.{u1} α) (CommRing.toCommSemiring.{u1} (FreeCommRing.{u1} α) (FreeCommRing.instCommRing.{u1} α)))))))) -> (forall (b : α), C (FreeCommRing.of.{u1} α b)) -> (forall (x : FreeCommRing.{u1} α) (y : FreeCommRing.{u1} α), (C x) -> (C y) -> (C (HAdd.hAdd.{u1, u1, u1} (FreeCommRing.{u1} α) (FreeCommRing.{u1} α) (FreeCommRing.{u1} α) (instHAdd.{u1} (FreeCommRing.{u1} α) (Distrib.toAdd.{u1} (FreeCommRing.{u1} α) (NonUnitalNonAssocSemiring.toDistrib.{u1} (FreeCommRing.{u1} α) (NonUnitalNonAssocRing.toNonUnitalNonAssocSemiring.{u1} (FreeCommRing.{u1} α) (NonAssocRing.toNonUnitalNonAssocRing.{u1} (FreeCommRing.{u1} α) (Ring.toNonAssocRing.{u1} (FreeCommRing.{u1} α) (CommRing.toRing.{u1} (FreeCommRing.{u1} α) (FreeCommRing.instCommRing.{u1} α)))))))) x y))) -> (forall (x : FreeCommRing.{u1} α) (y : FreeCommRing.{u1} α), (C x) -> (C y) -> (C (HMul.hMul.{u1, u1, u1} (FreeCommRing.{u1} α) (FreeCommRing.{u1} α) (FreeCommRing.{u1} α) (instHMul.{u1} (FreeCommRing.{u1} α) (NonUnitalNonAssocRing.toMul.{u1} (FreeCommRing.{u1} α) (NonAssocRing.toNonUnitalNonAssocRing.{u1} (FreeCommRing.{u1} α) (Ring.toNonAssocRing.{u1} (FreeCommRing.{u1} α) (CommRing.toRing.{u1} (FreeCommRing.{u1} α) (FreeCommRing.instCommRing.{u1} α)))))) x y))) -> (C z)
-Case conversion may be inaccurate. Consider using '#align free_comm_ring.induction_on FreeCommRing.induction_onₓ'. -/
 @[elab_as_elim]
 protected theorem induction_on {C : FreeCommRing α → Prop} (z : FreeCommRing α) (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)) :
@@ -141,12 +135,6 @@ def lift : (α → R) ≃ (FreeCommRing α →+* R) :=
 #align free_comm_ring.lift FreeCommRing.lift
 -/
 
-/- warning: free_comm_ring.lift_of -> FreeCommRing.lift_of is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {R : Type.{u2}} [_inst_1 : CommRing.{u2} R] (f : α -> R) (x : α), Eq.{succ u2} R (coeFn.{max (succ u1) (succ u2), max (succ u1) (succ u2)} (RingHom.{u1, u2} (FreeCommRing.{u1} α) R (NonAssocRing.toNonAssocSemiring.{u1} (FreeCommRing.{u1} α) (Ring.toNonAssocRing.{u1} (FreeCommRing.{u1} α) (CommRing.toRing.{u1} (FreeCommRing.{u1} α) (FreeCommRing.instCommRing.{u1} α)))) (NonAssocRing.toNonAssocSemiring.{u2} R (Ring.toNonAssocRing.{u2} R (CommRing.toRing.{u2} R _inst_1)))) (fun (_x : RingHom.{u1, u2} (FreeCommRing.{u1} α) R (NonAssocRing.toNonAssocSemiring.{u1} (FreeCommRing.{u1} α) (Ring.toNonAssocRing.{u1} (FreeCommRing.{u1} α) (CommRing.toRing.{u1} (FreeCommRing.{u1} α) (FreeCommRing.instCommRing.{u1} α)))) (NonAssocRing.toNonAssocSemiring.{u2} R (Ring.toNonAssocRing.{u2} R (CommRing.toRing.{u2} R _inst_1)))) => (FreeCommRing.{u1} α) -> R) (RingHom.hasCoeToFun.{u1, u2} (FreeCommRing.{u1} α) R (NonAssocRing.toNonAssocSemiring.{u1} (FreeCommRing.{u1} α) (Ring.toNonAssocRing.{u1} (FreeCommRing.{u1} α) (CommRing.toRing.{u1} (FreeCommRing.{u1} α) (FreeCommRing.instCommRing.{u1} α)))) (NonAssocRing.toNonAssocSemiring.{u2} R (Ring.toNonAssocRing.{u2} R (CommRing.toRing.{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} (FreeCommRing.{u1} α) R (NonAssocRing.toNonAssocSemiring.{u1} (FreeCommRing.{u1} α) (Ring.toNonAssocRing.{u1} (FreeCommRing.{u1} α) (CommRing.toRing.{u1} (FreeCommRing.{u1} α) (FreeCommRing.instCommRing.{u1} α)))) (NonAssocRing.toNonAssocSemiring.{u2} R (Ring.toNonAssocRing.{u2} R (CommRing.toRing.{u2} R _inst_1))))) (fun (_x : Equiv.{max (succ u1) (succ u2), max (succ u1) (succ u2)} (α -> R) (RingHom.{u1, u2} (FreeCommRing.{u1} α) R (NonAssocRing.toNonAssocSemiring.{u1} (FreeCommRing.{u1} α) (Ring.toNonAssocRing.{u1} (FreeCommRing.{u1} α) (CommRing.toRing.{u1} (FreeCommRing.{u1} α) (FreeCommRing.instCommRing.{u1} α)))) (NonAssocRing.toNonAssocSemiring.{u2} R (Ring.toNonAssocRing.{u2} R (CommRing.toRing.{u2} R _inst_1))))) => (α -> R) -> (RingHom.{u1, u2} (FreeCommRing.{u1} α) R (NonAssocRing.toNonAssocSemiring.{u1} (FreeCommRing.{u1} α) (Ring.toNonAssocRing.{u1} (FreeCommRing.{u1} α) (CommRing.toRing.{u1} (FreeCommRing.{u1} α) (FreeCommRing.instCommRing.{u1} α)))) (NonAssocRing.toNonAssocSemiring.{u2} R (Ring.toNonAssocRing.{u2} R (CommRing.toRing.{u2} R _inst_1))))) (Equiv.hasCoeToFun.{max (succ u1) (succ u2), max (succ u1) (succ u2)} (α -> R) (RingHom.{u1, u2} (FreeCommRing.{u1} α) R (NonAssocRing.toNonAssocSemiring.{u1} (FreeCommRing.{u1} α) (Ring.toNonAssocRing.{u1} (FreeCommRing.{u1} α) (CommRing.toRing.{u1} (FreeCommRing.{u1} α) (FreeCommRing.instCommRing.{u1} α)))) (NonAssocRing.toNonAssocSemiring.{u2} R (Ring.toNonAssocRing.{u2} R (CommRing.toRing.{u2} R _inst_1))))) (FreeCommRing.lift.{u1, u2} α R _inst_1) f) (FreeCommRing.of.{u1} α x)) (f x)
-but is expected to have type
-  forall {α : Type.{u1}} {R : Type.{u2}} [_inst_1 : CommRing.{u2} R] (f : α -> R) (x : α), Eq.{succ u2} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2397 : FreeCommRing.{u1} α) => R) (FreeCommRing.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} (FreeCommRing.{u1} α) R (Semiring.toNonAssocSemiring.{u1} (FreeCommRing.{u1} α) (CommSemiring.toSemiring.{u1} (FreeCommRing.{u1} α) (CommRing.toCommSemiring.{u1} (FreeCommRing.{u1} α) (FreeCommRing.instCommRing.{u1} α)))) (Semiring.toNonAssocSemiring.{u2} R (CommSemiring.toSemiring.{u2} R (CommRing.toCommSemiring.{u2} R _inst_1)))) f) (FreeCommRing.{u1} α) (fun (_x : FreeCommRing.{u1} α) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2397 : FreeCommRing.{u1} α) => R) _x) (MulHomClass.toFunLike.{max u1 u2, u1, u2} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : α -> R) => RingHom.{u1, u2} (FreeCommRing.{u1} α) R (Semiring.toNonAssocSemiring.{u1} (FreeCommRing.{u1} α) (CommSemiring.toSemiring.{u1} (FreeCommRing.{u1} α) (CommRing.toCommSemiring.{u1} (FreeCommRing.{u1} α) (FreeCommRing.instCommRing.{u1} α)))) (Semiring.toNonAssocSemiring.{u2} R (CommSemiring.toSemiring.{u2} R (CommRing.toCommSemiring.{u2} R _inst_1)))) f) (FreeCommRing.{u1} α) R (NonUnitalNonAssocSemiring.toMul.{u1} (FreeCommRing.{u1} α) (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u1} (FreeCommRing.{u1} α) (Semiring.toNonAssocSemiring.{u1} (FreeCommRing.{u1} α) (CommSemiring.toSemiring.{u1} (FreeCommRing.{u1} α) (CommRing.toCommSemiring.{u1} (FreeCommRing.{u1} α) (FreeCommRing.instCommRing.{u1} α)))))) (NonUnitalNonAssocSemiring.toMul.{u2} R (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u2} R (Semiring.toNonAssocSemiring.{u2} R (CommSemiring.toSemiring.{u2} R (CommRing.toCommSemiring.{u2} R _inst_1))))) (NonUnitalRingHomClass.toMulHomClass.{max u1 u2, u1, u2} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : α -> R) => RingHom.{u1, u2} (FreeCommRing.{u1} α) R (Semiring.toNonAssocSemiring.{u1} (FreeCommRing.{u1} α) (CommSemiring.toSemiring.{u1} (FreeCommRing.{u1} α) (CommRing.toCommSemiring.{u1} (FreeCommRing.{u1} α) (FreeCommRing.instCommRing.{u1} α)))) (Semiring.toNonAssocSemiring.{u2} R (CommSemiring.toSemiring.{u2} R (CommRing.toCommSemiring.{u2} R _inst_1)))) f) (FreeCommRing.{u1} α) R (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u1} (FreeCommRing.{u1} α) (Semiring.toNonAssocSemiring.{u1} (FreeCommRing.{u1} α) (CommSemiring.toSemiring.{u1} (FreeCommRing.{u1} α) (CommRing.toCommSemiring.{u1} (FreeCommRing.{u1} α) (FreeCommRing.instCommRing.{u1} α))))) (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u2} R (Semiring.toNonAssocSemiring.{u2} R (CommSemiring.toSemiring.{u2} R (CommRing.toCommSemiring.{u2} R _inst_1)))) (RingHomClass.toNonUnitalRingHomClass.{max u1 u2, u1, u2} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : α -> R) => RingHom.{u1, u2} (FreeCommRing.{u1} α) R (Semiring.toNonAssocSemiring.{u1} (FreeCommRing.{u1} α) (CommSemiring.toSemiring.{u1} (FreeCommRing.{u1} α) (CommRing.toCommSemiring.{u1} (FreeCommRing.{u1} α) (FreeCommRing.instCommRing.{u1} α)))) (Semiring.toNonAssocSemiring.{u2} R (CommSemiring.toSemiring.{u2} R (CommRing.toCommSemiring.{u2} R _inst_1)))) f) (FreeCommRing.{u1} α) R (Semiring.toNonAssocSemiring.{u1} (FreeCommRing.{u1} α) (CommSemiring.toSemiring.{u1} (FreeCommRing.{u1} α) (CommRing.toCommSemiring.{u1} (FreeCommRing.{u1} α) (FreeCommRing.instCommRing.{u1} α)))) (Semiring.toNonAssocSemiring.{u2} R (CommSemiring.toSemiring.{u2} R (CommRing.toCommSemiring.{u2} R _inst_1))) (RingHom.instRingHomClassRingHom.{u1, u2} (FreeCommRing.{u1} α) R (Semiring.toNonAssocSemiring.{u1} (FreeCommRing.{u1} α) (CommSemiring.toSemiring.{u1} (FreeCommRing.{u1} α) (CommRing.toCommSemiring.{u1} (FreeCommRing.{u1} α) (FreeCommRing.instCommRing.{u1} α)))) (Semiring.toNonAssocSemiring.{u2} R (CommSemiring.toSemiring.{u2} R (CommRing.toCommSemiring.{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} (FreeCommRing.{u1} α) R (Semiring.toNonAssocSemiring.{u1} (FreeCommRing.{u1} α) (CommSemiring.toSemiring.{u1} (FreeCommRing.{u1} α) (CommRing.toCommSemiring.{u1} (FreeCommRing.{u1} α) (FreeCommRing.instCommRing.{u1} α)))) (Semiring.toNonAssocSemiring.{u2} R (CommSemiring.toSemiring.{u2} R (CommRing.toCommSemiring.{u2} R _inst_1))))) (α -> R) (fun (_x : α -> R) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : α -> R) => RingHom.{u1, u2} (FreeCommRing.{u1} α) R (Semiring.toNonAssocSemiring.{u1} (FreeCommRing.{u1} α) (CommSemiring.toSemiring.{u1} (FreeCommRing.{u1} α) (CommRing.toCommSemiring.{u1} (FreeCommRing.{u1} α) (FreeCommRing.instCommRing.{u1} α)))) (Semiring.toNonAssocSemiring.{u2} R (CommSemiring.toSemiring.{u2} R (CommRing.toCommSemiring.{u2} R _inst_1)))) _x) (Equiv.instFunLikeEquiv.{max (succ u2) (succ u1), max (succ u2) (succ u1)} (α -> R) (RingHom.{u1, u2} (FreeCommRing.{u1} α) R (Semiring.toNonAssocSemiring.{u1} (FreeCommRing.{u1} α) (CommSemiring.toSemiring.{u1} (FreeCommRing.{u1} α) (CommRing.toCommSemiring.{u1} (FreeCommRing.{u1} α) (FreeCommRing.instCommRing.{u1} α)))) (Semiring.toNonAssocSemiring.{u2} R (CommSemiring.toSemiring.{u2} R (CommRing.toCommSemiring.{u2} R _inst_1))))) (FreeCommRing.lift.{u1, u2} α R _inst_1) f) (FreeCommRing.of.{u1} α x)) (f x)
-Case conversion may be inaccurate. Consider using '#align free_comm_ring.lift_of FreeCommRing.lift_ofₓ'. -/
 @[simp]
 theorem lift_of (x : α) : lift f (of x) = f x :=
   (FreeAbelianGroup.lift.of _ _).trans <| mul_one _
@@ -162,9 +150,6 @@ theorem lift_comp_of (f : FreeCommRing α →+* R) : lift (f ∘ of) = f :=
 #align free_comm_ring.lift_comp_of FreeCommRing.lift_comp_of
 -/
 
-/- warning: free_comm_ring.hom_ext -> FreeCommRing.hom_ext is a dubious translation:
-<too large>
-Case conversion may be inaccurate. Consider using '#align free_comm_ring.hom_ext FreeCommRing.hom_extₓ'. -/
 @[ext]
 theorem hom_ext ⦃f g : FreeCommRing α →+* R⦄ (h : ∀ x, f (of x) = g (of x)) : f = g :=
   lift.symm.Injective (funext h)
@@ -181,12 +166,6 @@ def map : FreeCommRing α →+* FreeCommRing β :=
 #align free_comm_ring.map FreeCommRing.map
 -/
 
-/- warning: free_comm_ring.map_of -> FreeCommRing.map_of is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {β : Type.{u2}} (f : α -> β) (x : α), Eq.{succ u2} (FreeCommRing.{u2} β) (coeFn.{max (succ u1) (succ u2), max (succ u1) (succ u2)} (RingHom.{u1, u2} (FreeCommRing.{u1} α) (FreeCommRing.{u2} β) (NonAssocRing.toNonAssocSemiring.{u1} (FreeCommRing.{u1} α) (Ring.toNonAssocRing.{u1} (FreeCommRing.{u1} α) (CommRing.toRing.{u1} (FreeCommRing.{u1} α) (FreeCommRing.instCommRing.{u1} α)))) (NonAssocRing.toNonAssocSemiring.{u2} (FreeCommRing.{u2} β) (Ring.toNonAssocRing.{u2} (FreeCommRing.{u2} β) (CommRing.toRing.{u2} (FreeCommRing.{u2} β) (FreeCommRing.instCommRing.{u2} β))))) (fun (_x : RingHom.{u1, u2} (FreeCommRing.{u1} α) (FreeCommRing.{u2} β) (NonAssocRing.toNonAssocSemiring.{u1} (FreeCommRing.{u1} α) (Ring.toNonAssocRing.{u1} (FreeCommRing.{u1} α) (CommRing.toRing.{u1} (FreeCommRing.{u1} α) (FreeCommRing.instCommRing.{u1} α)))) (NonAssocRing.toNonAssocSemiring.{u2} (FreeCommRing.{u2} β) (Ring.toNonAssocRing.{u2} (FreeCommRing.{u2} β) (CommRing.toRing.{u2} (FreeCommRing.{u2} β) (FreeCommRing.instCommRing.{u2} β))))) => (FreeCommRing.{u1} α) -> (FreeCommRing.{u2} β)) (RingHom.hasCoeToFun.{u1, u2} (FreeCommRing.{u1} α) (FreeCommRing.{u2} β) (NonAssocRing.toNonAssocSemiring.{u1} (FreeCommRing.{u1} α) (Ring.toNonAssocRing.{u1} (FreeCommRing.{u1} α) (CommRing.toRing.{u1} (FreeCommRing.{u1} α) (FreeCommRing.instCommRing.{u1} α)))) (NonAssocRing.toNonAssocSemiring.{u2} (FreeCommRing.{u2} β) (Ring.toNonAssocRing.{u2} (FreeCommRing.{u2} β) (CommRing.toRing.{u2} (FreeCommRing.{u2} β) (FreeCommRing.instCommRing.{u2} β))))) (FreeCommRing.map.{u1, u2} α β f) (FreeCommRing.of.{u1} α x)) (FreeCommRing.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 : FreeCommRing.{u1} α) => FreeCommRing.{u2} β) (FreeCommRing.of.{u1} α x)) (FunLike.coe.{max (succ u1) (succ u2), succ u1, succ u2} (RingHom.{u1, u2} (FreeCommRing.{u1} α) (FreeCommRing.{u2} β) (Semiring.toNonAssocSemiring.{u1} (FreeCommRing.{u1} α) (CommSemiring.toSemiring.{u1} (FreeCommRing.{u1} α) (CommRing.toCommSemiring.{u1} (FreeCommRing.{u1} α) (FreeCommRing.instCommRing.{u1} α)))) (Semiring.toNonAssocSemiring.{u2} (FreeCommRing.{u2} β) (CommSemiring.toSemiring.{u2} (FreeCommRing.{u2} β) (CommRing.toCommSemiring.{u2} (FreeCommRing.{u2} β) (FreeCommRing.instCommRing.{u2} β))))) (FreeCommRing.{u1} α) (fun (_x : FreeCommRing.{u1} α) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2397 : FreeCommRing.{u1} α) => FreeCommRing.{u2} β) _x) (MulHomClass.toFunLike.{max u1 u2, u1, u2} (RingHom.{u1, u2} (FreeCommRing.{u1} α) (FreeCommRing.{u2} β) (Semiring.toNonAssocSemiring.{u1} (FreeCommRing.{u1} α) (CommSemiring.toSemiring.{u1} (FreeCommRing.{u1} α) (CommRing.toCommSemiring.{u1} (FreeCommRing.{u1} α) (FreeCommRing.instCommRing.{u1} α)))) (Semiring.toNonAssocSemiring.{u2} (FreeCommRing.{u2} β) (CommSemiring.toSemiring.{u2} (FreeCommRing.{u2} β) (CommRing.toCommSemiring.{u2} (FreeCommRing.{u2} β) (FreeCommRing.instCommRing.{u2} β))))) (FreeCommRing.{u1} α) (FreeCommRing.{u2} β) (NonUnitalNonAssocSemiring.toMul.{u1} (FreeCommRing.{u1} α) (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u1} (FreeCommRing.{u1} α) (Semiring.toNonAssocSemiring.{u1} (FreeCommRing.{u1} α) (CommSemiring.toSemiring.{u1} (FreeCommRing.{u1} α) (CommRing.toCommSemiring.{u1} (FreeCommRing.{u1} α) (FreeCommRing.instCommRing.{u1} α)))))) (NonUnitalNonAssocSemiring.toMul.{u2} (FreeCommRing.{u2} β) (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u2} (FreeCommRing.{u2} β) (Semiring.toNonAssocSemiring.{u2} (FreeCommRing.{u2} β) (CommSemiring.toSemiring.{u2} (FreeCommRing.{u2} β) (CommRing.toCommSemiring.{u2} (FreeCommRing.{u2} β) (FreeCommRing.instCommRing.{u2} β)))))) (NonUnitalRingHomClass.toMulHomClass.{max u1 u2, u1, u2} (RingHom.{u1, u2} (FreeCommRing.{u1} α) (FreeCommRing.{u2} β) (Semiring.toNonAssocSemiring.{u1} (FreeCommRing.{u1} α) (CommSemiring.toSemiring.{u1} (FreeCommRing.{u1} α) (CommRing.toCommSemiring.{u1} (FreeCommRing.{u1} α) (FreeCommRing.instCommRing.{u1} α)))) (Semiring.toNonAssocSemiring.{u2} (FreeCommRing.{u2} β) (CommSemiring.toSemiring.{u2} (FreeCommRing.{u2} β) (CommRing.toCommSemiring.{u2} (FreeCommRing.{u2} β) (FreeCommRing.instCommRing.{u2} β))))) (FreeCommRing.{u1} α) (FreeCommRing.{u2} β) (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u1} (FreeCommRing.{u1} α) (Semiring.toNonAssocSemiring.{u1} (FreeCommRing.{u1} α) (CommSemiring.toSemiring.{u1} (FreeCommRing.{u1} α) (CommRing.toCommSemiring.{u1} (FreeCommRing.{u1} α) (FreeCommRing.instCommRing.{u1} α))))) (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u2} (FreeCommRing.{u2} β) (Semiring.toNonAssocSemiring.{u2} (FreeCommRing.{u2} β) (CommSemiring.toSemiring.{u2} (FreeCommRing.{u2} β) (CommRing.toCommSemiring.{u2} (FreeCommRing.{u2} β) (FreeCommRing.instCommRing.{u2} β))))) (RingHomClass.toNonUnitalRingHomClass.{max u1 u2, u1, u2} (RingHom.{u1, u2} (FreeCommRing.{u1} α) (FreeCommRing.{u2} β) (Semiring.toNonAssocSemiring.{u1} (FreeCommRing.{u1} α) (CommSemiring.toSemiring.{u1} (FreeCommRing.{u1} α) (CommRing.toCommSemiring.{u1} (FreeCommRing.{u1} α) (FreeCommRing.instCommRing.{u1} α)))) (Semiring.toNonAssocSemiring.{u2} (FreeCommRing.{u2} β) (CommSemiring.toSemiring.{u2} (FreeCommRing.{u2} β) (CommRing.toCommSemiring.{u2} (FreeCommRing.{u2} β) (FreeCommRing.instCommRing.{u2} β))))) (FreeCommRing.{u1} α) (FreeCommRing.{u2} β) (Semiring.toNonAssocSemiring.{u1} (FreeCommRing.{u1} α) (CommSemiring.toSemiring.{u1} (FreeCommRing.{u1} α) (CommRing.toCommSemiring.{u1} (FreeCommRing.{u1} α) (FreeCommRing.instCommRing.{u1} α)))) (Semiring.toNonAssocSemiring.{u2} (FreeCommRing.{u2} β) (CommSemiring.toSemiring.{u2} (FreeCommRing.{u2} β) (CommRing.toCommSemiring.{u2} (FreeCommRing.{u2} β) (FreeCommRing.instCommRing.{u2} β)))) (RingHom.instRingHomClassRingHom.{u1, u2} (FreeCommRing.{u1} α) (FreeCommRing.{u2} β) (Semiring.toNonAssocSemiring.{u1} (FreeCommRing.{u1} α) (CommSemiring.toSemiring.{u1} (FreeCommRing.{u1} α) (CommRing.toCommSemiring.{u1} (FreeCommRing.{u1} α) (FreeCommRing.instCommRing.{u1} α)))) (Semiring.toNonAssocSemiring.{u2} (FreeCommRing.{u2} β) (CommSemiring.toSemiring.{u2} (FreeCommRing.{u2} β) (CommRing.toCommSemiring.{u2} (FreeCommRing.{u2} β) (FreeCommRing.instCommRing.{u2} β)))))))) (FreeCommRing.map.{u1, u2} α β f) (FreeCommRing.of.{u1} α x)) (FreeCommRing.of.{u2} β (f x))
-Case conversion may be inaccurate. Consider using '#align free_comm_ring.map_of FreeCommRing.map_ofₓ'. -/
 @[simp]
 theorem map_of (x : α) : map f (of x) = of (f x) :=
   lift_of _ _
@@ -209,72 +188,30 @@ theorem isSupported_upwards (hs : IsSupported x s) (hst : s ⊆ t) : IsSupported
 #align free_comm_ring.is_supported_upwards FreeCommRing.isSupported_upwards
 -/
 
-/- warning: free_comm_ring.is_supported_add -> FreeCommRing.isSupported_add is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {x : FreeCommRing.{u1} α} {y : FreeCommRing.{u1} α} {s : Set.{u1} α}, (FreeCommRing.IsSupported.{u1} α x s) -> (FreeCommRing.IsSupported.{u1} α y s) -> (FreeCommRing.IsSupported.{u1} α (HAdd.hAdd.{u1, u1, u1} (FreeCommRing.{u1} α) (FreeCommRing.{u1} α) (FreeCommRing.{u1} α) (instHAdd.{u1} (FreeCommRing.{u1} α) (Distrib.toHasAdd.{u1} (FreeCommRing.{u1} α) (Ring.toDistrib.{u1} (FreeCommRing.{u1} α) (CommRing.toRing.{u1} (FreeCommRing.{u1} α) (FreeCommRing.instCommRing.{u1} α))))) x y) s)
-but is expected to have type
-  forall {α : Type.{u1}} {x : FreeCommRing.{u1} α} {y : FreeCommRing.{u1} α} {s : Set.{u1} α}, (FreeCommRing.IsSupported.{u1} α x s) -> (FreeCommRing.IsSupported.{u1} α y s) -> (FreeCommRing.IsSupported.{u1} α (HAdd.hAdd.{u1, u1, u1} (FreeCommRing.{u1} α) (FreeCommRing.{u1} α) (FreeCommRing.{u1} α) (instHAdd.{u1} (FreeCommRing.{u1} α) (Distrib.toAdd.{u1} (FreeCommRing.{u1} α) (NonUnitalNonAssocSemiring.toDistrib.{u1} (FreeCommRing.{u1} α) (NonUnitalNonAssocRing.toNonUnitalNonAssocSemiring.{u1} (FreeCommRing.{u1} α) (NonAssocRing.toNonUnitalNonAssocRing.{u1} (FreeCommRing.{u1} α) (Ring.toNonAssocRing.{u1} (FreeCommRing.{u1} α) (CommRing.toRing.{u1} (FreeCommRing.{u1} α) (FreeCommRing.instCommRing.{u1} α)))))))) x y) s)
-Case conversion may be inaccurate. Consider using '#align free_comm_ring.is_supported_add FreeCommRing.isSupported_addₓ'. -/
 theorem isSupported_add (hxs : IsSupported x s) (hys : IsSupported y s) : IsSupported (x + y) s :=
   Subring.add_mem _ hxs hys
 #align free_comm_ring.is_supported_add FreeCommRing.isSupported_add
 
-/- warning: free_comm_ring.is_supported_neg -> FreeCommRing.isSupported_neg is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {x : FreeCommRing.{u1} α} {s : Set.{u1} α}, (FreeCommRing.IsSupported.{u1} α x s) -> (FreeCommRing.IsSupported.{u1} α (Neg.neg.{u1} (FreeCommRing.{u1} α) (SubNegMonoid.toHasNeg.{u1} (FreeCommRing.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeCommRing.{u1} α) (AddGroupWithOne.toAddGroup.{u1} (FreeCommRing.{u1} α) (AddCommGroupWithOne.toAddGroupWithOne.{u1} (FreeCommRing.{u1} α) (Ring.toAddCommGroupWithOne.{u1} (FreeCommRing.{u1} α) (CommRing.toRing.{u1} (FreeCommRing.{u1} α) (FreeCommRing.instCommRing.{u1} α))))))) x) s)
-but is expected to have type
-  forall {α : Type.{u1}} {x : FreeCommRing.{u1} α} {s : Set.{u1} α}, (FreeCommRing.IsSupported.{u1} α x s) -> (FreeCommRing.IsSupported.{u1} α (Neg.neg.{u1} (FreeCommRing.{u1} α) (Ring.toNeg.{u1} (FreeCommRing.{u1} α) (CommRing.toRing.{u1} (FreeCommRing.{u1} α) (FreeCommRing.instCommRing.{u1} α))) x) s)
-Case conversion may be inaccurate. Consider using '#align free_comm_ring.is_supported_neg FreeCommRing.isSupported_negₓ'. -/
 theorem isSupported_neg (hxs : IsSupported x s) : IsSupported (-x) s :=
   Subring.neg_mem _ hxs
 #align free_comm_ring.is_supported_neg FreeCommRing.isSupported_neg
 
-/- warning: free_comm_ring.is_supported_sub -> FreeCommRing.isSupported_sub is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {x : FreeCommRing.{u1} α} {y : FreeCommRing.{u1} α} {s : Set.{u1} α}, (FreeCommRing.IsSupported.{u1} α x s) -> (FreeCommRing.IsSupported.{u1} α y s) -> (FreeCommRing.IsSupported.{u1} α (HSub.hSub.{u1, u1, u1} (FreeCommRing.{u1} α) (FreeCommRing.{u1} α) (FreeCommRing.{u1} α) (instHSub.{u1} (FreeCommRing.{u1} α) (SubNegMonoid.toHasSub.{u1} (FreeCommRing.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeCommRing.{u1} α) (AddGroupWithOne.toAddGroup.{u1} (FreeCommRing.{u1} α) (AddCommGroupWithOne.toAddGroupWithOne.{u1} (FreeCommRing.{u1} α) (Ring.toAddCommGroupWithOne.{u1} (FreeCommRing.{u1} α) (CommRing.toRing.{u1} (FreeCommRing.{u1} α) (FreeCommRing.instCommRing.{u1} α)))))))) x y) s)
-but is expected to have type
-  forall {α : Type.{u1}} {x : FreeCommRing.{u1} α} {y : FreeCommRing.{u1} α} {s : Set.{u1} α}, (FreeCommRing.IsSupported.{u1} α x s) -> (FreeCommRing.IsSupported.{u1} α y s) -> (FreeCommRing.IsSupported.{u1} α (HSub.hSub.{u1, u1, u1} (FreeCommRing.{u1} α) (FreeCommRing.{u1} α) (FreeCommRing.{u1} α) (instHSub.{u1} (FreeCommRing.{u1} α) (Ring.toSub.{u1} (FreeCommRing.{u1} α) (CommRing.toRing.{u1} (FreeCommRing.{u1} α) (FreeCommRing.instCommRing.{u1} α)))) x y) s)
-Case conversion may be inaccurate. Consider using '#align free_comm_ring.is_supported_sub FreeCommRing.isSupported_subₓ'. -/
 theorem isSupported_sub (hxs : IsSupported x s) (hys : IsSupported y s) : IsSupported (x - y) s :=
   Subring.sub_mem _ hxs hys
 #align free_comm_ring.is_supported_sub FreeCommRing.isSupported_sub
 
-/- warning: free_comm_ring.is_supported_mul -> FreeCommRing.isSupported_mul is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {x : FreeCommRing.{u1} α} {y : FreeCommRing.{u1} α} {s : Set.{u1} α}, (FreeCommRing.IsSupported.{u1} α x s) -> (FreeCommRing.IsSupported.{u1} α y s) -> (FreeCommRing.IsSupported.{u1} α (HMul.hMul.{u1, u1, u1} (FreeCommRing.{u1} α) (FreeCommRing.{u1} α) (FreeCommRing.{u1} α) (instHMul.{u1} (FreeCommRing.{u1} α) (Distrib.toHasMul.{u1} (FreeCommRing.{u1} α) (Ring.toDistrib.{u1} (FreeCommRing.{u1} α) (CommRing.toRing.{u1} (FreeCommRing.{u1} α) (FreeCommRing.instCommRing.{u1} α))))) x y) s)
-but is expected to have type
-  forall {α : Type.{u1}} {x : FreeCommRing.{u1} α} {y : FreeCommRing.{u1} α} {s : Set.{u1} α}, (FreeCommRing.IsSupported.{u1} α x s) -> (FreeCommRing.IsSupported.{u1} α y s) -> (FreeCommRing.IsSupported.{u1} α (HMul.hMul.{u1, u1, u1} (FreeCommRing.{u1} α) (FreeCommRing.{u1} α) (FreeCommRing.{u1} α) (instHMul.{u1} (FreeCommRing.{u1} α) (NonUnitalNonAssocRing.toMul.{u1} (FreeCommRing.{u1} α) (NonAssocRing.toNonUnitalNonAssocRing.{u1} (FreeCommRing.{u1} α) (Ring.toNonAssocRing.{u1} (FreeCommRing.{u1} α) (CommRing.toRing.{u1} (FreeCommRing.{u1} α) (FreeCommRing.instCommRing.{u1} α)))))) x y) s)
-Case conversion may be inaccurate. Consider using '#align free_comm_ring.is_supported_mul FreeCommRing.isSupported_mulₓ'. -/
 theorem isSupported_mul (hxs : IsSupported x s) (hys : IsSupported y s) : IsSupported (x * y) s :=
   Subring.mul_mem _ hxs hys
 #align free_comm_ring.is_supported_mul FreeCommRing.isSupported_mul
 
-/- warning: free_comm_ring.is_supported_zero -> FreeCommRing.isSupported_zero is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {s : Set.{u1} α}, FreeCommRing.IsSupported.{u1} α (OfNat.ofNat.{u1} (FreeCommRing.{u1} α) 0 (OfNat.mk.{u1} (FreeCommRing.{u1} α) 0 (Zero.zero.{u1} (FreeCommRing.{u1} α) (MulZeroClass.toHasZero.{u1} (FreeCommRing.{u1} α) (NonUnitalNonAssocSemiring.toMulZeroClass.{u1} (FreeCommRing.{u1} α) (NonUnitalNonAssocRing.toNonUnitalNonAssocSemiring.{u1} (FreeCommRing.{u1} α) (NonAssocRing.toNonUnitalNonAssocRing.{u1} (FreeCommRing.{u1} α) (Ring.toNonAssocRing.{u1} (FreeCommRing.{u1} α) (CommRing.toRing.{u1} (FreeCommRing.{u1} α) (FreeCommRing.instCommRing.{u1} α)))))))))) s
-but is expected to have type
-  forall {α : Type.{u1}} {s : Set.{u1} α}, FreeCommRing.IsSupported.{u1} α (OfNat.ofNat.{u1} (FreeCommRing.{u1} α) 0 (Zero.toOfNat0.{u1} (FreeCommRing.{u1} α) (CommMonoidWithZero.toZero.{u1} (FreeCommRing.{u1} α) (CommSemiring.toCommMonoidWithZero.{u1} (FreeCommRing.{u1} α) (CommRing.toCommSemiring.{u1} (FreeCommRing.{u1} α) (FreeCommRing.instCommRing.{u1} α)))))) s
-Case conversion may be inaccurate. Consider using '#align free_comm_ring.is_supported_zero FreeCommRing.isSupported_zeroₓ'. -/
 theorem isSupported_zero : IsSupported 0 s :=
   Subring.zero_mem _
 #align free_comm_ring.is_supported_zero FreeCommRing.isSupported_zero
 
-/- warning: free_comm_ring.is_supported_one -> FreeCommRing.isSupported_one is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {s : Set.{u1} α}, FreeCommRing.IsSupported.{u1} α (OfNat.ofNat.{u1} (FreeCommRing.{u1} α) 1 (OfNat.mk.{u1} (FreeCommRing.{u1} α) 1 (One.one.{u1} (FreeCommRing.{u1} α) (AddMonoidWithOne.toOne.{u1} (FreeCommRing.{u1} α) (AddGroupWithOne.toAddMonoidWithOne.{u1} (FreeCommRing.{u1} α) (AddCommGroupWithOne.toAddGroupWithOne.{u1} (FreeCommRing.{u1} α) (Ring.toAddCommGroupWithOne.{u1} (FreeCommRing.{u1} α) (CommRing.toRing.{u1} (FreeCommRing.{u1} α) (FreeCommRing.instCommRing.{u1} α))))))))) s
-but is expected to have type
-  forall {α : Type.{u1}} {s : Set.{u1} α}, FreeCommRing.IsSupported.{u1} α (OfNat.ofNat.{u1} (FreeCommRing.{u1} α) 1 (One.toOfNat1.{u1} (FreeCommRing.{u1} α) (Semiring.toOne.{u1} (FreeCommRing.{u1} α) (CommSemiring.toSemiring.{u1} (FreeCommRing.{u1} α) (CommRing.toCommSemiring.{u1} (FreeCommRing.{u1} α) (FreeCommRing.instCommRing.{u1} α)))))) s
-Case conversion may be inaccurate. Consider using '#align free_comm_ring.is_supported_one FreeCommRing.isSupported_oneₓ'. -/
 theorem isSupported_one : IsSupported 1 s :=
   Subring.one_mem _
 #align free_comm_ring.is_supported_one FreeCommRing.isSupported_one
 
-/- warning: free_comm_ring.is_supported_int -> FreeCommRing.isSupported_int is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {i : Int} {s : Set.{u1} α}, FreeCommRing.IsSupported.{u1} α ((fun (a : Type) (b : Type.{u1}) [self : HasLiftT.{1, succ u1} a b] => self.0) Int (FreeCommRing.{u1} α) (HasLiftT.mk.{1, succ u1} Int (FreeCommRing.{u1} α) (CoeTCₓ.coe.{1, succ u1} Int (FreeCommRing.{u1} α) (Int.castCoe.{u1} (FreeCommRing.{u1} α) (AddGroupWithOne.toHasIntCast.{u1} (FreeCommRing.{u1} α) (AddCommGroupWithOne.toAddGroupWithOne.{u1} (FreeCommRing.{u1} α) (Ring.toAddCommGroupWithOne.{u1} (FreeCommRing.{u1} α) (CommRing.toRing.{u1} (FreeCommRing.{u1} α) (FreeCommRing.instCommRing.{u1} α)))))))) i) s
-but is expected to have type
-  forall {α : Type.{u1}} {i : Int} {s : Set.{u1} α}, FreeCommRing.IsSupported.{u1} α (Int.cast.{u1} (FreeCommRing.{u1} α) (Ring.toIntCast.{u1} (FreeCommRing.{u1} α) (CommRing.toRing.{u1} (FreeCommRing.{u1} α) (FreeCommRing.instCommRing.{u1} α))) i) s
-Case conversion may be inaccurate. Consider using '#align free_comm_ring.is_supported_int FreeCommRing.isSupported_intₓ'. -/
 theorem isSupported_int {i : ℤ} {s : Set α} : IsSupported (↑i) s :=
   Int.induction_on i isSupported_zero
     (fun i hi => by rw [Int.cast_add, Int.cast_one] <;> exact is_supported_add hi is_supported_one)
@@ -295,9 +232,6 @@ section Restriction
 
 variable (s : Set α) [DecidablePred (· ∈ s)] (x y : FreeCommRing α)
 
-/- warning: free_comm_ring.restriction_of -> FreeCommRing.restriction_of is a dubious translation:
-<too large>
-Case conversion may be inaccurate. Consider using '#align free_comm_ring.restriction_of FreeCommRing.restriction_ofₓ'. -/
 @[simp]
 theorem restriction_of (p) : restriction s (of p) = if H : p ∈ s then of ⟨p, H⟩ else 0 :=
   lift_of _ _
@@ -331,9 +265,6 @@ theorem isSupported_of {p} {s : Set α} : IsSupported (of p) s ↔ p ∈ s :=
 #align free_comm_ring.is_supported_of FreeCommRing.isSupported_of
 -/
 
-/- warning: free_comm_ring.map_subtype_val_restriction -> FreeCommRing.map_subtype_val_restriction is a dubious translation:
-<too large>
-Case conversion may be inaccurate. Consider using '#align free_comm_ring.map_subtype_val_restriction FreeCommRing.map_subtype_val_restrictionₓ'. -/
 theorem map_subtype_val_restriction {x} (s : Set α) [DecidablePred (· ∈ s)]
     (hxs : IsSupported x s) : map (Subtype.val : s → α) (restriction s x) = x :=
   by
@@ -393,23 +324,11 @@ def coeRingHom : FreeRing α →+* FreeCommRing α :=
 #align free_ring.coe_ring_hom FreeRing.coeRingHom
 -/
 
-/- warning: free_ring.coe_zero -> FreeRing.coe_zero is a dubious translation:
-lean 3 declaration is
-  forall (α : Type.{u1}), Eq.{succ u1} (FreeCommRing.{u1} α) ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) (FreeRing.{u1} α) (FreeCommRing.{u1} α) (HasLiftT.mk.{succ u1, succ u1} (FreeRing.{u1} α) (FreeCommRing.{u1} α) (CoeTCₓ.coe.{succ u1, succ u1} (FreeRing.{u1} α) (FreeCommRing.{u1} α) (coeBase.{succ u1, succ u1} (FreeRing.{u1} α) (FreeCommRing.{u1} α) (FreeRing.FreeCommRing.instCoe.{u1} α)))) (OfNat.ofNat.{u1} (FreeRing.{u1} α) 0 (OfNat.mk.{u1} (FreeRing.{u1} α) 0 (Zero.zero.{u1} (FreeRing.{u1} α) (MulZeroClass.toHasZero.{u1} (FreeRing.{u1} α) (NonUnitalNonAssocSemiring.toMulZeroClass.{u1} (FreeRing.{u1} α) (NonUnitalNonAssocRing.toNonUnitalNonAssocSemiring.{u1} (FreeRing.{u1} α) (NonAssocRing.toNonUnitalNonAssocRing.{u1} (FreeRing.{u1} α) (Ring.toNonAssocRing.{u1} (FreeRing.{u1} α) (FreeRing.ring.{u1} α)))))))))) (OfNat.ofNat.{u1} (FreeCommRing.{u1} α) 0 (OfNat.mk.{u1} (FreeCommRing.{u1} α) 0 (Zero.zero.{u1} (FreeCommRing.{u1} α) (MulZeroClass.toHasZero.{u1} (FreeCommRing.{u1} α) (NonUnitalNonAssocSemiring.toMulZeroClass.{u1} (FreeCommRing.{u1} α) (NonUnitalNonAssocRing.toNonUnitalNonAssocSemiring.{u1} (FreeCommRing.{u1} α) (NonAssocRing.toNonUnitalNonAssocRing.{u1} (FreeCommRing.{u1} α) (Ring.toNonAssocRing.{u1} (FreeCommRing.{u1} α) (CommRing.toRing.{u1} (FreeCommRing.{u1} α) (FreeCommRing.instCommRing.{u1} α))))))))))
-but is expected to have type
-  forall (α : Type.{u1}), Eq.{succ u1} (FreeCommRing.{u1} α) (FreeRing.castFreeCommRing.{u1} α (OfNat.ofNat.{u1} (FreeRing.{u1} α) 0 (Zero.toOfNat0.{u1} (FreeRing.{u1} α) (MonoidWithZero.toZero.{u1} (FreeRing.{u1} α) (Semiring.toMonoidWithZero.{u1} (FreeRing.{u1} α) (Ring.toSemiring.{u1} (FreeRing.{u1} α) (instRingFreeRing.{u1} α))))))) (OfNat.ofNat.{u1} (FreeCommRing.{u1} α) 0 (Zero.toOfNat0.{u1} (FreeCommRing.{u1} α) (CommMonoidWithZero.toZero.{u1} (FreeCommRing.{u1} α) (CommSemiring.toCommMonoidWithZero.{u1} (FreeCommRing.{u1} α) (CommRing.toCommSemiring.{u1} (FreeCommRing.{u1} α) (FreeCommRing.instCommRing.{u1} α))))))
-Case conversion may be inaccurate. Consider using '#align free_ring.coe_zero FreeRing.coe_zeroₓ'. -/
 @[simp, norm_cast]
 protected theorem coe_zero : ↑(0 : FreeRing α) = (0 : FreeCommRing α) :=
   rfl
 #align free_ring.coe_zero FreeRing.coe_zero
 
-/- warning: free_ring.coe_one -> FreeRing.coe_one is a dubious translation:
-lean 3 declaration is
-  forall (α : Type.{u1}), Eq.{succ u1} (FreeCommRing.{u1} α) ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) (FreeRing.{u1} α) (FreeCommRing.{u1} α) (HasLiftT.mk.{succ u1, succ u1} (FreeRing.{u1} α) (FreeCommRing.{u1} α) (CoeTCₓ.coe.{succ u1, succ u1} (FreeRing.{u1} α) (FreeCommRing.{u1} α) (coeBase.{succ u1, succ u1} (FreeRing.{u1} α) (FreeCommRing.{u1} α) (FreeRing.FreeCommRing.instCoe.{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} α))))))))) (OfNat.ofNat.{u1} (FreeCommRing.{u1} α) 1 (OfNat.mk.{u1} (FreeCommRing.{u1} α) 1 (One.one.{u1} (FreeCommRing.{u1} α) (AddMonoidWithOne.toOne.{u1} (FreeCommRing.{u1} α) (AddGroupWithOne.toAddMonoidWithOne.{u1} (FreeCommRing.{u1} α) (AddCommGroupWithOne.toAddGroupWithOne.{u1} (FreeCommRing.{u1} α) (Ring.toAddCommGroupWithOne.{u1} (FreeCommRing.{u1} α) (CommRing.toRing.{u1} (FreeCommRing.{u1} α) (FreeCommRing.instCommRing.{u1} α)))))))))
-but is expected to have type
-  forall (α : Type.{u1}), Eq.{succ u1} (FreeCommRing.{u1} α) (FreeRing.castFreeCommRing.{u1} α (OfNat.ofNat.{u1} (FreeRing.{u1} α) 1 (One.toOfNat1.{u1} (FreeRing.{u1} α) (Semiring.toOne.{u1} (FreeRing.{u1} α) (Ring.toSemiring.{u1} (FreeRing.{u1} α) (instRingFreeRing.{u1} α)))))) (OfNat.ofNat.{u1} (FreeCommRing.{u1} α) 1 (One.toOfNat1.{u1} (FreeCommRing.{u1} α) (Semiring.toOne.{u1} (FreeCommRing.{u1} α) (CommSemiring.toSemiring.{u1} (FreeCommRing.{u1} α) (CommRing.toCommSemiring.{u1} (FreeCommRing.{u1} α) (FreeCommRing.instCommRing.{u1} α))))))
-Case conversion may be inaccurate. Consider using '#align free_ring.coe_one FreeRing.coe_oneₓ'. -/
 @[simp, norm_cast]
 protected theorem coe_one : ↑(1 : FreeRing α) = (1 : FreeCommRing α) :=
   rfl
@@ -424,45 +343,21 @@ protected theorem coe_of (a : α) : ↑(FreeRing.of a) = FreeCommRing.of a :=
 #align free_ring.coe_of FreeRing.coe_of
 -/
 
-/- warning: free_ring.coe_neg -> FreeRing.coe_neg is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} (x : FreeRing.{u1} α), Eq.{succ u1} (FreeCommRing.{u1} α) ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) (FreeRing.{u1} α) (FreeCommRing.{u1} α) (HasLiftT.mk.{succ u1, succ u1} (FreeRing.{u1} α) (FreeCommRing.{u1} α) (CoeTCₓ.coe.{succ u1, succ u1} (FreeRing.{u1} α) (FreeCommRing.{u1} α) (coeBase.{succ u1, succ u1} (FreeRing.{u1} α) (FreeCommRing.{u1} α) (FreeRing.FreeCommRing.instCoe.{u1} α)))) (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} α)))))) x)) (Neg.neg.{u1} (FreeCommRing.{u1} α) (SubNegMonoid.toHasNeg.{u1} (FreeCommRing.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeCommRing.{u1} α) (AddGroupWithOne.toAddGroup.{u1} (FreeCommRing.{u1} α) (AddCommGroupWithOne.toAddGroupWithOne.{u1} (FreeCommRing.{u1} α) (Ring.toAddCommGroupWithOne.{u1} (FreeCommRing.{u1} α) (CommRing.toRing.{u1} (FreeCommRing.{u1} α) (FreeCommRing.instCommRing.{u1} α))))))) ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) (FreeRing.{u1} α) (FreeCommRing.{u1} α) (HasLiftT.mk.{succ u1, succ u1} (FreeRing.{u1} α) (FreeCommRing.{u1} α) (CoeTCₓ.coe.{succ u1, succ u1} (FreeRing.{u1} α) (FreeCommRing.{u1} α) (coeBase.{succ u1, succ u1} (FreeRing.{u1} α) (FreeCommRing.{u1} α) (FreeRing.FreeCommRing.instCoe.{u1} α)))) x))
-but is expected to have type
-  forall {α : Type.{u1}} (x : FreeRing.{u1} α), Eq.{succ u1} (FreeCommRing.{u1} α) (FreeRing.castFreeCommRing.{u1} α (Neg.neg.{u1} (FreeRing.{u1} α) (Ring.toNeg.{u1} (FreeRing.{u1} α) (instRingFreeRing.{u1} α)) x)) (Neg.neg.{u1} (FreeCommRing.{u1} α) (Ring.toNeg.{u1} (FreeCommRing.{u1} α) (CommRing.toRing.{u1} (FreeCommRing.{u1} α) (FreeCommRing.instCommRing.{u1} α))) (FreeRing.castFreeCommRing.{u1} α x))
-Case conversion may be inaccurate. Consider using '#align free_ring.coe_neg FreeRing.coe_negₓ'. -/
 @[simp, norm_cast]
 protected theorem coe_neg (x : FreeRing α) : ↑(-x) = -(x : FreeCommRing α) :=
   (FreeRing.lift _).map_neg _
 #align free_ring.coe_neg FreeRing.coe_neg
 
-/- warning: free_ring.coe_add -> FreeRing.coe_add is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} (x : FreeRing.{u1} α) (y : FreeRing.{u1} α), Eq.{succ u1} (FreeCommRing.{u1} α) ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) (FreeRing.{u1} α) (FreeCommRing.{u1} α) (HasLiftT.mk.{succ u1, succ u1} (FreeRing.{u1} α) (FreeCommRing.{u1} α) (CoeTCₓ.coe.{succ u1, succ u1} (FreeRing.{u1} α) (FreeCommRing.{u1} α) (coeBase.{succ u1, succ u1} (FreeRing.{u1} α) (FreeCommRing.{u1} α) (FreeRing.FreeCommRing.instCoe.{u1} α)))) (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)) (HAdd.hAdd.{u1, u1, u1} (FreeCommRing.{u1} α) (FreeCommRing.{u1} α) (FreeCommRing.{u1} α) (instHAdd.{u1} (FreeCommRing.{u1} α) (Distrib.toHasAdd.{u1} (FreeCommRing.{u1} α) (Ring.toDistrib.{u1} (FreeCommRing.{u1} α) (CommRing.toRing.{u1} (FreeCommRing.{u1} α) (FreeCommRing.instCommRing.{u1} α))))) ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) (FreeRing.{u1} α) (FreeCommRing.{u1} α) (HasLiftT.mk.{succ u1, succ u1} (FreeRing.{u1} α) (FreeCommRing.{u1} α) (CoeTCₓ.coe.{succ u1, succ u1} (FreeRing.{u1} α) (FreeCommRing.{u1} α) (coeBase.{succ u1, succ u1} (FreeRing.{u1} α) (FreeCommRing.{u1} α) (FreeRing.FreeCommRing.instCoe.{u1} α)))) x) ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) (FreeRing.{u1} α) (FreeCommRing.{u1} α) (HasLiftT.mk.{succ u1, succ u1} (FreeRing.{u1} α) (FreeCommRing.{u1} α) (CoeTCₓ.coe.{succ u1, succ u1} (FreeRing.{u1} α) (FreeCommRing.{u1} α) (coeBase.{succ u1, succ u1} (FreeRing.{u1} α) (FreeCommRing.{u1} α) (FreeRing.FreeCommRing.instCoe.{u1} α)))) y))
-but is expected to have type
-  forall {α : Type.{u1}} (x : FreeRing.{u1} α) (y : FreeRing.{u1} α), Eq.{succ u1} (FreeCommRing.{u1} α) (FreeRing.castFreeCommRing.{u1} α (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)) (HAdd.hAdd.{u1, u1, u1} (FreeCommRing.{u1} α) (FreeCommRing.{u1} α) (FreeCommRing.{u1} α) (instHAdd.{u1} (FreeCommRing.{u1} α) (Distrib.toAdd.{u1} (FreeCommRing.{u1} α) (NonUnitalNonAssocSemiring.toDistrib.{u1} (FreeCommRing.{u1} α) (NonUnitalNonAssocRing.toNonUnitalNonAssocSemiring.{u1} (FreeCommRing.{u1} α) (NonAssocRing.toNonUnitalNonAssocRing.{u1} (FreeCommRing.{u1} α) (Ring.toNonAssocRing.{u1} (FreeCommRing.{u1} α) (CommRing.toRing.{u1} (FreeCommRing.{u1} α) (FreeCommRing.instCommRing.{u1} α)))))))) (FreeRing.castFreeCommRing.{u1} α x) (FreeRing.castFreeCommRing.{u1} α y))
-Case conversion may be inaccurate. Consider using '#align free_ring.coe_add FreeRing.coe_addₓ'. -/
 @[simp, norm_cast]
 protected theorem coe_add (x y : FreeRing α) : ↑(x + y) = (x : FreeCommRing α) + y :=
   (FreeRing.lift _).map_add _ _
 #align free_ring.coe_add FreeRing.coe_add
 
-/- warning: free_ring.coe_sub -> FreeRing.coe_sub is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} (x : FreeRing.{u1} α) (y : FreeRing.{u1} α), Eq.{succ u1} (FreeCommRing.{u1} α) ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) (FreeRing.{u1} α) (FreeCommRing.{u1} α) (HasLiftT.mk.{succ u1, succ u1} (FreeRing.{u1} α) (FreeCommRing.{u1} α) (CoeTCₓ.coe.{succ u1, succ u1} (FreeRing.{u1} α) (FreeCommRing.{u1} α) (coeBase.{succ u1, succ u1} (FreeRing.{u1} α) (FreeCommRing.{u1} α) (FreeRing.FreeCommRing.instCoe.{u1} α)))) (HSub.hSub.{u1, u1, u1} (FreeRing.{u1} α) (FreeRing.{u1} α) (FreeRing.{u1} α) (instHSub.{u1} (FreeRing.{u1} α) (SubNegMonoid.toHasSub.{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} α))))))) x y)) (HSub.hSub.{u1, u1, u1} (FreeCommRing.{u1} α) (FreeCommRing.{u1} α) (FreeCommRing.{u1} α) (instHSub.{u1} (FreeCommRing.{u1} α) (SubNegMonoid.toHasSub.{u1} (FreeCommRing.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeCommRing.{u1} α) (AddGroupWithOne.toAddGroup.{u1} (FreeCommRing.{u1} α) (AddCommGroupWithOne.toAddGroupWithOne.{u1} (FreeCommRing.{u1} α) (Ring.toAddCommGroupWithOne.{u1} (FreeCommRing.{u1} α) (CommRing.toRing.{u1} (FreeCommRing.{u1} α) (FreeCommRing.instCommRing.{u1} α)))))))) ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) (FreeRing.{u1} α) (FreeCommRing.{u1} α) (HasLiftT.mk.{succ u1, succ u1} (FreeRing.{u1} α) (FreeCommRing.{u1} α) (CoeTCₓ.coe.{succ u1, succ u1} (FreeRing.{u1} α) (FreeCommRing.{u1} α) (coeBase.{succ u1, succ u1} (FreeRing.{u1} α) (FreeCommRing.{u1} α) (FreeRing.FreeCommRing.instCoe.{u1} α)))) x) ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) (FreeRing.{u1} α) (FreeCommRing.{u1} α) (HasLiftT.mk.{succ u1, succ u1} (FreeRing.{u1} α) (FreeCommRing.{u1} α) (CoeTCₓ.coe.{succ u1, succ u1} (FreeRing.{u1} α) (FreeCommRing.{u1} α) (coeBase.{succ u1, succ u1} (FreeRing.{u1} α) (FreeCommRing.{u1} α) (FreeRing.FreeCommRing.instCoe.{u1} α)))) y))
-but is expected to have type
-  forall {α : Type.{u1}} (x : FreeRing.{u1} α) (y : FreeRing.{u1} α), Eq.{succ u1} (FreeCommRing.{u1} α) (FreeRing.castFreeCommRing.{u1} α (HSub.hSub.{u1, u1, u1} (FreeRing.{u1} α) (FreeRing.{u1} α) (FreeRing.{u1} α) (instHSub.{u1} (FreeRing.{u1} α) (Ring.toSub.{u1} (FreeRing.{u1} α) (instRingFreeRing.{u1} α))) x y)) (HSub.hSub.{u1, u1, u1} (FreeCommRing.{u1} α) (FreeCommRing.{u1} α) (FreeCommRing.{u1} α) (instHSub.{u1} (FreeCommRing.{u1} α) (Ring.toSub.{u1} (FreeCommRing.{u1} α) (CommRing.toRing.{u1} (FreeCommRing.{u1} α) (FreeCommRing.instCommRing.{u1} α)))) (FreeRing.castFreeCommRing.{u1} α x) (FreeRing.castFreeCommRing.{u1} α y))
-Case conversion may be inaccurate. Consider using '#align free_ring.coe_sub FreeRing.coe_subₓ'. -/
 @[simp, norm_cast]
 protected theorem coe_sub (x y : FreeRing α) : ↑(x - y) = (x : FreeCommRing α) - y :=
   (FreeRing.lift _).map_sub _ _
 #align free_ring.coe_sub FreeRing.coe_sub
 
-/- warning: free_ring.coe_mul -> FreeRing.coe_mul is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} (x : FreeRing.{u1} α) (y : FreeRing.{u1} α), Eq.{succ u1} (FreeCommRing.{u1} α) ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) (FreeRing.{u1} α) (FreeCommRing.{u1} α) (HasLiftT.mk.{succ u1, succ u1} (FreeRing.{u1} α) (FreeCommRing.{u1} α) (CoeTCₓ.coe.{succ u1, succ u1} (FreeRing.{u1} α) (FreeCommRing.{u1} α) (coeBase.{succ u1, succ u1} (FreeRing.{u1} α) (FreeCommRing.{u1} α) (FreeRing.FreeCommRing.instCoe.{u1} α)))) (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)) (HMul.hMul.{u1, u1, u1} (FreeCommRing.{u1} α) (FreeCommRing.{u1} α) (FreeCommRing.{u1} α) (instHMul.{u1} (FreeCommRing.{u1} α) (Distrib.toHasMul.{u1} (FreeCommRing.{u1} α) (Ring.toDistrib.{u1} (FreeCommRing.{u1} α) (CommRing.toRing.{u1} (FreeCommRing.{u1} α) (FreeCommRing.instCommRing.{u1} α))))) ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) (FreeRing.{u1} α) (FreeCommRing.{u1} α) (HasLiftT.mk.{succ u1, succ u1} (FreeRing.{u1} α) (FreeCommRing.{u1} α) (CoeTCₓ.coe.{succ u1, succ u1} (FreeRing.{u1} α) (FreeCommRing.{u1} α) (coeBase.{succ u1, succ u1} (FreeRing.{u1} α) (FreeCommRing.{u1} α) (FreeRing.FreeCommRing.instCoe.{u1} α)))) x) ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) (FreeRing.{u1} α) (FreeCommRing.{u1} α) (HasLiftT.mk.{succ u1, succ u1} (FreeRing.{u1} α) (FreeCommRing.{u1} α) (CoeTCₓ.coe.{succ u1, succ u1} (FreeRing.{u1} α) (FreeCommRing.{u1} α) (coeBase.{succ u1, succ u1} (FreeRing.{u1} α) (FreeCommRing.{u1} α) (FreeRing.FreeCommRing.instCoe.{u1} α)))) y))
-but is expected to have type
-  forall {α : Type.{u1}} (x : FreeRing.{u1} α) (y : FreeRing.{u1} α), Eq.{succ u1} (FreeCommRing.{u1} α) (FreeRing.castFreeCommRing.{u1} α (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)) (HMul.hMul.{u1, u1, u1} (FreeCommRing.{u1} α) (FreeCommRing.{u1} α) (FreeCommRing.{u1} α) (instHMul.{u1} (FreeCommRing.{u1} α) (NonUnitalNonAssocRing.toMul.{u1} (FreeCommRing.{u1} α) (NonAssocRing.toNonUnitalNonAssocRing.{u1} (FreeCommRing.{u1} α) (Ring.toNonAssocRing.{u1} (FreeCommRing.{u1} α) (CommRing.toRing.{u1} (FreeCommRing.{u1} α) (FreeCommRing.instCommRing.{u1} α)))))) (FreeRing.castFreeCommRing.{u1} α x) (FreeRing.castFreeCommRing.{u1} α y))
-Case conversion may be inaccurate. Consider using '#align free_ring.coe_mul FreeRing.coe_mulₓ'. -/
 @[simp, norm_cast]
 protected theorem coe_mul (x y : FreeRing α) : ↑(x * y) = (x : FreeCommRing α) * y :=
   (FreeRing.lift _).map_mul _ _
@@ -481,12 +376,6 @@ protected theorem coe_surjective : Surjective (coe : FreeRing α → FreeCommRin
 #align free_ring.coe_surjective FreeRing.coe_surjective
 -/
 
-/- warning: free_ring.coe_eq -> FreeRing.coe_eq is a dubious translation:
-lean 3 declaration is
-  forall (α : Type.{u1}), Eq.{succ u1} ((FreeRing.{u1} α) -> (FreeCommRing.{u1} α)) ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) (FreeRing.{u1} α) (FreeCommRing.{u1} α) (HasLiftT.mk.{succ u1, succ u1} (FreeRing.{u1} α) (FreeCommRing.{u1} α) (CoeTCₓ.coe.{succ u1, succ u1} (FreeRing.{u1} α) (FreeCommRing.{u1} α) (coeBase.{succ u1, succ u1} (FreeRing.{u1} α) (FreeCommRing.{u1} α) (FreeRing.FreeCommRing.instCoe.{u1} α))))) (Functor.map.{u1, u1} FreeAbelianGroup.{u1} (Applicative.toFunctor.{u1, u1} FreeAbelianGroup.{u1} (Monad.toApplicative.{u1, u1} FreeAbelianGroup.{u1} FreeAbelianGroup.monad.{u1})) (List.{u1} α) (Multiset.{u1} α) (fun (l : List.{u1} α) => (fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) (List.{u1} α) (Multiset.{u1} α) (HasLiftT.mk.{succ u1, succ u1} (List.{u1} α) (Multiset.{u1} α) (CoeTCₓ.coe.{succ u1, succ u1} (List.{u1} α) (Multiset.{u1} α) (coeBase.{succ u1, succ u1} (List.{u1} α) (Multiset.{u1} α) (Multiset.hasCoe.{u1} α)))) l))
-but is expected to have type
-  forall (α : Type.{u1}), Eq.{succ u1} ((FreeRing.{u1} α) -> (FreeCommRing.{u1} α)) (FreeRing.castFreeCommRing.{u1} α) (Functor.map.{u1, u1} FreeAbelianGroup.{u1} (Applicative.toFunctor.{u1, u1} FreeAbelianGroup.{u1} (Monad.toApplicative.{u1, u1} FreeAbelianGroup.{u1} FreeAbelianGroup.instMonadFreeAbelianGroup.{u1})) (List.{u1} α) (Multiset.{u1} α) (fun (l : List.{u1} α) => Multiset.ofList.{u1} α l))
-Case conversion may be inaccurate. Consider using '#align free_ring.coe_eq FreeRing.coe_eqₓ'. -/
 theorem coe_eq :
     (coe : FreeRing α → FreeCommRing α) =
       @Functor.map FreeAbelianGroup _ _ _ fun l : List α => (l : Multiset α) :=
@@ -497,12 +386,6 @@ theorem coe_eq :
           rw [(FreeMonoid.lift _).map_mul, FreeMonoid.lift_eval_of, ih]; rfl
 #align free_ring.coe_eq FreeRing.coe_eq
 
-/- warning: free_ring.subsingleton_equiv_free_comm_ring -> FreeRing.subsingletonEquivFreeCommRing is a dubious translation:
-lean 3 declaration is
-  forall (α : Type.{u1}) [_inst_1 : Subsingleton.{succ u1} α], RingEquiv.{u1, u1} (FreeRing.{u1} α) (FreeCommRing.{u1} α) (Distrib.toHasMul.{u1} (FreeRing.{u1} α) (Ring.toDistrib.{u1} (FreeRing.{u1} α) (FreeRing.ring.{u1} α))) (Distrib.toHasAdd.{u1} (FreeRing.{u1} α) (Ring.toDistrib.{u1} (FreeRing.{u1} α) (FreeRing.ring.{u1} α))) (Distrib.toHasMul.{u1} (FreeCommRing.{u1} α) (Ring.toDistrib.{u1} (FreeCommRing.{u1} α) (CommRing.toRing.{u1} (FreeCommRing.{u1} α) (FreeCommRing.instCommRing.{u1} α)))) (Distrib.toHasAdd.{u1} (FreeCommRing.{u1} α) (Ring.toDistrib.{u1} (FreeCommRing.{u1} α) (CommRing.toRing.{u1} (FreeCommRing.{u1} α) (FreeCommRing.instCommRing.{u1} α))))
-but is expected to have type
-  forall (α : Type.{u1}) [_inst_1 : Subsingleton.{succ u1} α], RingEquiv.{u1, u1} (FreeRing.{u1} α) (FreeCommRing.{u1} α) (NonUnitalNonAssocRing.toMul.{u1} (FreeRing.{u1} α) (NonAssocRing.toNonUnitalNonAssocRing.{u1} (FreeRing.{u1} α) (Ring.toNonAssocRing.{u1} (FreeRing.{u1} α) (instRingFreeRing.{u1} α)))) (NonUnitalNonAssocRing.toMul.{u1} (FreeCommRing.{u1} α) (NonAssocRing.toNonUnitalNonAssocRing.{u1} (FreeCommRing.{u1} α) (Ring.toNonAssocRing.{u1} (FreeCommRing.{u1} α) (CommRing.toRing.{u1} (FreeCommRing.{u1} α) (FreeCommRing.instCommRing.{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} α)))))) (Distrib.toAdd.{u1} (FreeCommRing.{u1} α) (NonUnitalNonAssocSemiring.toDistrib.{u1} (FreeCommRing.{u1} α) (NonUnitalNonAssocRing.toNonUnitalNonAssocSemiring.{u1} (FreeCommRing.{u1} α) (NonAssocRing.toNonUnitalNonAssocRing.{u1} (FreeCommRing.{u1} α) (Ring.toNonAssocRing.{u1} (FreeCommRing.{u1} α) (CommRing.toRing.{u1} (FreeCommRing.{u1} α) (FreeCommRing.instCommRing.{u1} α)))))))
-Case conversion may be inaccurate. Consider using '#align free_ring.subsingleton_equiv_free_comm_ring FreeRing.subsingletonEquivFreeCommRingₓ'. -/
 /-- If α has size at most 1 then the natural map from the free ring on `α` to the
     free commutative ring on `α` is an isomorphism of rings. -/
 def subsingletonEquivFreeCommRing [Subsingleton α] : FreeRing α ≃+* FreeCommRing α :=
@@ -526,12 +409,6 @@ instance [Subsingleton α] : CommRing (FreeRing α) :=
 
 end FreeRing
 
-/- warning: free_comm_ring_equiv_mv_polynomial_int -> freeCommRingEquivMvPolynomialInt is a dubious translation:
-lean 3 declaration is
-  forall (α : Type.{u1}), RingEquiv.{u1, u1} (FreeCommRing.{u1} α) (MvPolynomial.{u1, 0} α Int Int.commSemiring) (Distrib.toHasMul.{u1} (FreeCommRing.{u1} α) (Ring.toDistrib.{u1} (FreeCommRing.{u1} α) (CommRing.toRing.{u1} (FreeCommRing.{u1} α) (FreeCommRing.instCommRing.{u1} α)))) (Distrib.toHasAdd.{u1} (FreeCommRing.{u1} α) (Ring.toDistrib.{u1} (FreeCommRing.{u1} α) (CommRing.toRing.{u1} (FreeCommRing.{u1} α) (FreeCommRing.instCommRing.{u1} α)))) (Distrib.toHasMul.{u1} (MvPolynomial.{u1, 0} α Int Int.commSemiring) (Ring.toDistrib.{u1} (MvPolynomial.{u1, 0} α Int Int.commSemiring) (CommRing.toRing.{u1} (MvPolynomial.{u1, 0} α Int Int.commSemiring) (MvPolynomial.commRing.{0, u1} Int α Int.commRing)))) (Distrib.toHasAdd.{u1} (MvPolynomial.{u1, 0} α Int Int.commSemiring) (Ring.toDistrib.{u1} (MvPolynomial.{u1, 0} α Int Int.commSemiring) (CommRing.toRing.{u1} (MvPolynomial.{u1, 0} α Int Int.commSemiring) (MvPolynomial.commRing.{0, u1} Int α Int.commRing))))
-but is expected to have type
-  forall (α : Type.{u1}), RingEquiv.{u1, u1} (FreeCommRing.{u1} α) (MvPolynomial.{u1, 0} α Int Int.instCommSemiringInt) (NonUnitalNonAssocRing.toMul.{u1} (FreeCommRing.{u1} α) (NonAssocRing.toNonUnitalNonAssocRing.{u1} (FreeCommRing.{u1} α) (Ring.toNonAssocRing.{u1} (FreeCommRing.{u1} α) (CommRing.toRing.{u1} (FreeCommRing.{u1} α) (FreeCommRing.instCommRing.{u1} α))))) (NonUnitalNonAssocRing.toMul.{u1} (MvPolynomial.{u1, 0} α Int Int.instCommSemiringInt) (NonAssocRing.toNonUnitalNonAssocRing.{u1} (MvPolynomial.{u1, 0} α Int Int.instCommSemiringInt) (Ring.toNonAssocRing.{u1} (MvPolynomial.{u1, 0} α Int Int.instCommSemiringInt) (CommRing.toRing.{u1} (MvPolynomial.{u1, 0} α Int Int.instCommSemiringInt) (MvPolynomial.instCommRingMvPolynomialToCommSemiring.{0, u1} Int α Int.instCommRingInt))))) (Distrib.toAdd.{u1} (FreeCommRing.{u1} α) (NonUnitalNonAssocSemiring.toDistrib.{u1} (FreeCommRing.{u1} α) (NonUnitalNonAssocRing.toNonUnitalNonAssocSemiring.{u1} (FreeCommRing.{u1} α) (NonAssocRing.toNonUnitalNonAssocRing.{u1} (FreeCommRing.{u1} α) (Ring.toNonAssocRing.{u1} (FreeCommRing.{u1} α) (CommRing.toRing.{u1} (FreeCommRing.{u1} α) (FreeCommRing.instCommRing.{u1} α))))))) (Distrib.toAdd.{u1} (MvPolynomial.{u1, 0} α Int Int.instCommSemiringInt) (NonUnitalNonAssocSemiring.toDistrib.{u1} (MvPolynomial.{u1, 0} α Int Int.instCommSemiringInt) (NonUnitalNonAssocRing.toNonUnitalNonAssocSemiring.{u1} (MvPolynomial.{u1, 0} α Int Int.instCommSemiringInt) (NonAssocRing.toNonUnitalNonAssocRing.{u1} (MvPolynomial.{u1, 0} α Int Int.instCommSemiringInt) (Ring.toNonAssocRing.{u1} (MvPolynomial.{u1, 0} α Int Int.instCommSemiringInt) (CommRing.toRing.{u1} (MvPolynomial.{u1, 0} α Int Int.instCommSemiringInt) (MvPolynomial.instCommRingMvPolynomialToCommSemiring.{0, u1} Int α Int.instCommRingInt)))))))
-Case conversion may be inaccurate. Consider using '#align free_comm_ring_equiv_mv_polynomial_int freeCommRingEquivMvPolynomialIntₓ'. -/
 /-- The free commutative ring on `α` is isomorphic to the polynomial ring over ℤ with
     variables in `α` -/
 def freeCommRingEquivMvPolynomialInt : FreeCommRing α ≃+* MvPolynomial α ℤ :=
@@ -540,23 +417,11 @@ def freeCommRingEquivMvPolynomialInt : FreeCommRing α ≃+* MvPolynomial α ℤ
     (by ext <;> simp)
 #align free_comm_ring_equiv_mv_polynomial_int freeCommRingEquivMvPolynomialInt
 
-/- warning: free_comm_ring_pempty_equiv_int -> freeCommRingPemptyEquivInt is a dubious translation:
-lean 3 declaration is
-  RingEquiv.{u1, 0} (FreeCommRing.{u1} PEmpty.{succ u1}) Int (Distrib.toHasMul.{u1} (FreeCommRing.{u1} PEmpty.{succ u1}) (Ring.toDistrib.{u1} (FreeCommRing.{u1} PEmpty.{succ u1}) (CommRing.toRing.{u1} (FreeCommRing.{u1} PEmpty.{succ u1}) (FreeCommRing.instCommRing.{u1} PEmpty.{succ u1})))) (Distrib.toHasAdd.{u1} (FreeCommRing.{u1} PEmpty.{succ u1}) (Ring.toDistrib.{u1} (FreeCommRing.{u1} PEmpty.{succ u1}) (CommRing.toRing.{u1} (FreeCommRing.{u1} PEmpty.{succ u1}) (FreeCommRing.instCommRing.{u1} PEmpty.{succ u1})))) Int.hasMul Int.hasAdd
-but is expected to have type
-  RingEquiv.{u1, 0} (FreeCommRing.{u1} PEmpty.{succ u1}) Int (NonUnitalNonAssocRing.toMul.{u1} (FreeCommRing.{u1} PEmpty.{succ u1}) (NonAssocRing.toNonUnitalNonAssocRing.{u1} (FreeCommRing.{u1} PEmpty.{succ u1}) (Ring.toNonAssocRing.{u1} (FreeCommRing.{u1} PEmpty.{succ u1}) (CommRing.toRing.{u1} (FreeCommRing.{u1} PEmpty.{succ u1}) (FreeCommRing.instCommRing.{u1} PEmpty.{succ u1}))))) Int.instMulInt (Distrib.toAdd.{u1} (FreeCommRing.{u1} PEmpty.{succ u1}) (NonUnitalNonAssocSemiring.toDistrib.{u1} (FreeCommRing.{u1} PEmpty.{succ u1}) (NonUnitalNonAssocRing.toNonUnitalNonAssocSemiring.{u1} (FreeCommRing.{u1} PEmpty.{succ u1}) (NonAssocRing.toNonUnitalNonAssocRing.{u1} (FreeCommRing.{u1} PEmpty.{succ u1}) (Ring.toNonAssocRing.{u1} (FreeCommRing.{u1} PEmpty.{succ u1}) (CommRing.toRing.{u1} (FreeCommRing.{u1} PEmpty.{succ u1}) (FreeCommRing.instCommRing.{u1} PEmpty.{succ u1}))))))) Int.instAddInt
-Case conversion may be inaccurate. Consider using '#align free_comm_ring_pempty_equiv_int freeCommRingPemptyEquivIntₓ'. -/
 /-- The free commutative ring on the empty type is isomorphic to `ℤ`. -/
 def freeCommRingPemptyEquivInt : FreeCommRing PEmpty.{u + 1} ≃+* ℤ :=
   RingEquiv.trans (freeCommRingEquivMvPolynomialInt _) (MvPolynomial.isEmptyRingEquiv _ PEmpty)
 #align free_comm_ring_pempty_equiv_int freeCommRingPemptyEquivInt
 
-/- warning: free_comm_ring_punit_equiv_polynomial_int -> freeCommRingPunitEquivPolynomialInt is a dubious translation:
-lean 3 declaration is
-  RingEquiv.{u1, 0} (FreeCommRing.{u1} PUnit.{succ u1}) (Polynomial.{0} Int Int.semiring) (Distrib.toHasMul.{u1} (FreeCommRing.{u1} PUnit.{succ u1}) (Ring.toDistrib.{u1} (FreeCommRing.{u1} PUnit.{succ u1}) (CommRing.toRing.{u1} (FreeCommRing.{u1} PUnit.{succ u1}) (FreeCommRing.instCommRing.{u1} PUnit.{succ u1})))) (Distrib.toHasAdd.{u1} (FreeCommRing.{u1} PUnit.{succ u1}) (Ring.toDistrib.{u1} (FreeCommRing.{u1} PUnit.{succ u1}) (CommRing.toRing.{u1} (FreeCommRing.{u1} PUnit.{succ u1}) (FreeCommRing.instCommRing.{u1} PUnit.{succ u1})))) (Polynomial.mul'.{0} Int Int.semiring) (Polynomial.add'.{0} Int Int.semiring)
-but is expected to have type
-  RingEquiv.{u1, 0} (FreeCommRing.{u1} PUnit.{succ u1}) (Polynomial.{0} Int Int.instSemiringInt) (NonUnitalNonAssocRing.toMul.{u1} (FreeCommRing.{u1} PUnit.{succ u1}) (NonAssocRing.toNonUnitalNonAssocRing.{u1} (FreeCommRing.{u1} PUnit.{succ u1}) (Ring.toNonAssocRing.{u1} (FreeCommRing.{u1} PUnit.{succ u1}) (CommRing.toRing.{u1} (FreeCommRing.{u1} PUnit.{succ u1}) (FreeCommRing.instCommRing.{u1} PUnit.{succ u1}))))) (Polynomial.mul'.{0} Int Int.instSemiringInt) (Distrib.toAdd.{u1} (FreeCommRing.{u1} PUnit.{succ u1}) (NonUnitalNonAssocSemiring.toDistrib.{u1} (FreeCommRing.{u1} PUnit.{succ u1}) (NonUnitalNonAssocRing.toNonUnitalNonAssocSemiring.{u1} (FreeCommRing.{u1} PUnit.{succ u1}) (NonAssocRing.toNonUnitalNonAssocRing.{u1} (FreeCommRing.{u1} PUnit.{succ u1}) (Ring.toNonAssocRing.{u1} (FreeCommRing.{u1} PUnit.{succ u1}) (CommRing.toRing.{u1} (FreeCommRing.{u1} PUnit.{succ u1}) (FreeCommRing.instCommRing.{u1} PUnit.{succ u1}))))))) (Polynomial.add'.{0} Int Int.instSemiringInt)
-Case conversion may be inaccurate. Consider using '#align free_comm_ring_punit_equiv_polynomial_int freeCommRingPunitEquivPolynomialIntₓ'. -/
 /-- The free commutative ring on a type with one term is isomorphic to `ℤ[X]`. -/
 def freeCommRingPunitEquivPolynomialInt : FreeCommRing PUnit.{u + 1} ≃+* ℤ[X] :=
   (freeCommRingEquivMvPolynomialInt _).trans (MvPolynomial.pUnitAlgEquiv ℤ).toRingEquiv
@@ -564,23 +429,11 @@ def freeCommRingPunitEquivPolynomialInt : FreeCommRing PUnit.{u + 1} ≃+* ℤ[X
 
 open FreeRing
 
-/- warning: free_ring_pempty_equiv_int -> freeRingPemptyEquivInt is a dubious translation:
-lean 3 declaration is
-  RingEquiv.{u1, 0} (FreeRing.{u1} PEmpty.{succ u1}) Int (Distrib.toHasMul.{u1} (FreeRing.{u1} PEmpty.{succ u1}) (Ring.toDistrib.{u1} (FreeRing.{u1} PEmpty.{succ u1}) (FreeRing.ring.{u1} PEmpty.{succ u1}))) (Distrib.toHasAdd.{u1} (FreeRing.{u1} PEmpty.{succ u1}) (Ring.toDistrib.{u1} (FreeRing.{u1} PEmpty.{succ u1}) (FreeRing.ring.{u1} PEmpty.{succ u1}))) Int.hasMul Int.hasAdd
-but is expected to have type
-  RingEquiv.{u1, 0} (FreeRing.{u1} PEmpty.{succ u1}) Int (NonUnitalNonAssocRing.toMul.{u1} (FreeRing.{u1} PEmpty.{succ u1}) (NonAssocRing.toNonUnitalNonAssocRing.{u1} (FreeRing.{u1} PEmpty.{succ u1}) (Ring.toNonAssocRing.{u1} (FreeRing.{u1} PEmpty.{succ u1}) (instRingFreeRing.{u1} PEmpty.{succ u1})))) Int.instMulInt (Distrib.toAdd.{u1} (FreeRing.{u1} PEmpty.{succ u1}) (NonUnitalNonAssocSemiring.toDistrib.{u1} (FreeRing.{u1} PEmpty.{succ u1}) (NonUnitalNonAssocRing.toNonUnitalNonAssocSemiring.{u1} (FreeRing.{u1} PEmpty.{succ u1}) (NonAssocRing.toNonUnitalNonAssocRing.{u1} (FreeRing.{u1} PEmpty.{succ u1}) (Ring.toNonAssocRing.{u1} (FreeRing.{u1} PEmpty.{succ u1}) (instRingFreeRing.{u1} PEmpty.{succ u1})))))) Int.instAddInt
-Case conversion may be inaccurate. Consider using '#align free_ring_pempty_equiv_int freeRingPemptyEquivIntₓ'. -/
 /-- The free ring on the empty type is isomorphic to `ℤ`. -/
 def freeRingPemptyEquivInt : FreeRing PEmpty.{u + 1} ≃+* ℤ :=
   RingEquiv.trans (subsingletonEquivFreeCommRing _) freeCommRingPemptyEquivInt
 #align free_ring_pempty_equiv_int freeRingPemptyEquivInt
 
-/- warning: free_ring_punit_equiv_polynomial_int -> freeRingPunitEquivPolynomialInt is a dubious translation:
-lean 3 declaration is
-  RingEquiv.{u1, 0} (FreeRing.{u1} PUnit.{succ u1}) (Polynomial.{0} Int Int.semiring) (Distrib.toHasMul.{u1} (FreeRing.{u1} PUnit.{succ u1}) (Ring.toDistrib.{u1} (FreeRing.{u1} PUnit.{succ u1}) (FreeRing.ring.{u1} PUnit.{succ u1}))) (Distrib.toHasAdd.{u1} (FreeRing.{u1} PUnit.{succ u1}) (Ring.toDistrib.{u1} (FreeRing.{u1} PUnit.{succ u1}) (FreeRing.ring.{u1} PUnit.{succ u1}))) (Polynomial.mul'.{0} Int Int.semiring) (Polynomial.add'.{0} Int Int.semiring)
-but is expected to have type
-  RingEquiv.{u1, 0} (FreeRing.{u1} PUnit.{succ u1}) (Polynomial.{0} Int Int.instSemiringInt) (NonUnitalNonAssocRing.toMul.{u1} (FreeRing.{u1} PUnit.{succ u1}) (NonAssocRing.toNonUnitalNonAssocRing.{u1} (FreeRing.{u1} PUnit.{succ u1}) (Ring.toNonAssocRing.{u1} (FreeRing.{u1} PUnit.{succ u1}) (instRingFreeRing.{u1} PUnit.{succ u1})))) (Polynomial.mul'.{0} Int Int.instSemiringInt) (Distrib.toAdd.{u1} (FreeRing.{u1} PUnit.{succ u1}) (NonUnitalNonAssocSemiring.toDistrib.{u1} (FreeRing.{u1} PUnit.{succ u1}) (NonUnitalNonAssocRing.toNonUnitalNonAssocSemiring.{u1} (FreeRing.{u1} PUnit.{succ u1}) (NonAssocRing.toNonUnitalNonAssocRing.{u1} (FreeRing.{u1} PUnit.{succ u1}) (Ring.toNonAssocRing.{u1} (FreeRing.{u1} PUnit.{succ u1}) (instRingFreeRing.{u1} PUnit.{succ u1})))))) (Polynomial.add'.{0} Int Int.instSemiringInt)
-Case conversion may be inaccurate. Consider using '#align free_ring_punit_equiv_polynomial_int freeRingPunitEquivPolynomialIntₓ'. -/
 /-- The free ring on a type with one term is isomorphic to `ℤ[X]`. -/
 def freeRingPunitEquivPolynomialInt : FreeRing PUnit.{u + 1} ≃+* ℤ[X] :=
   RingEquiv.trans (subsingletonEquivFreeCommRing _) freeCommRingPunitEquivPolynomialInt

50251fd6

bump to nightly-2023-05-28-04

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

6797a637

Diff

@@ -117,9 +117,7 @@ private def lift_to_multiset : (α → R) ≃ (Multiplicative (Multiset α) →*
     { toFun := fun s => (s.toAdd.map f).Prod
       map_mul' := fun x y =>
         calc
-          _ = Multiset.prod (Multiset.map f x + Multiset.map f y) :=
-            by
-            congr 1
+          _ = Multiset.prod (Multiset.map f x + Multiset.map f y) := by congr 1;
             exact Multiset.map_add _ _ _
           _ = _ := Multiset.prod_add _ _
           
@@ -318,29 +316,16 @@ theorem isSupported_of {p} {s : Set α} : IsSupported (of p) s ↔ p ∈ s :=
       is_supported x s →
         ∃ n : ℤ, lift (fun a => if a ∈ s then (0 : ℤ[X]) else Polynomial.X) x = n :=
     by
-    intro x hx
-    refine' Subring.InClosure.recOn hx _ _ _ _
-    · use 1
-      rw [RingHom.map_one]
-      norm_cast
-    · use -1
-      rw [RingHom.map_neg, RingHom.map_one, Int.cast_neg, Int.cast_one]
-    · rintro _ ⟨z, hzs, rfl⟩ _ _
-      use 0
+    intro x hx; refine' Subring.InClosure.recOn hx _ _ _ _
+    · use 1; rw [RingHom.map_one]; norm_cast
+    · use -1; rw [RingHom.map_neg, RingHom.map_one, Int.cast_neg, Int.cast_one]
+    · rintro _ ⟨z, hzs, rfl⟩ _ _; use 0;
       rw [RingHom.map_mul, lift_of, if_pos hzs, MulZeroClass.zero_mul]
       norm_cast
-    · rintro x y ⟨q, hq⟩ ⟨r, hr⟩
-      refine' ⟨q + r, _⟩
-      rw [RingHom.map_add, hq, hr]
-      norm_cast
-  specialize this (of p) hps
-  rw [lift_of] at this
-  split_ifs  at this
-  · exact h
-  exfalso
-  apply Ne.symm Int.zero_ne_one
-  rcases this with ⟨w, H⟩
-  rw [← Polynomial.C_eq_int_cast] at H
+    · rintro x y ⟨q, hq⟩ ⟨r, hr⟩; refine' ⟨q + r, _⟩; rw [RingHom.map_add, hq, hr]; norm_cast
+  specialize this (of p) hps; rw [lift_of] at this; split_ifs  at this; · exact h
+  exfalso; apply Ne.symm Int.zero_ne_one
+  rcases this with ⟨w, H⟩; rw [← Polynomial.C_eq_int_cast] at H
   have : polynomial.X.coeff 1 = (Polynomial.C ↑w).coeff 1 := by rw [H]
   rwa [Polynomial.coeff_C, if_neg (one_ne_zero : 1 ≠ 0), Polynomial.coeff_X, if_pos rfl] at this
 #align free_comm_ring.is_supported_of FreeCommRing.isSupported_of
@@ -353,14 +338,11 @@ theorem map_subtype_val_restriction {x} (s : Set α) [DecidablePred (· ∈ s)]
     (hxs : IsSupported x s) : map (Subtype.val : s → α) (restriction s x) = x :=
   by
   refine' Subring.InClosure.recOn hxs _ _ _ _
-  · rw [RingHom.map_one]
-    rfl
-  · rw [RingHom.map_neg, RingHom.map_neg, RingHom.map_one]
-    rfl
+  · rw [RingHom.map_one]; rfl
+  · rw [RingHom.map_neg, RingHom.map_neg, RingHom.map_one]; rfl
   · rintro _ ⟨p, hps, rfl⟩ n ih
     rw [RingHom.map_mul, restriction_of, dif_pos hps, RingHom.map_mul, map_of, ih]
-  · intro x y ihx ihy
-    rw [RingHom.map_add, RingHom.map_add, ihx, ihy]
+  · intro x y ihx ihy; rw [RingHom.map_add, RingHom.map_add, ihx, ihy]
 #align free_comm_ring.map_subtype_val_restriction FreeCommRing.map_subtype_val_restriction
 
 #print FreeCommRing.exists_finite_support /-
@@ -492,17 +474,10 @@ variable (α)
 protected theorem coe_surjective : Surjective (coe : FreeRing α → FreeCommRing α) := fun x =>
   by
   apply FreeCommRing.induction_on x
-  · use -1
-    rfl
-  · intro x
-    use FreeRing.of x
-    rfl
-  · rintro _ _ ⟨x, rfl⟩ ⟨y, rfl⟩
-    use x + y
-    exact (FreeRing.lift _).map_add _ _
-  · rintro _ _ ⟨x, rfl⟩ ⟨y, rfl⟩
-    use x * y
-    exact (FreeRing.lift _).map_mul _ _
+  · use -1; rfl
+  · intro x; use FreeRing.of x; rfl
+  · rintro _ _ ⟨x, rfl⟩ ⟨y, rfl⟩; use x + y; exact (FreeRing.lift _).map_add _ _
+  · rintro _ _ ⟨x, rfl⟩ ⟨y, rfl⟩; use x * y; exact (FreeRing.lift _).map_mul _ _
 #align free_ring.coe_surjective FreeRing.coe_surjective
 -/
 
@@ -516,14 +491,10 @@ theorem coe_eq :
     (coe : FreeRing α → FreeCommRing α) =
       @Functor.map FreeAbelianGroup _ _ _ fun l : List α => (l : Multiset α) :=
   funext fun x =>
-    FreeAbelianGroup.lift.unique _ _ fun L =>
-      by
-      simp_rw [FreeAbelianGroup.lift.of, (· ∘ ·)]
+    FreeAbelianGroup.lift.unique _ _ fun L => by simp_rw [FreeAbelianGroup.lift.of, (· ∘ ·)];
       exact
-        FreeMonoid.recOn L rfl fun hd tl ih =>
-          by
-          rw [(FreeMonoid.lift _).map_mul, FreeMonoid.lift_eval_of, ih]
-          rfl
+        FreeMonoid.recOn L rfl fun hd tl ih => by
+          rw [(FreeMonoid.lift _).map_mul, FreeMonoid.lift_eval_of, ih]; rfl
 #align free_ring.coe_eq FreeRing.coe_eq
 
 /- warning: free_ring.subsingleton_equiv_free_comm_ring -> FreeRing.subsingletonEquivFreeCommRing is a dubious translation:
@@ -565,10 +536,7 @@ Case conversion may be inaccurate. Consider using '#align free_comm_ring_equiv_m
     variables in `α` -/
 def freeCommRingEquivMvPolynomialInt : FreeCommRing α ≃+* MvPolynomial α ℤ :=
   RingEquiv.ofHomInv (FreeCommRing.lift <| (fun a => MvPolynomial.X a : α → MvPolynomial α ℤ))
-    (MvPolynomial.eval₂Hom (Int.castRingHom (FreeCommRing α)) FreeCommRing.of)
-    (by
-      ext
-      simp)
+    (MvPolynomial.eval₂Hom (Int.castRingHom (FreeCommRing α)) FreeCommRing.of) (by ext; simp)
     (by ext <;> simp)
 #align free_comm_ring_equiv_mv_polynomial_int freeCommRingEquivMvPolynomialInt

50251fd6

bump to nightly-2023-05-28-03

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

6c6011cf

Diff

@@ -134,7 +134,6 @@ private def lift_to_multiset : (α → R) ≃ (Multiplicative (Multiset α) →*
         by
         rw [← Multiset.map_map, ← AddMonoidHom.map_multiset_sum]
         exact F.congr_arg (Multiset.sum_map_singleton x')
-#align free_comm_ring.lift_to_multiset free_comm_ring.lift_to_multiset
 
 #print FreeCommRing.lift /-
 /-- Lift a map `α → R` to a additive group homomorphism `free_comm_ring α → R`.
@@ -166,10 +165,7 @@ theorem lift_comp_of (f : FreeCommRing α →+* R) : lift (f ∘ of) = f :=
 -/
 
 /- warning: free_comm_ring.hom_ext -> FreeCommRing.hom_ext is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {R : Type.{u2}} [_inst_1 : CommRing.{u2} R] {{f : RingHom.{u1, u2} (FreeCommRing.{u1} α) R (NonAssocRing.toNonAssocSemiring.{u1} (FreeCommRing.{u1} α) (Ring.toNonAssocRing.{u1} (FreeCommRing.{u1} α) (CommRing.toRing.{u1} (FreeCommRing.{u1} α) (FreeCommRing.instCommRing.{u1} α)))) (NonAssocRing.toNonAssocSemiring.{u2} R (Ring.toNonAssocRing.{u2} R (CommRing.toRing.{u2} R _inst_1)))}} {{g : RingHom.{u1, u2} (FreeCommRing.{u1} α) R (NonAssocRing.toNonAssocSemiring.{u1} (FreeCommRing.{u1} α) (Ring.toNonAssocRing.{u1} (FreeCommRing.{u1} α) (CommRing.toRing.{u1} (FreeCommRing.{u1} α) (FreeCommRing.instCommRing.{u1} α)))) (NonAssocRing.toNonAssocSemiring.{u2} R (Ring.toNonAssocRing.{u2} R (CommRing.toRing.{u2} R _inst_1)))}}, (forall (x : α), Eq.{succ u2} R (coeFn.{max (succ u1) (succ u2), max (succ u1) (succ u2)} (RingHom.{u1, u2} (FreeCommRing.{u1} α) R (NonAssocRing.toNonAssocSemiring.{u1} (FreeCommRing.{u1} α) (Ring.toNonAssocRing.{u1} (FreeCommRing.{u1} α) (CommRing.toRing.{u1} (FreeCommRing.{u1} α) (FreeCommRing.instCommRing.{u1} α)))) (NonAssocRing.toNonAssocSemiring.{u2} R (Ring.toNonAssocRing.{u2} R (CommRing.toRing.{u2} R _inst_1)))) (fun (_x : RingHom.{u1, u2} (FreeCommRing.{u1} α) R (NonAssocRing.toNonAssocSemiring.{u1} (FreeCommRing.{u1} α) (Ring.toNonAssocRing.{u1} (FreeCommRing.{u1} α) (CommRing.toRing.{u1} (FreeCommRing.{u1} α) (FreeCommRing.instCommRing.{u1} α)))) (NonAssocRing.toNonAssocSemiring.{u2} R (Ring.toNonAssocRing.{u2} R (CommRing.toRing.{u2} R _inst_1)))) => (FreeCommRing.{u1} α) -> R) (RingHom.hasCoeToFun.{u1, u2} (FreeCommRing.{u1} α) R (NonAssocRing.toNonAssocSemiring.{u1} (FreeCommRing.{u1} α) (Ring.toNonAssocRing.{u1} (FreeCommRing.{u1} α) (CommRing.toRing.{u1} (FreeCommRing.{u1} α) (FreeCommRing.instCommRing.{u1} α)))) (NonAssocRing.toNonAssocSemiring.{u2} R (Ring.toNonAssocRing.{u2} R (CommRing.toRing.{u2} R _inst_1)))) f (FreeCommRing.of.{u1} α x)) (coeFn.{max (succ u1) (succ u2), max (succ u1) (succ u2)} (RingHom.{u1, u2} (FreeCommRing.{u1} α) R (NonAssocRing.toNonAssocSemiring.{u1} (FreeCommRing.{u1} α) (Ring.toNonAssocRing.{u1} (FreeCommRing.{u1} α) (CommRing.toRing.{u1} (FreeCommRing.{u1} α) (FreeCommRing.instCommRing.{u1} α)))) (NonAssocRing.toNonAssocSemiring.{u2} R (Ring.toNonAssocRing.{u2} R (CommRing.toRing.{u2} R _inst_1)))) (fun (_x : RingHom.{u1, u2} (FreeCommRing.{u1} α) R (NonAssocRing.toNonAssocSemiring.{u1} (FreeCommRing.{u1} α) (Ring.toNonAssocRing.{u1} (FreeCommRing.{u1} α) (CommRing.toRing.{u1} (FreeCommRing.{u1} α) (FreeCommRing.instCommRing.{u1} α)))) (NonAssocRing.toNonAssocSemiring.{u2} R (Ring.toNonAssocRing.{u2} R (CommRing.toRing.{u2} R _inst_1)))) => (FreeCommRing.{u1} α) -> R) (RingHom.hasCoeToFun.{u1, u2} (FreeCommRing.{u1} α) R (NonAssocRing.toNonAssocSemiring.{u1} (FreeCommRing.{u1} α) (Ring.toNonAssocRing.{u1} (FreeCommRing.{u1} α) (CommRing.toRing.{u1} (FreeCommRing.{u1} α) (FreeCommRing.instCommRing.{u1} α)))) (NonAssocRing.toNonAssocSemiring.{u2} R (Ring.toNonAssocRing.{u2} R (CommRing.toRing.{u2} R _inst_1)))) g (FreeCommRing.of.{u1} α x))) -> (Eq.{max (succ u1) (succ u2)} (RingHom.{u1, u2} (FreeCommRing.{u1} α) R (NonAssocRing.toNonAssocSemiring.{u1} (FreeCommRing.{u1} α) (Ring.toNonAssocRing.{u1} (FreeCommRing.{u1} α) (CommRing.toRing.{u1} (FreeCommRing.{u1} α) (FreeCommRing.instCommRing.{u1} α)))) (NonAssocRing.toNonAssocSemiring.{u2} R (Ring.toNonAssocRing.{u2} R (CommRing.toRing.{u2} R _inst_1)))) f g)
-but is expected to have type
-  forall {α : Type.{u1}} {R : Type.{u2}} [_inst_1 : CommRing.{u2} R] {{f : RingHom.{u1, u2} (FreeCommRing.{u1} α) R (Semiring.toNonAssocSemiring.{u1} (FreeCommRing.{u1} α) (CommSemiring.toSemiring.{u1} (FreeCommRing.{u1} α) (CommRing.toCommSemiring.{u1} (FreeCommRing.{u1} α) (FreeCommRing.instCommRing.{u1} α)))) (Semiring.toNonAssocSemiring.{u2} R (CommSemiring.toSemiring.{u2} R (CommRing.toCommSemiring.{u2} R _inst_1)))}} {{g : RingHom.{u1, u2} (FreeCommRing.{u1} α) R (Semiring.toNonAssocSemiring.{u1} (FreeCommRing.{u1} α) (CommSemiring.toSemiring.{u1} (FreeCommRing.{u1} α) (CommRing.toCommSemiring.{u1} (FreeCommRing.{u1} α) (FreeCommRing.instCommRing.{u1} α)))) (Semiring.toNonAssocSemiring.{u2} R (CommSemiring.toSemiring.{u2} R (CommRing.toCommSemiring.{u2} R _inst_1)))}}, (forall (x : α), Eq.{succ u2} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2397 : FreeCommRing.{u1} α) => R) (FreeCommRing.of.{u1} α x)) (FunLike.coe.{max (succ u1) (succ u2), succ u1, succ u2} (RingHom.{u1, u2} (FreeCommRing.{u1} α) R (Semiring.toNonAssocSemiring.{u1} (FreeCommRing.{u1} α) (CommSemiring.toSemiring.{u1} (FreeCommRing.{u1} α) (CommRing.toCommSemiring.{u1} (FreeCommRing.{u1} α) (FreeCommRing.instCommRing.{u1} α)))) (Semiring.toNonAssocSemiring.{u2} R (CommSemiring.toSemiring.{u2} R (CommRing.toCommSemiring.{u2} R _inst_1)))) (FreeCommRing.{u1} α) (fun (_x : FreeCommRing.{u1} α) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2397 : FreeCommRing.{u1} α) => R) _x) (MulHomClass.toFunLike.{max u1 u2, u1, u2} (RingHom.{u1, u2} (FreeCommRing.{u1} α) R (Semiring.toNonAssocSemiring.{u1} (FreeCommRing.{u1} α) (CommSemiring.toSemiring.{u1} (FreeCommRing.{u1} α) (CommRing.toCommSemiring.{u1} (FreeCommRing.{u1} α) (FreeCommRing.instCommRing.{u1} α)))) (Semiring.toNonAssocSemiring.{u2} R (CommSemiring.toSemiring.{u2} R (CommRing.toCommSemiring.{u2} R _inst_1)))) (FreeCommRing.{u1} α) R (NonUnitalNonAssocSemiring.toMul.{u1} (FreeCommRing.{u1} α) (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u1} (FreeCommRing.{u1} α) (Semiring.toNonAssocSemiring.{u1} (FreeCommRing.{u1} α) (CommSemiring.toSemiring.{u1} (FreeCommRing.{u1} α) (CommRing.toCommSemiring.{u1} (FreeCommRing.{u1} α) (FreeCommRing.instCommRing.{u1} α)))))) (NonUnitalNonAssocSemiring.toMul.{u2} R (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u2} R (Semiring.toNonAssocSemiring.{u2} R (CommSemiring.toSemiring.{u2} R (CommRing.toCommSemiring.{u2} R _inst_1))))) (NonUnitalRingHomClass.toMulHomClass.{max u1 u2, u1, u2} (RingHom.{u1, u2} (FreeCommRing.{u1} α) R (Semiring.toNonAssocSemiring.{u1} (FreeCommRing.{u1} α) (CommSemiring.toSemiring.{u1} (FreeCommRing.{u1} α) (CommRing.toCommSemiring.{u1} (FreeCommRing.{u1} α) (FreeCommRing.instCommRing.{u1} α)))) (Semiring.toNonAssocSemiring.{u2} R (CommSemiring.toSemiring.{u2} R (CommRing.toCommSemiring.{u2} R _inst_1)))) (FreeCommRing.{u1} α) R (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u1} (FreeCommRing.{u1} α) (Semiring.toNonAssocSemiring.{u1} (FreeCommRing.{u1} α) (CommSemiring.toSemiring.{u1} (FreeCommRing.{u1} α) (CommRing.toCommSemiring.{u1} (FreeCommRing.{u1} α) (FreeCommRing.instCommRing.{u1} α))))) (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u2} R (Semiring.toNonAssocSemiring.{u2} R (CommSemiring.toSemiring.{u2} R (CommRing.toCommSemiring.{u2} R _inst_1)))) (RingHomClass.toNonUnitalRingHomClass.{max u1 u2, u1, u2} (RingHom.{u1, u2} (FreeCommRing.{u1} α) R (Semiring.toNonAssocSemiring.{u1} (FreeCommRing.{u1} α) (CommSemiring.toSemiring.{u1} (FreeCommRing.{u1} α) (CommRing.toCommSemiring.{u1} (FreeCommRing.{u1} α) (FreeCommRing.instCommRing.{u1} α)))) (Semiring.toNonAssocSemiring.{u2} R (CommSemiring.toSemiring.{u2} R (CommRing.toCommSemiring.{u2} R _inst_1)))) (FreeCommRing.{u1} α) R (Semiring.toNonAssocSemiring.{u1} (FreeCommRing.{u1} α) (CommSemiring.toSemiring.{u1} (FreeCommRing.{u1} α) (CommRing.toCommSemiring.{u1} (FreeCommRing.{u1} α) (FreeCommRing.instCommRing.{u1} α)))) (Semiring.toNonAssocSemiring.{u2} R (CommSemiring.toSemiring.{u2} R (CommRing.toCommSemiring.{u2} R _inst_1))) (RingHom.instRingHomClassRingHom.{u1, u2} (FreeCommRing.{u1} α) R (Semiring.toNonAssocSemiring.{u1} (FreeCommRing.{u1} α) (CommSemiring.toSemiring.{u1} (FreeCommRing.{u1} α) (CommRing.toCommSemiring.{u1} (FreeCommRing.{u1} α) (FreeCommRing.instCommRing.{u1} α)))) (Semiring.toNonAssocSemiring.{u2} R (CommSemiring.toSemiring.{u2} R (CommRing.toCommSemiring.{u2} R _inst_1))))))) f (FreeCommRing.of.{u1} α x)) (FunLike.coe.{max (succ u1) (succ u2), succ u1, succ u2} (RingHom.{u1, u2} (FreeCommRing.{u1} α) R (Semiring.toNonAssocSemiring.{u1} (FreeCommRing.{u1} α) (CommSemiring.toSemiring.{u1} (FreeCommRing.{u1} α) (CommRing.toCommSemiring.{u1} (FreeCommRing.{u1} α) (FreeCommRing.instCommRing.{u1} α)))) (Semiring.toNonAssocSemiring.{u2} R (CommSemiring.toSemiring.{u2} R (CommRing.toCommSemiring.{u2} R _inst_1)))) (FreeCommRing.{u1} α) (fun (_x : FreeCommRing.{u1} α) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2397 : FreeCommRing.{u1} α) => R) _x) (MulHomClass.toFunLike.{max u1 u2, u1, u2} (RingHom.{u1, u2} (FreeCommRing.{u1} α) R (Semiring.toNonAssocSemiring.{u1} (FreeCommRing.{u1} α) (CommSemiring.toSemiring.{u1} (FreeCommRing.{u1} α) (CommRing.toCommSemiring.{u1} (FreeCommRing.{u1} α) (FreeCommRing.instCommRing.{u1} α)))) (Semiring.toNonAssocSemiring.{u2} R (CommSemiring.toSemiring.{u2} R (CommRing.toCommSemiring.{u2} R _inst_1)))) (FreeCommRing.{u1} α) R (NonUnitalNonAssocSemiring.toMul.{u1} (FreeCommRing.{u1} α) (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u1} (FreeCommRing.{u1} α) (Semiring.toNonAssocSemiring.{u1} (FreeCommRing.{u1} α) (CommSemiring.toSemiring.{u1} (FreeCommRing.{u1} α) (CommRing.toCommSemiring.{u1} (FreeCommRing.{u1} α) (FreeCommRing.instCommRing.{u1} α)))))) (NonUnitalNonAssocSemiring.toMul.{u2} R (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u2} R (Semiring.toNonAssocSemiring.{u2} R (CommSemiring.toSemiring.{u2} R (CommRing.toCommSemiring.{u2} R _inst_1))))) (NonUnitalRingHomClass.toMulHomClass.{max u1 u2, u1, u2} (RingHom.{u1, u2} (FreeCommRing.{u1} α) R (Semiring.toNonAssocSemiring.{u1} (FreeCommRing.{u1} α) (CommSemiring.toSemiring.{u1} (FreeCommRing.{u1} α) (CommRing.toCommSemiring.{u1} (FreeCommRing.{u1} α) (FreeCommRing.instCommRing.{u1} α)))) (Semiring.toNonAssocSemiring.{u2} R (CommSemiring.toSemiring.{u2} R (CommRing.toCommSemiring.{u2} R _inst_1)))) (FreeCommRing.{u1} α) R (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u1} (FreeCommRing.{u1} α) (Semiring.toNonAssocSemiring.{u1} (FreeCommRing.{u1} α) (CommSemiring.toSemiring.{u1} (FreeCommRing.{u1} α) (CommRing.toCommSemiring.{u1} (FreeCommRing.{u1} α) (FreeCommRing.instCommRing.{u1} α))))) (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u2} R (Semiring.toNonAssocSemiring.{u2} R (CommSemiring.toSemiring.{u2} R (CommRing.toCommSemiring.{u2} R _inst_1)))) (RingHomClass.toNonUnitalRingHomClass.{max u1 u2, u1, u2} (RingHom.{u1, u2} (FreeCommRing.{u1} α) R (Semiring.toNonAssocSemiring.{u1} (FreeCommRing.{u1} α) (CommSemiring.toSemiring.{u1} (FreeCommRing.{u1} α) (CommRing.toCommSemiring.{u1} (FreeCommRing.{u1} α) (FreeCommRing.instCommRing.{u1} α)))) (Semiring.toNonAssocSemiring.{u2} R (CommSemiring.toSemiring.{u2} R (CommRing.toCommSemiring.{u2} R _inst_1)))) (FreeCommRing.{u1} α) R (Semiring.toNonAssocSemiring.{u1} (FreeCommRing.{u1} α) (CommSemiring.toSemiring.{u1} (FreeCommRing.{u1} α) (CommRing.toCommSemiring.{u1} (FreeCommRing.{u1} α) (FreeCommRing.instCommRing.{u1} α)))) (Semiring.toNonAssocSemiring.{u2} R (CommSemiring.toSemiring.{u2} R (CommRing.toCommSemiring.{u2} R _inst_1))) (RingHom.instRingHomClassRingHom.{u1, u2} (FreeCommRing.{u1} α) R (Semiring.toNonAssocSemiring.{u1} (FreeCommRing.{u1} α) (CommSemiring.toSemiring.{u1} (FreeCommRing.{u1} α) (CommRing.toCommSemiring.{u1} (FreeCommRing.{u1} α) (FreeCommRing.instCommRing.{u1} α)))) (Semiring.toNonAssocSemiring.{u2} R (CommSemiring.toSemiring.{u2} R (CommRing.toCommSemiring.{u2} R _inst_1))))))) g (FreeCommRing.of.{u1} α x))) -> (Eq.{max (succ u1) (succ u2)} (RingHom.{u1, u2} (FreeCommRing.{u1} α) R (Semiring.toNonAssocSemiring.{u1} (FreeCommRing.{u1} α) (CommSemiring.toSemiring.{u1} (FreeCommRing.{u1} α) (CommRing.toCommSemiring.{u1} (FreeCommRing.{u1} α) (FreeCommRing.instCommRing.{u1} α)))) (Semiring.toNonAssocSemiring.{u2} R (CommSemiring.toSemiring.{u2} R (CommRing.toCommSemiring.{u2} R _inst_1)))) f g)
+<too large>
 Case conversion may be inaccurate. Consider using '#align free_comm_ring.hom_ext FreeCommRing.hom_extₓ'. -/
 @[ext]
 theorem hom_ext ⦃f g : FreeCommRing α →+* R⦄ (h : ∀ x, f (of x) = g (of x)) : f = g :=
@@ -302,10 +298,7 @@ section Restriction
 variable (s : Set α) [DecidablePred (· ∈ s)] (x y : FreeCommRing α)
 
 /- warning: free_comm_ring.restriction_of -> FreeCommRing.restriction_of is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} (s : Set.{u1} α) [_inst_1 : DecidablePred.{succ u1} α (fun (_x : α) => Membership.Mem.{u1, u1} α (Set.{u1} α) (Set.hasMem.{u1} α) _x s)] (p : α), Eq.{succ u1} (FreeCommRing.{u1} (coeSort.{succ u1, succ (succ u1)} (Set.{u1} α) Type.{u1} (Set.hasCoeToSort.{u1} α) s)) (coeFn.{succ u1, succ u1} (RingHom.{u1, u1} (FreeCommRing.{u1} α) (FreeCommRing.{u1} (coeSort.{succ u1, succ (succ u1)} (Set.{u1} α) Type.{u1} (Set.hasCoeToSort.{u1} α) s)) (NonAssocRing.toNonAssocSemiring.{u1} (FreeCommRing.{u1} α) (Ring.toNonAssocRing.{u1} (FreeCommRing.{u1} α) (CommRing.toRing.{u1} (FreeCommRing.{u1} α) (FreeCommRing.instCommRing.{u1} α)))) (NonAssocRing.toNonAssocSemiring.{u1} (FreeCommRing.{u1} (coeSort.{succ u1, succ (succ u1)} (Set.{u1} α) Type.{u1} (Set.hasCoeToSort.{u1} α) s)) (Ring.toNonAssocRing.{u1} (FreeCommRing.{u1} (coeSort.{succ u1, succ (succ u1)} (Set.{u1} α) Type.{u1} (Set.hasCoeToSort.{u1} α) s)) (CommRing.toRing.{u1} (FreeCommRing.{u1} (coeSort.{succ u1, succ (succ u1)} (Set.{u1} α) Type.{u1} (Set.hasCoeToSort.{u1} α) s)) (FreeCommRing.instCommRing.{u1} (coeSort.{succ u1, succ (succ u1)} (Set.{u1} α) Type.{u1} (Set.hasCoeToSort.{u1} α) s)))))) (fun (_x : RingHom.{u1, u1} (FreeCommRing.{u1} α) (FreeCommRing.{u1} (coeSort.{succ u1, succ (succ u1)} (Set.{u1} α) Type.{u1} (Set.hasCoeToSort.{u1} α) s)) (NonAssocRing.toNonAssocSemiring.{u1} (FreeCommRing.{u1} α) (Ring.toNonAssocRing.{u1} (FreeCommRing.{u1} α) (CommRing.toRing.{u1} (FreeCommRing.{u1} α) (FreeCommRing.instCommRing.{u1} α)))) (NonAssocRing.toNonAssocSemiring.{u1} (FreeCommRing.{u1} (coeSort.{succ u1, succ (succ u1)} (Set.{u1} α) Type.{u1} (Set.hasCoeToSort.{u1} α) s)) (Ring.toNonAssocRing.{u1} (FreeCommRing.{u1} (coeSort.{succ u1, succ (succ u1)} (Set.{u1} α) Type.{u1} (Set.hasCoeToSort.{u1} α) s)) (CommRing.toRing.{u1} (FreeCommRing.{u1} (coeSort.{succ u1, succ (succ u1)} (Set.{u1} α) Type.{u1} (Set.hasCoeToSort.{u1} α) s)) (FreeCommRing.instCommRing.{u1} (coeSort.{succ u1, succ (succ u1)} (Set.{u1} α) Type.{u1} (Set.hasCoeToSort.{u1} α) s)))))) => (FreeCommRing.{u1} α) -> (FreeCommRing.{u1} (coeSort.{succ u1, succ (succ u1)} (Set.{u1} α) Type.{u1} (Set.hasCoeToSort.{u1} α) s))) (RingHom.hasCoeToFun.{u1, u1} (FreeCommRing.{u1} α) (FreeCommRing.{u1} (coeSort.{succ u1, succ (succ u1)} (Set.{u1} α) Type.{u1} (Set.hasCoeToSort.{u1} α) s)) (NonAssocRing.toNonAssocSemiring.{u1} (FreeCommRing.{u1} α) (Ring.toNonAssocRing.{u1} (FreeCommRing.{u1} α) (CommRing.toRing.{u1} (FreeCommRing.{u1} α) (FreeCommRing.instCommRing.{u1} α)))) (NonAssocRing.toNonAssocSemiring.{u1} (FreeCommRing.{u1} (coeSort.{succ u1, succ (succ u1)} (Set.{u1} α) Type.{u1} (Set.hasCoeToSort.{u1} α) s)) (Ring.toNonAssocRing.{u1} (FreeCommRing.{u1} (coeSort.{succ u1, succ (succ u1)} (Set.{u1} α) Type.{u1} (Set.hasCoeToSort.{u1} α) s)) (CommRing.toRing.{u1} (FreeCommRing.{u1} (coeSort.{succ u1, succ (succ u1)} (Set.{u1} α) Type.{u1} (Set.hasCoeToSort.{u1} α) s)) (FreeCommRing.instCommRing.{u1} (coeSort.{succ u1, succ (succ u1)} (Set.{u1} α) Type.{u1} (Set.hasCoeToSort.{u1} α) s)))))) (FreeCommRing.restriction.{u1} α s (fun (a : α) => _inst_1 a)) (FreeCommRing.of.{u1} α p)) (dite.{succ u1} (FreeCommRing.{u1} (coeSort.{succ u1, succ (succ u1)} (Set.{u1} α) Type.{u1} (Set.hasCoeToSort.{u1} α) s)) (Membership.Mem.{u1, u1} α (Set.{u1} α) (Set.hasMem.{u1} α) p s) (_inst_1 p) (fun (H : Membership.Mem.{u1, u1} α (Set.{u1} α) (Set.hasMem.{u1} α) p s) => FreeCommRing.of.{u1} (coeSort.{succ u1, succ (succ u1)} (Set.{u1} α) Type.{u1} (Set.hasCoeToSort.{u1} α) s) (Subtype.mk.{succ u1} α (fun (x : α) => Membership.Mem.{u1, u1} α (Set.{u1} α) (Set.hasMem.{u1} α) x s) p H)) (fun (H : Not (Membership.Mem.{u1, u1} α (Set.{u1} α) (Set.hasMem.{u1} α) p s)) => OfNat.ofNat.{u1} (FreeCommRing.{u1} (coeSort.{succ u1, succ (succ u1)} (Set.{u1} α) Type.{u1} (Set.hasCoeToSort.{u1} α) s)) 0 (OfNat.mk.{u1} (FreeCommRing.{u1} (coeSort.{succ u1, succ (succ u1)} (Set.{u1} α) Type.{u1} (Set.hasCoeToSort.{u1} α) s)) 0 (Zero.zero.{u1} (FreeCommRing.{u1} (coeSort.{succ u1, succ (succ u1)} (Set.{u1} α) Type.{u1} (Set.hasCoeToSort.{u1} α) s)) (MulZeroClass.toHasZero.{u1} (FreeCommRing.{u1} (coeSort.{succ u1, succ (succ u1)} (Set.{u1} α) Type.{u1} (Set.hasCoeToSort.{u1} α) s)) (NonUnitalNonAssocSemiring.toMulZeroClass.{u1} (FreeCommRing.{u1} (coeSort.{succ u1, succ (succ u1)} (Set.{u1} α) Type.{u1} (Set.hasCoeToSort.{u1} α) s)) (NonUnitalNonAssocRing.toNonUnitalNonAssocSemiring.{u1} (FreeCommRing.{u1} (coeSort.{succ u1, succ (succ u1)} (Set.{u1} α) Type.{u1} (Set.hasCoeToSort.{u1} α) s)) (NonAssocRing.toNonUnitalNonAssocRing.{u1} (FreeCommRing.{u1} (coeSort.{succ u1, succ (succ u1)} (Set.{u1} α) Type.{u1} (Set.hasCoeToSort.{u1} α) s)) (Ring.toNonAssocRing.{u1} (FreeCommRing.{u1} (coeSort.{succ u1, succ (succ u1)} (Set.{u1} α) Type.{u1} (Set.hasCoeToSort.{u1} α) s)) (CommRing.toRing.{u1} (FreeCommRing.{u1} (coeSort.{succ u1, succ (succ u1)} (Set.{u1} α) Type.{u1} (Set.hasCoeToSort.{u1} α) s)) (FreeCommRing.instCommRing.{u1} (coeSort.{succ u1, succ (succ u1)} (Set.{u1} α) Type.{u1} (Set.hasCoeToSort.{u1} α) s))))))))))))
-but is expected to have type
-  forall {α : Type.{u1}} (s : Set.{u1} α) [_inst_1 : DecidablePred.{succ u1} α (fun (_x : α) => Membership.mem.{u1, u1} α (Set.{u1} α) (Set.instMembershipSet.{u1} α) _x s)] (p : α), Eq.{succ u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2397 : FreeCommRing.{u1} α) => FreeCommRing.{u1} (Set.Elem.{u1} α s)) (FreeCommRing.of.{u1} α p)) (FunLike.coe.{succ u1, succ u1, succ u1} (RingHom.{u1, u1} (FreeCommRing.{u1} α) (FreeCommRing.{u1} (Set.Elem.{u1} α s)) (Semiring.toNonAssocSemiring.{u1} (FreeCommRing.{u1} α) (CommSemiring.toSemiring.{u1} (FreeCommRing.{u1} α) (CommRing.toCommSemiring.{u1} (FreeCommRing.{u1} α) (FreeCommRing.instCommRing.{u1} α)))) (Semiring.toNonAssocSemiring.{u1} (FreeCommRing.{u1} (Set.Elem.{u1} α s)) (CommSemiring.toSemiring.{u1} (FreeCommRing.{u1} (Set.Elem.{u1} α s)) (CommRing.toCommSemiring.{u1} (FreeCommRing.{u1} (Set.Elem.{u1} α s)) (FreeCommRing.instCommRing.{u1} (Set.Elem.{u1} α s)))))) (FreeCommRing.{u1} α) (fun (_x : FreeCommRing.{u1} α) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2397 : FreeCommRing.{u1} α) => FreeCommRing.{u1} (Set.Elem.{u1} α s)) _x) (MulHomClass.toFunLike.{u1, u1, u1} (RingHom.{u1, u1} (FreeCommRing.{u1} α) (FreeCommRing.{u1} (Set.Elem.{u1} α s)) (Semiring.toNonAssocSemiring.{u1} (FreeCommRing.{u1} α) (CommSemiring.toSemiring.{u1} (FreeCommRing.{u1} α) (CommRing.toCommSemiring.{u1} (FreeCommRing.{u1} α) (FreeCommRing.instCommRing.{u1} α)))) (Semiring.toNonAssocSemiring.{u1} (FreeCommRing.{u1} (Set.Elem.{u1} α s)) (CommSemiring.toSemiring.{u1} (FreeCommRing.{u1} (Set.Elem.{u1} α s)) (CommRing.toCommSemiring.{u1} (FreeCommRing.{u1} (Set.Elem.{u1} α s)) (FreeCommRing.instCommRing.{u1} (Set.Elem.{u1} α s)))))) (FreeCommRing.{u1} α) (FreeCommRing.{u1} (Set.Elem.{u1} α s)) (NonUnitalNonAssocSemiring.toMul.{u1} (FreeCommRing.{u1} α) (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u1} (FreeCommRing.{u1} α) (Semiring.toNonAssocSemiring.{u1} (FreeCommRing.{u1} α) (CommSemiring.toSemiring.{u1} (FreeCommRing.{u1} α) (CommRing.toCommSemiring.{u1} (FreeCommRing.{u1} α) (FreeCommRing.instCommRing.{u1} α)))))) (NonUnitalNonAssocSemiring.toMul.{u1} (FreeCommRing.{u1} (Set.Elem.{u1} α s)) (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u1} (FreeCommRing.{u1} (Set.Elem.{u1} α s)) (Semiring.toNonAssocSemiring.{u1} (FreeCommRing.{u1} (Set.Elem.{u1} α s)) (CommSemiring.toSemiring.{u1} (FreeCommRing.{u1} (Set.Elem.{u1} α s)) (CommRing.toCommSemiring.{u1} (FreeCommRing.{u1} (Set.Elem.{u1} α s)) (FreeCommRing.instCommRing.{u1} (Set.Elem.{u1} α s))))))) (NonUnitalRingHomClass.toMulHomClass.{u1, u1, u1} (RingHom.{u1, u1} (FreeCommRing.{u1} α) (FreeCommRing.{u1} (Set.Elem.{u1} α s)) (Semiring.toNonAssocSemiring.{u1} (FreeCommRing.{u1} α) (CommSemiring.toSemiring.{u1} (FreeCommRing.{u1} α) (CommRing.toCommSemiring.{u1} (FreeCommRing.{u1} α) (FreeCommRing.instCommRing.{u1} α)))) (Semiring.toNonAssocSemiring.{u1} (FreeCommRing.{u1} (Set.Elem.{u1} α s)) (CommSemiring.toSemiring.{u1} (FreeCommRing.{u1} (Set.Elem.{u1} α s)) (CommRing.toCommSemiring.{u1} (FreeCommRing.{u1} (Set.Elem.{u1} α s)) (FreeCommRing.instCommRing.{u1} (Set.Elem.{u1} α s)))))) (FreeCommRing.{u1} α) (FreeCommRing.{u1} (Set.Elem.{u1} α s)) (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u1} (FreeCommRing.{u1} α) (Semiring.toNonAssocSemiring.{u1} (FreeCommRing.{u1} α) (CommSemiring.toSemiring.{u1} (FreeCommRing.{u1} α) (CommRing.toCommSemiring.{u1} (FreeCommRing.{u1} α) (FreeCommRing.instCommRing.{u1} α))))) (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u1} (FreeCommRing.{u1} (Set.Elem.{u1} α s)) (Semiring.toNonAssocSemiring.{u1} (FreeCommRing.{u1} (Set.Elem.{u1} α s)) (CommSemiring.toSemiring.{u1} (FreeCommRing.{u1} (Set.Elem.{u1} α s)) (CommRing.toCommSemiring.{u1} (FreeCommRing.{u1} (Set.Elem.{u1} α s)) (FreeCommRing.instCommRing.{u1} (Set.Elem.{u1} α s)))))) (RingHomClass.toNonUnitalRingHomClass.{u1, u1, u1} (RingHom.{u1, u1} (FreeCommRing.{u1} α) (FreeCommRing.{u1} (Set.Elem.{u1} α s)) (Semiring.toNonAssocSemiring.{u1} (FreeCommRing.{u1} α) (CommSemiring.toSemiring.{u1} (FreeCommRing.{u1} α) (CommRing.toCommSemiring.{u1} (FreeCommRing.{u1} α) (FreeCommRing.instCommRing.{u1} α)))) (Semiring.toNonAssocSemiring.{u1} (FreeCommRing.{u1} (Set.Elem.{u1} α s)) (CommSemiring.toSemiring.{u1} (FreeCommRing.{u1} (Set.Elem.{u1} α s)) (CommRing.toCommSemiring.{u1} (FreeCommRing.{u1} (Set.Elem.{u1} α s)) (FreeCommRing.instCommRing.{u1} (Set.Elem.{u1} α s)))))) (FreeCommRing.{u1} α) (FreeCommRing.{u1} (Set.Elem.{u1} α s)) (Semiring.toNonAssocSemiring.{u1} (FreeCommRing.{u1} α) (CommSemiring.toSemiring.{u1} (FreeCommRing.{u1} α) (CommRing.toCommSemiring.{u1} (FreeCommRing.{u1} α) (FreeCommRing.instCommRing.{u1} α)))) (Semiring.toNonAssocSemiring.{u1} (FreeCommRing.{u1} (Set.Elem.{u1} α s)) (CommSemiring.toSemiring.{u1} (FreeCommRing.{u1} (Set.Elem.{u1} α s)) (CommRing.toCommSemiring.{u1} (FreeCommRing.{u1} (Set.Elem.{u1} α s)) (FreeCommRing.instCommRing.{u1} (Set.Elem.{u1} α s))))) (RingHom.instRingHomClassRingHom.{u1, u1} (FreeCommRing.{u1} α) (FreeCommRing.{u1} (Set.Elem.{u1} α s)) (Semiring.toNonAssocSemiring.{u1} (FreeCommRing.{u1} α) (CommSemiring.toSemiring.{u1} (FreeCommRing.{u1} α) (CommRing.toCommSemiring.{u1} (FreeCommRing.{u1} α) (FreeCommRing.instCommRing.{u1} α)))) (Semiring.toNonAssocSemiring.{u1} (FreeCommRing.{u1} (Set.Elem.{u1} α s)) (CommSemiring.toSemiring.{u1} (FreeCommRing.{u1} (Set.Elem.{u1} α s)) (CommRing.toCommSemiring.{u1} (FreeCommRing.{u1} (Set.Elem.{u1} α s)) (FreeCommRing.instCommRing.{u1} (Set.Elem.{u1} α s))))))))) (FreeCommRing.restriction.{u1} α s (fun (a : α) => _inst_1 a)) (FreeCommRing.of.{u1} α p)) (dite.{succ u1} (FreeCommRing.{u1} (Set.Elem.{u1} α s)) (Membership.mem.{u1, u1} α (Set.{u1} α) (Set.instMembershipSet.{u1} α) p s) (_inst_1 p) (fun (H : Membership.mem.{u1, u1} α (Set.{u1} α) (Set.instMembershipSet.{u1} α) p s) => FreeCommRing.of.{u1} (Set.Elem.{u1} α s) (Subtype.mk.{succ u1} α (fun (x : α) => Membership.mem.{u1, u1} α (Set.{u1} α) (Set.instMembershipSet.{u1} α) x s) p H)) (fun (H : Not (Membership.mem.{u1, u1} α (Set.{u1} α) (Set.instMembershipSet.{u1} α) p s)) => OfNat.ofNat.{u1} (FreeCommRing.{u1} (Set.Elem.{u1} α s)) 0 (Zero.toOfNat0.{u1} (FreeCommRing.{u1} (Set.Elem.{u1} α s)) (CommMonoidWithZero.toZero.{u1} (FreeCommRing.{u1} (Set.Elem.{u1} α s)) (CommSemiring.toCommMonoidWithZero.{u1} (FreeCommRing.{u1} (Set.Elem.{u1} α s)) (CommRing.toCommSemiring.{u1} (FreeCommRing.{u1} (Set.Elem.{u1} α s)) (FreeCommRing.instCommRing.{u1} (Set.Elem.{u1} α s))))))))
+<too large>
 Case conversion may be inaccurate. Consider using '#align free_comm_ring.restriction_of FreeCommRing.restriction_ofₓ'. -/
 @[simp]
 theorem restriction_of (p) : restriction s (of p) = if H : p ∈ s then of ⟨p, H⟩ else 0 :=
@@ -354,10 +347,7 @@ theorem isSupported_of {p} {s : Set α} : IsSupported (of p) s ↔ p ∈ s :=
 -/
 
 /- warning: free_comm_ring.map_subtype_val_restriction -> FreeCommRing.map_subtype_val_restriction is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {x : FreeCommRing.{u1} α} (s : Set.{u1} α) [_inst_1 : DecidablePred.{succ u1} α (fun (_x : α) => Membership.Mem.{u1, u1} α (Set.{u1} α) (Set.hasMem.{u1} α) _x s)], (FreeCommRing.IsSupported.{u1} α x s) -> (Eq.{succ u1} (FreeCommRing.{u1} α) (coeFn.{succ u1, succ u1} (RingHom.{u1, u1} (FreeCommRing.{u1} (Subtype.{succ u1} α (fun (x : α) => Membership.Mem.{u1, u1} α (Set.{u1} α) (Set.hasMem.{u1} α) x s))) (FreeCommRing.{u1} α) (NonAssocRing.toNonAssocSemiring.{u1} (FreeCommRing.{u1} (Subtype.{succ u1} α (fun (x : α) => Membership.Mem.{u1, u1} α (Set.{u1} α) (Set.hasMem.{u1} α) x s))) (Ring.toNonAssocRing.{u1} (FreeCommRing.{u1} (Subtype.{succ u1} α (fun (x : α) => Membership.Mem.{u1, u1} α (Set.{u1} α) (Set.hasMem.{u1} α) x s))) (CommRing.toRing.{u1} (FreeCommRing.{u1} (Subtype.{succ u1} α (fun (x : α) => Membership.Mem.{u1, u1} α (Set.{u1} α) (Set.hasMem.{u1} α) x s))) (FreeCommRing.instCommRing.{u1} (Subtype.{succ u1} α (fun (x : α) => Membership.Mem.{u1, u1} α (Set.{u1} α) (Set.hasMem.{u1} α) x s)))))) (NonAssocRing.toNonAssocSemiring.{u1} (FreeCommRing.{u1} α) (Ring.toNonAssocRing.{u1} (FreeCommRing.{u1} α) (CommRing.toRing.{u1} (FreeCommRing.{u1} α) (FreeCommRing.instCommRing.{u1} α))))) (fun (_x : RingHom.{u1, u1} (FreeCommRing.{u1} (Subtype.{succ u1} α (fun (x : α) => Membership.Mem.{u1, u1} α (Set.{u1} α) (Set.hasMem.{u1} α) x s))) (FreeCommRing.{u1} α) (NonAssocRing.toNonAssocSemiring.{u1} (FreeCommRing.{u1} (Subtype.{succ u1} α (fun (x : α) => Membership.Mem.{u1, u1} α (Set.{u1} α) (Set.hasMem.{u1} α) x s))) (Ring.toNonAssocRing.{u1} (FreeCommRing.{u1} (Subtype.{succ u1} α (fun (x : α) => Membership.Mem.{u1, u1} α (Set.{u1} α) (Set.hasMem.{u1} α) x s))) (CommRing.toRing.{u1} (FreeCommRing.{u1} (Subtype.{succ u1} α (fun (x : α) => Membership.Mem.{u1, u1} α (Set.{u1} α) (Set.hasMem.{u1} α) x s))) (FreeCommRing.instCommRing.{u1} (Subtype.{succ u1} α (fun (x : α) => Membership.Mem.{u1, u1} α (Set.{u1} α) (Set.hasMem.{u1} α) x s)))))) (NonAssocRing.toNonAssocSemiring.{u1} (FreeCommRing.{u1} α) (Ring.toNonAssocRing.{u1} (FreeCommRing.{u1} α) (CommRing.toRing.{u1} (FreeCommRing.{u1} α) (FreeCommRing.instCommRing.{u1} α))))) => (FreeCommRing.{u1} (Subtype.{succ u1} α (fun (x : α) => Membership.Mem.{u1, u1} α (Set.{u1} α) (Set.hasMem.{u1} α) x s))) -> (FreeCommRing.{u1} α)) (RingHom.hasCoeToFun.{u1, u1} (FreeCommRing.{u1} (Subtype.{succ u1} α (fun (x : α) => Membership.Mem.{u1, u1} α (Set.{u1} α) (Set.hasMem.{u1} α) x s))) (FreeCommRing.{u1} α) (NonAssocRing.toNonAssocSemiring.{u1} (FreeCommRing.{u1} (Subtype.{succ u1} α (fun (x : α) => Membership.Mem.{u1, u1} α (Set.{u1} α) (Set.hasMem.{u1} α) x s))) (Ring.toNonAssocRing.{u1} (FreeCommRing.{u1} (Subtype.{succ u1} α (fun (x : α) => Membership.Mem.{u1, u1} α (Set.{u1} α) (Set.hasMem.{u1} α) x s))) (CommRing.toRing.{u1} (FreeCommRing.{u1} (Subtype.{succ u1} α (fun (x : α) => Membership.Mem.{u1, u1} α (Set.{u1} α) (Set.hasMem.{u1} α) x s))) (FreeCommRing.instCommRing.{u1} (Subtype.{succ u1} α (fun (x : α) => Membership.Mem.{u1, u1} α (Set.{u1} α) (Set.hasMem.{u1} α) x s)))))) (NonAssocRing.toNonAssocSemiring.{u1} (FreeCommRing.{u1} α) (Ring.toNonAssocRing.{u1} (FreeCommRing.{u1} α) (CommRing.toRing.{u1} (FreeCommRing.{u1} α) (FreeCommRing.instCommRing.{u1} α))))) (FreeCommRing.map.{u1, u1} (Subtype.{succ u1} α (fun (x : α) => Membership.Mem.{u1, u1} α (Set.{u1} α) (Set.hasMem.{u1} α) x s)) α (Subtype.val.{succ u1} α (fun (x : α) => Membership.Mem.{u1, u1} α (Set.{u1} α) (Set.hasMem.{u1} α) x s))) (coeFn.{succ u1, succ u1} (RingHom.{u1, u1} (FreeCommRing.{u1} α) (FreeCommRing.{u1} (coeSort.{succ u1, succ (succ u1)} (Set.{u1} α) Type.{u1} (Set.hasCoeToSort.{u1} α) s)) (NonAssocRing.toNonAssocSemiring.{u1} (FreeCommRing.{u1} α) (Ring.toNonAssocRing.{u1} (FreeCommRing.{u1} α) (CommRing.toRing.{u1} (FreeCommRing.{u1} α) (FreeCommRing.instCommRing.{u1} α)))) (NonAssocRing.toNonAssocSemiring.{u1} (FreeCommRing.{u1} (coeSort.{succ u1, succ (succ u1)} (Set.{u1} α) Type.{u1} (Set.hasCoeToSort.{u1} α) s)) (Ring.toNonAssocRing.{u1} (FreeCommRing.{u1} (coeSort.{succ u1, succ (succ u1)} (Set.{u1} α) Type.{u1} (Set.hasCoeToSort.{u1} α) s)) (CommRing.toRing.{u1} (FreeCommRing.{u1} (coeSort.{succ u1, succ (succ u1)} (Set.{u1} α) Type.{u1} (Set.hasCoeToSort.{u1} α) s)) (FreeCommRing.instCommRing.{u1} (coeSort.{succ u1, succ (succ u1)} (Set.{u1} α) Type.{u1} (Set.hasCoeToSort.{u1} α) s)))))) (fun (_x : RingHom.{u1, u1} (FreeCommRing.{u1} α) (FreeCommRing.{u1} (coeSort.{succ u1, succ (succ u1)} (Set.{u1} α) Type.{u1} (Set.hasCoeToSort.{u1} α) s)) (NonAssocRing.toNonAssocSemiring.{u1} (FreeCommRing.{u1} α) (Ring.toNonAssocRing.{u1} (FreeCommRing.{u1} α) (CommRing.toRing.{u1} (FreeCommRing.{u1} α) (FreeCommRing.instCommRing.{u1} α)))) (NonAssocRing.toNonAssocSemiring.{u1} (FreeCommRing.{u1} (coeSort.{succ u1, succ (succ u1)} (Set.{u1} α) Type.{u1} (Set.hasCoeToSort.{u1} α) s)) (Ring.toNonAssocRing.{u1} (FreeCommRing.{u1} (coeSort.{succ u1, succ (succ u1)} (Set.{u1} α) Type.{u1} (Set.hasCoeToSort.{u1} α) s)) (CommRing.toRing.{u1} (FreeCommRing.{u1} (coeSort.{succ u1, succ (succ u1)} (Set.{u1} α) Type.{u1} (Set.hasCoeToSort.{u1} α) s)) (FreeCommRing.instCommRing.{u1} (coeSort.{succ u1, succ (succ u1)} (Set.{u1} α) Type.{u1} (Set.hasCoeToSort.{u1} α) s)))))) => (FreeCommRing.{u1} α) -> (FreeCommRing.{u1} (coeSort.{succ u1, succ (succ u1)} (Set.{u1} α) Type.{u1} (Set.hasCoeToSort.{u1} α) s))) (RingHom.hasCoeToFun.{u1, u1} (FreeCommRing.{u1} α) (FreeCommRing.{u1} (coeSort.{succ u1, succ (succ u1)} (Set.{u1} α) Type.{u1} (Set.hasCoeToSort.{u1} α) s)) (NonAssocRing.toNonAssocSemiring.{u1} (FreeCommRing.{u1} α) (Ring.toNonAssocRing.{u1} (FreeCommRing.{u1} α) (CommRing.toRing.{u1} (FreeCommRing.{u1} α) (FreeCommRing.instCommRing.{u1} α)))) (NonAssocRing.toNonAssocSemiring.{u1} (FreeCommRing.{u1} (coeSort.{succ u1, succ (succ u1)} (Set.{u1} α) Type.{u1} (Set.hasCoeToSort.{u1} α) s)) (Ring.toNonAssocRing.{u1} (FreeCommRing.{u1} (coeSort.{succ u1, succ (succ u1)} (Set.{u1} α) Type.{u1} (Set.hasCoeToSort.{u1} α) s)) (CommRing.toRing.{u1} (FreeCommRing.{u1} (coeSort.{succ u1, succ (succ u1)} (Set.{u1} α) Type.{u1} (Set.hasCoeToSort.{u1} α) s)) (FreeCommRing.instCommRing.{u1} (coeSort.{succ u1, succ (succ u1)} (Set.{u1} α) Type.{u1} (Set.hasCoeToSort.{u1} α) s)))))) (FreeCommRing.restriction.{u1} α s (fun (a : α) => _inst_1 a)) x)) x)
-but is expected to have type
-  forall {α : Type.{u1}} {x : FreeCommRing.{u1} α} (s : Set.{u1} α) [_inst_1 : DecidablePred.{succ u1} α (fun (_x : α) => Membership.mem.{u1, u1} α (Set.{u1} α) (Set.instMembershipSet.{u1} α) _x s)], (FreeCommRing.IsSupported.{u1} α x s) -> (Eq.{succ u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2397 : FreeCommRing.{u1} (Set.Elem.{u1} α s)) => FreeCommRing.{u1} α) (FunLike.coe.{succ u1, succ u1, succ u1} (RingHom.{u1, u1} (FreeCommRing.{u1} α) (FreeCommRing.{u1} (Set.Elem.{u1} α s)) (Semiring.toNonAssocSemiring.{u1} (FreeCommRing.{u1} α) (CommSemiring.toSemiring.{u1} (FreeCommRing.{u1} α) (CommRing.toCommSemiring.{u1} (FreeCommRing.{u1} α) (FreeCommRing.instCommRing.{u1} α)))) (Semiring.toNonAssocSemiring.{u1} (FreeCommRing.{u1} (Set.Elem.{u1} α s)) (CommSemiring.toSemiring.{u1} (FreeCommRing.{u1} (Set.Elem.{u1} α s)) (CommRing.toCommSemiring.{u1} (FreeCommRing.{u1} (Set.Elem.{u1} α s)) (FreeCommRing.instCommRing.{u1} (Set.Elem.{u1} α s)))))) (FreeCommRing.{u1} α) (fun (a : FreeCommRing.{u1} α) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2397 : FreeCommRing.{u1} α) => FreeCommRing.{u1} (Set.Elem.{u1} α s)) a) (MulHomClass.toFunLike.{u1, u1, u1} (RingHom.{u1, u1} (FreeCommRing.{u1} α) (FreeCommRing.{u1} (Set.Elem.{u1} α s)) (Semiring.toNonAssocSemiring.{u1} (FreeCommRing.{u1} α) (CommSemiring.toSemiring.{u1} (FreeCommRing.{u1} α) (CommRing.toCommSemiring.{u1} (FreeCommRing.{u1} α) (FreeCommRing.instCommRing.{u1} α)))) (Semiring.toNonAssocSemiring.{u1} (FreeCommRing.{u1} (Set.Elem.{u1} α s)) (CommSemiring.toSemiring.{u1} (FreeCommRing.{u1} (Set.Elem.{u1} α s)) (CommRing.toCommSemiring.{u1} (FreeCommRing.{u1} (Set.Elem.{u1} α s)) (FreeCommRing.instCommRing.{u1} (Set.Elem.{u1} α s)))))) (FreeCommRing.{u1} α) (FreeCommRing.{u1} (Set.Elem.{u1} α s)) (NonUnitalNonAssocSemiring.toMul.{u1} (FreeCommRing.{u1} α) (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u1} (FreeCommRing.{u1} α) (Semiring.toNonAssocSemiring.{u1} (FreeCommRing.{u1} α) (CommSemiring.toSemiring.{u1} (FreeCommRing.{u1} α) (CommRing.toCommSemiring.{u1} (FreeCommRing.{u1} α) (FreeCommRing.instCommRing.{u1} α)))))) (NonUnitalNonAssocSemiring.toMul.{u1} (FreeCommRing.{u1} (Set.Elem.{u1} α s)) (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u1} (FreeCommRing.{u1} (Set.Elem.{u1} α s)) (Semiring.toNonAssocSemiring.{u1} (FreeCommRing.{u1} (Set.Elem.{u1} α s)) (CommSemiring.toSemiring.{u1} (FreeCommRing.{u1} (Set.Elem.{u1} α s)) (CommRing.toCommSemiring.{u1} (FreeCommRing.{u1} (Set.Elem.{u1} α s)) (FreeCommRing.instCommRing.{u1} (Set.Elem.{u1} α s))))))) (NonUnitalRingHomClass.toMulHomClass.{u1, u1, u1} (RingHom.{u1, u1} (FreeCommRing.{u1} α) (FreeCommRing.{u1} (Set.Elem.{u1} α s)) (Semiring.toNonAssocSemiring.{u1} (FreeCommRing.{u1} α) (CommSemiring.toSemiring.{u1} (FreeCommRing.{u1} α) (CommRing.toCommSemiring.{u1} (FreeCommRing.{u1} α) (FreeCommRing.instCommRing.{u1} α)))) (Semiring.toNonAssocSemiring.{u1} (FreeCommRing.{u1} (Set.Elem.{u1} α s)) (CommSemiring.toSemiring.{u1} (FreeCommRing.{u1} (Set.Elem.{u1} α s)) (CommRing.toCommSemiring.{u1} (FreeCommRing.{u1} (Set.Elem.{u1} α s)) (FreeCommRing.instCommRing.{u1} (Set.Elem.{u1} α s)))))) (FreeCommRing.{u1} α) (FreeCommRing.{u1} (Set.Elem.{u1} α s)) (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u1} (FreeCommRing.{u1} α) (Semiring.toNonAssocSemiring.{u1} (FreeCommRing.{u1} α) (CommSemiring.toSemiring.{u1} (FreeCommRing.{u1} α) (CommRing.toCommSemiring.{u1} (FreeCommRing.{u1} α) (FreeCommRing.instCommRing.{u1} α))))) (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u1} (FreeCommRing.{u1} (Set.Elem.{u1} α s)) (Semiring.toNonAssocSemiring.{u1} (FreeCommRing.{u1} (Set.Elem.{u1} α s)) (CommSemiring.toSemiring.{u1} (FreeCommRing.{u1} (Set.Elem.{u1} α s)) (CommRing.toCommSemiring.{u1} (FreeCommRing.{u1} (Set.Elem.{u1} α s)) (FreeCommRing.instCommRing.{u1} (Set.Elem.{u1} α s)))))) (RingHomClass.toNonUnitalRingHomClass.{u1, u1, u1} (RingHom.{u1, u1} (FreeCommRing.{u1} α) (FreeCommRing.{u1} (Set.Elem.{u1} α s)) (Semiring.toNonAssocSemiring.{u1} (FreeCommRing.{u1} α) (CommSemiring.toSemiring.{u1} (FreeCommRing.{u1} α) (CommRing.toCommSemiring.{u1} (FreeCommRing.{u1} α) (FreeCommRing.instCommRing.{u1} α)))) (Semiring.toNonAssocSemiring.{u1} (FreeCommRing.{u1} (Set.Elem.{u1} α s)) (CommSemiring.toSemiring.{u1} (FreeCommRing.{u1} (Set.Elem.{u1} α s)) (CommRing.toCommSemiring.{u1} (FreeCommRing.{u1} (Set.Elem.{u1} α s)) (FreeCommRing.instCommRing.{u1} (Set.Elem.{u1} α s)))))) (FreeCommRing.{u1} α) (FreeCommRing.{u1} (Set.Elem.{u1} α s)) (Semiring.toNonAssocSemiring.{u1} (FreeCommRing.{u1} α) (CommSemiring.toSemiring.{u1} (FreeCommRing.{u1} α) (CommRing.toCommSemiring.{u1} (FreeCommRing.{u1} α) (FreeCommRing.instCommRing.{u1} α)))) (Semiring.toNonAssocSemiring.{u1} (FreeCommRing.{u1} (Set.Elem.{u1} α s)) (CommSemiring.toSemiring.{u1} (FreeCommRing.{u1} (Set.Elem.{u1} α s)) (CommRing.toCommSemiring.{u1} (FreeCommRing.{u1} (Set.Elem.{u1} α s)) (FreeCommRing.instCommRing.{u1} (Set.Elem.{u1} α s))))) (RingHom.instRingHomClassRingHom.{u1, u1} (FreeCommRing.{u1} α) (FreeCommRing.{u1} (Set.Elem.{u1} α s)) (Semiring.toNonAssocSemiring.{u1} (FreeCommRing.{u1} α) (CommSemiring.toSemiring.{u1} (FreeCommRing.{u1} α) (CommRing.toCommSemiring.{u1} (FreeCommRing.{u1} α) (FreeCommRing.instCommRing.{u1} α)))) (Semiring.toNonAssocSemiring.{u1} (FreeCommRing.{u1} (Set.Elem.{u1} α s)) (CommSemiring.toSemiring.{u1} (FreeCommRing.{u1} (Set.Elem.{u1} α s)) (CommRing.toCommSemiring.{u1} (FreeCommRing.{u1} (Set.Elem.{u1} α s)) (FreeCommRing.instCommRing.{u1} (Set.Elem.{u1} α s))))))))) (FreeCommRing.restriction.{u1} α s (fun (a : α) => _inst_1 a)) x)) (FunLike.coe.{succ u1, succ u1, succ u1} (RingHom.{u1, u1} (FreeCommRing.{u1} (Set.Elem.{u1} α s)) (FreeCommRing.{u1} α) (Semiring.toNonAssocSemiring.{u1} (FreeCommRing.{u1} (Set.Elem.{u1} α s)) (CommSemiring.toSemiring.{u1} (FreeCommRing.{u1} (Set.Elem.{u1} α s)) (CommRing.toCommSemiring.{u1} (FreeCommRing.{u1} (Set.Elem.{u1} α s)) (FreeCommRing.instCommRing.{u1} (Set.Elem.{u1} α s))))) (Semiring.toNonAssocSemiring.{u1} (FreeCommRing.{u1} α) (CommSemiring.toSemiring.{u1} (FreeCommRing.{u1} α) (CommRing.toCommSemiring.{u1} (FreeCommRing.{u1} α) (FreeCommRing.instCommRing.{u1} α))))) (FreeCommRing.{u1} (Set.Elem.{u1} α s)) (fun (_x : FreeCommRing.{u1} (Set.Elem.{u1} α s)) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2397 : FreeCommRing.{u1} (Set.Elem.{u1} α s)) => FreeCommRing.{u1} α) _x) (MulHomClass.toFunLike.{u1, u1, u1} (RingHom.{u1, u1} (FreeCommRing.{u1} (Set.Elem.{u1} α s)) (FreeCommRing.{u1} α) (Semiring.toNonAssocSemiring.{u1} (FreeCommRing.{u1} (Set.Elem.{u1} α s)) (CommSemiring.toSemiring.{u1} (FreeCommRing.{u1} (Set.Elem.{u1} α s)) (CommRing.toCommSemiring.{u1} (FreeCommRing.{u1} (Set.Elem.{u1} α s)) (FreeCommRing.instCommRing.{u1} (Set.Elem.{u1} α s))))) (Semiring.toNonAssocSemiring.{u1} (FreeCommRing.{u1} α) (CommSemiring.toSemiring.{u1} (FreeCommRing.{u1} α) (CommRing.toCommSemiring.{u1} (FreeCommRing.{u1} α) (FreeCommRing.instCommRing.{u1} α))))) (FreeCommRing.{u1} (Set.Elem.{u1} α s)) (FreeCommRing.{u1} α) (NonUnitalNonAssocSemiring.toMul.{u1} (FreeCommRing.{u1} (Set.Elem.{u1} α s)) (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u1} (FreeCommRing.{u1} (Set.Elem.{u1} α s)) (Semiring.toNonAssocSemiring.{u1} (FreeCommRing.{u1} (Set.Elem.{u1} α s)) (CommSemiring.toSemiring.{u1} (FreeCommRing.{u1} (Set.Elem.{u1} α s)) (CommRing.toCommSemiring.{u1} (FreeCommRing.{u1} (Set.Elem.{u1} α s)) (FreeCommRing.instCommRing.{u1} (Set.Elem.{u1} α s))))))) (NonUnitalNonAssocSemiring.toMul.{u1} (FreeCommRing.{u1} α) (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u1} (FreeCommRing.{u1} α) (Semiring.toNonAssocSemiring.{u1} (FreeCommRing.{u1} α) (CommSemiring.toSemiring.{u1} (FreeCommRing.{u1} α) (CommRing.toCommSemiring.{u1} (FreeCommRing.{u1} α) (FreeCommRing.instCommRing.{u1} α)))))) (NonUnitalRingHomClass.toMulHomClass.{u1, u1, u1} (RingHom.{u1, u1} (FreeCommRing.{u1} (Set.Elem.{u1} α s)) (FreeCommRing.{u1} α) (Semiring.toNonAssocSemiring.{u1} (FreeCommRing.{u1} (Set.Elem.{u1} α s)) (CommSemiring.toSemiring.{u1} (FreeCommRing.{u1} (Set.Elem.{u1} α s)) (CommRing.toCommSemiring.{u1} (FreeCommRing.{u1} (Set.Elem.{u1} α s)) (FreeCommRing.instCommRing.{u1} (Set.Elem.{u1} α s))))) (Semiring.toNonAssocSemiring.{u1} (FreeCommRing.{u1} α) (CommSemiring.toSemiring.{u1} (FreeCommRing.{u1} α) (CommRing.toCommSemiring.{u1} (FreeCommRing.{u1} α) (FreeCommRing.instCommRing.{u1} α))))) (FreeCommRing.{u1} (Set.Elem.{u1} α s)) (FreeCommRing.{u1} α) (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u1} (FreeCommRing.{u1} (Set.Elem.{u1} α s)) (Semiring.toNonAssocSemiring.{u1} (FreeCommRing.{u1} (Set.Elem.{u1} α s)) (CommSemiring.toSemiring.{u1} (FreeCommRing.{u1} (Set.Elem.{u1} α s)) (CommRing.toCommSemiring.{u1} (FreeCommRing.{u1} (Set.Elem.{u1} α s)) (FreeCommRing.instCommRing.{u1} (Set.Elem.{u1} α s)))))) (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u1} (FreeCommRing.{u1} α) (Semiring.toNonAssocSemiring.{u1} (FreeCommRing.{u1} α) (CommSemiring.toSemiring.{u1} (FreeCommRing.{u1} α) (CommRing.toCommSemiring.{u1} (FreeCommRing.{u1} α) (FreeCommRing.instCommRing.{u1} α))))) (RingHomClass.toNonUnitalRingHomClass.{u1, u1, u1} (RingHom.{u1, u1} (FreeCommRing.{u1} (Set.Elem.{u1} α s)) (FreeCommRing.{u1} α) (Semiring.toNonAssocSemiring.{u1} (FreeCommRing.{u1} (Set.Elem.{u1} α s)) (CommSemiring.toSemiring.{u1} (FreeCommRing.{u1} (Set.Elem.{u1} α s)) (CommRing.toCommSemiring.{u1} (FreeCommRing.{u1} (Set.Elem.{u1} α s)) (FreeCommRing.instCommRing.{u1} (Set.Elem.{u1} α s))))) (Semiring.toNonAssocSemiring.{u1} (FreeCommRing.{u1} α) (CommSemiring.toSemiring.{u1} (FreeCommRing.{u1} α) (CommRing.toCommSemiring.{u1} (FreeCommRing.{u1} α) (FreeCommRing.instCommRing.{u1} α))))) (FreeCommRing.{u1} (Set.Elem.{u1} α s)) (FreeCommRing.{u1} α) (Semiring.toNonAssocSemiring.{u1} (FreeCommRing.{u1} (Set.Elem.{u1} α s)) (CommSemiring.toSemiring.{u1} (FreeCommRing.{u1} (Set.Elem.{u1} α s)) (CommRing.toCommSemiring.{u1} (FreeCommRing.{u1} (Set.Elem.{u1} α s)) (FreeCommRing.instCommRing.{u1} (Set.Elem.{u1} α s))))) (Semiring.toNonAssocSemiring.{u1} (FreeCommRing.{u1} α) (CommSemiring.toSemiring.{u1} (FreeCommRing.{u1} α) (CommRing.toCommSemiring.{u1} (FreeCommRing.{u1} α) (FreeCommRing.instCommRing.{u1} α)))) (RingHom.instRingHomClassRingHom.{u1, u1} (FreeCommRing.{u1} (Set.Elem.{u1} α s)) (FreeCommRing.{u1} α) (Semiring.toNonAssocSemiring.{u1} (FreeCommRing.{u1} (Set.Elem.{u1} α s)) (CommSemiring.toSemiring.{u1} (FreeCommRing.{u1} (Set.Elem.{u1} α s)) (CommRing.toCommSemiring.{u1} (FreeCommRing.{u1} (Set.Elem.{u1} α s)) (FreeCommRing.instCommRing.{u1} (Set.Elem.{u1} α s))))) (Semiring.toNonAssocSemiring.{u1} (FreeCommRing.{u1} α) (CommSemiring.toSemiring.{u1} (FreeCommRing.{u1} α) (CommRing.toCommSemiring.{u1} (FreeCommRing.{u1} α) (FreeCommRing.instCommRing.{u1} α)))))))) (FreeCommRing.map.{u1, u1} (Set.Elem.{u1} α s) α (Subtype.val.{succ u1} α (fun (x : α) => Membership.mem.{u1, u1} α (Set.{u1} α) (Set.instMembershipSet.{u1} α) x s))) (FunLike.coe.{succ u1, succ u1, succ u1} (RingHom.{u1, u1} (FreeCommRing.{u1} α) (FreeCommRing.{u1} (Set.Elem.{u1} α s)) (Semiring.toNonAssocSemiring.{u1} (FreeCommRing.{u1} α) (CommSemiring.toSemiring.{u1} (FreeCommRing.{u1} α) (CommRing.toCommSemiring.{u1} (FreeCommRing.{u1} α) (FreeCommRing.instCommRing.{u1} α)))) (Semiring.toNonAssocSemiring.{u1} (FreeCommRing.{u1} (Set.Elem.{u1} α s)) (CommSemiring.toSemiring.{u1} (FreeCommRing.{u1} (Set.Elem.{u1} α s)) (CommRing.toCommSemiring.{u1} (FreeCommRing.{u1} (Set.Elem.{u1} α s)) (FreeCommRing.instCommRing.{u1} (Set.Elem.{u1} α s)))))) (FreeCommRing.{u1} α) (fun (_x : FreeCommRing.{u1} α) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2397 : FreeCommRing.{u1} α) => FreeCommRing.{u1} (Set.Elem.{u1} α s)) _x) (MulHomClass.toFunLike.{u1, u1, u1} (RingHom.{u1, u1} (FreeCommRing.{u1} α) (FreeCommRing.{u1} (Set.Elem.{u1} α s)) (Semiring.toNonAssocSemiring.{u1} (FreeCommRing.{u1} α) (CommSemiring.toSemiring.{u1} (FreeCommRing.{u1} α) (CommRing.toCommSemiring.{u1} (FreeCommRing.{u1} α) (FreeCommRing.instCommRing.{u1} α)))) (Semiring.toNonAssocSemiring.{u1} (FreeCommRing.{u1} (Set.Elem.{u1} α s)) (CommSemiring.toSemiring.{u1} (FreeCommRing.{u1} (Set.Elem.{u1} α s)) (CommRing.toCommSemiring.{u1} (FreeCommRing.{u1} (Set.Elem.{u1} α s)) (FreeCommRing.instCommRing.{u1} (Set.Elem.{u1} α s)))))) (FreeCommRing.{u1} α) (FreeCommRing.{u1} (Set.Elem.{u1} α s)) (NonUnitalNonAssocSemiring.toMul.{u1} (FreeCommRing.{u1} α) (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u1} (FreeCommRing.{u1} α) (Semiring.toNonAssocSemiring.{u1} (FreeCommRing.{u1} α) (CommSemiring.toSemiring.{u1} (FreeCommRing.{u1} α) (CommRing.toCommSemiring.{u1} (FreeCommRing.{u1} α) (FreeCommRing.instCommRing.{u1} α)))))) (NonUnitalNonAssocSemiring.toMul.{u1} (FreeCommRing.{u1} (Set.Elem.{u1} α s)) (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u1} (FreeCommRing.{u1} (Set.Elem.{u1} α s)) (Semiring.toNonAssocSemiring.{u1} (FreeCommRing.{u1} (Set.Elem.{u1} α s)) (CommSemiring.toSemiring.{u1} (FreeCommRing.{u1} (Set.Elem.{u1} α s)) (CommRing.toCommSemiring.{u1} (FreeCommRing.{u1} (Set.Elem.{u1} α s)) (FreeCommRing.instCommRing.{u1} (Set.Elem.{u1} α s))))))) (NonUnitalRingHomClass.toMulHomClass.{u1, u1, u1} (RingHom.{u1, u1} (FreeCommRing.{u1} α) (FreeCommRing.{u1} (Set.Elem.{u1} α s)) (Semiring.toNonAssocSemiring.{u1} (FreeCommRing.{u1} α) (CommSemiring.toSemiring.{u1} (FreeCommRing.{u1} α) (CommRing.toCommSemiring.{u1} (FreeCommRing.{u1} α) (FreeCommRing.instCommRing.{u1} α)))) (Semiring.toNonAssocSemiring.{u1} (FreeCommRing.{u1} (Set.Elem.{u1} α s)) (CommSemiring.toSemiring.{u1} (FreeCommRing.{u1} (Set.Elem.{u1} α s)) (CommRing.toCommSemiring.{u1} (FreeCommRing.{u1} (Set.Elem.{u1} α s)) (FreeCommRing.instCommRing.{u1} (Set.Elem.{u1} α s)))))) (FreeCommRing.{u1} α) (FreeCommRing.{u1} (Set.Elem.{u1} α s)) (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u1} (FreeCommRing.{u1} α) (Semiring.toNonAssocSemiring.{u1} (FreeCommRing.{u1} α) (CommSemiring.toSemiring.{u1} (FreeCommRing.{u1} α) (CommRing.toCommSemiring.{u1} (FreeCommRing.{u1} α) (FreeCommRing.instCommRing.{u1} α))))) (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u1} (FreeCommRing.{u1} (Set.Elem.{u1} α s)) (Semiring.toNonAssocSemiring.{u1} (FreeCommRing.{u1} (Set.Elem.{u1} α s)) (CommSemiring.toSemiring.{u1} (FreeCommRing.{u1} (Set.Elem.{u1} α s)) (CommRing.toCommSemiring.{u1} (FreeCommRing.{u1} (Set.Elem.{u1} α s)) (FreeCommRing.instCommRing.{u1} (Set.Elem.{u1} α s)))))) (RingHomClass.toNonUnitalRingHomClass.{u1, u1, u1} (RingHom.{u1, u1} (FreeCommRing.{u1} α) (FreeCommRing.{u1} (Set.Elem.{u1} α s)) (Semiring.toNonAssocSemiring.{u1} (FreeCommRing.{u1} α) (CommSemiring.toSemiring.{u1} (FreeCommRing.{u1} α) (CommRing.toCommSemiring.{u1} (FreeCommRing.{u1} α) (FreeCommRing.instCommRing.{u1} α)))) (Semiring.toNonAssocSemiring.{u1} (FreeCommRing.{u1} (Set.Elem.{u1} α s)) (CommSemiring.toSemiring.{u1} (FreeCommRing.{u1} (Set.Elem.{u1} α s)) (CommRing.toCommSemiring.{u1} (FreeCommRing.{u1} (Set.Elem.{u1} α s)) (FreeCommRing.instCommRing.{u1} (Set.Elem.{u1} α s)))))) (FreeCommRing.{u1} α) (FreeCommRing.{u1} (Set.Elem.{u1} α s)) (Semiring.toNonAssocSemiring.{u1} (FreeCommRing.{u1} α) (CommSemiring.toSemiring.{u1} (FreeCommRing.{u1} α) (CommRing.toCommSemiring.{u1} (FreeCommRing.{u1} α) (FreeCommRing.instCommRing.{u1} α)))) (Semiring.toNonAssocSemiring.{u1} (FreeCommRing.{u1} (Set.Elem.{u1} α s)) (CommSemiring.toSemiring.{u1} (FreeCommRing.{u1} (Set.Elem.{u1} α s)) (CommRing.toCommSemiring.{u1} (FreeCommRing.{u1} (Set.Elem.{u1} α s)) (FreeCommRing.instCommRing.{u1} (Set.Elem.{u1} α s))))) (RingHom.instRingHomClassRingHom.{u1, u1} (FreeCommRing.{u1} α) (FreeCommRing.{u1} (Set.Elem.{u1} α s)) (Semiring.toNonAssocSemiring.{u1} (FreeCommRing.{u1} α) (CommSemiring.toSemiring.{u1} (FreeCommRing.{u1} α) (CommRing.toCommSemiring.{u1} (FreeCommRing.{u1} α) (FreeCommRing.instCommRing.{u1} α)))) (Semiring.toNonAssocSemiring.{u1} (FreeCommRing.{u1} (Set.Elem.{u1} α s)) (CommSemiring.toSemiring.{u1} (FreeCommRing.{u1} (Set.Elem.{u1} α s)) (CommRing.toCommSemiring.{u1} (FreeCommRing.{u1} (Set.Elem.{u1} α s)) (FreeCommRing.instCommRing.{u1} (Set.Elem.{u1} α s))))))))) (FreeCommRing.restriction.{u1} α s (fun (a : α) => _inst_1 a)) x)) x)
+<too large>
 Case conversion may be inaccurate. Consider using '#align free_comm_ring.map_subtype_val_restriction FreeCommRing.map_subtype_val_restrictionₓ'. -/
 theorem map_subtype_val_restriction {x} (s : Set α) [DecidablePred (· ∈ s)]
     (hxs : IsSupported x s) : map (Subtype.val : s → α) (restriction s x) = x :=

50251fd6

bump to nightly-2023-05-19-16

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

a31df521

Diff

@@ -148,7 +148,7 @@ def lift : (α → R) ≃ (FreeCommRing α →+* R) :=
 lean 3 declaration is
   forall {α : Type.{u1}} {R : Type.{u2}} [_inst_1 : CommRing.{u2} R] (f : α -> R) (x : α), Eq.{succ u2} R (coeFn.{max (succ u1) (succ u2), max (succ u1) (succ u2)} (RingHom.{u1, u2} (FreeCommRing.{u1} α) R (NonAssocRing.toNonAssocSemiring.{u1} (FreeCommRing.{u1} α) (Ring.toNonAssocRing.{u1} (FreeCommRing.{u1} α) (CommRing.toRing.{u1} (FreeCommRing.{u1} α) (FreeCommRing.instCommRing.{u1} α)))) (NonAssocRing.toNonAssocSemiring.{u2} R (Ring.toNonAssocRing.{u2} R (CommRing.toRing.{u2} R _inst_1)))) (fun (_x : RingHom.{u1, u2} (FreeCommRing.{u1} α) R (NonAssocRing.toNonAssocSemiring.{u1} (FreeCommRing.{u1} α) (Ring.toNonAssocRing.{u1} (FreeCommRing.{u1} α) (CommRing.toRing.{u1} (FreeCommRing.{u1} α) (FreeCommRing.instCommRing.{u1} α)))) (NonAssocRing.toNonAssocSemiring.{u2} R (Ring.toNonAssocRing.{u2} R (CommRing.toRing.{u2} R _inst_1)))) => (FreeCommRing.{u1} α) -> R) (RingHom.hasCoeToFun.{u1, u2} (FreeCommRing.{u1} α) R (NonAssocRing.toNonAssocSemiring.{u1} (FreeCommRing.{u1} α) (Ring.toNonAssocRing.{u1} (FreeCommRing.{u1} α) (CommRing.toRing.{u1} (FreeCommRing.{u1} α) (FreeCommRing.instCommRing.{u1} α)))) (NonAssocRing.toNonAssocSemiring.{u2} R (Ring.toNonAssocRing.{u2} R (CommRing.toRing.{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} (FreeCommRing.{u1} α) R (NonAssocRing.toNonAssocSemiring.{u1} (FreeCommRing.{u1} α) (Ring.toNonAssocRing.{u1} (FreeCommRing.{u1} α) (CommRing.toRing.{u1} (FreeCommRing.{u1} α) (FreeCommRing.instCommRing.{u1} α)))) (NonAssocRing.toNonAssocSemiring.{u2} R (Ring.toNonAssocRing.{u2} R (CommRing.toRing.{u2} R _inst_1))))) (fun (_x : Equiv.{max (succ u1) (succ u2), max (succ u1) (succ u2)} (α -> R) (RingHom.{u1, u2} (FreeCommRing.{u1} α) R (NonAssocRing.toNonAssocSemiring.{u1} (FreeCommRing.{u1} α) (Ring.toNonAssocRing.{u1} (FreeCommRing.{u1} α) (CommRing.toRing.{u1} (FreeCommRing.{u1} α) (FreeCommRing.instCommRing.{u1} α)))) (NonAssocRing.toNonAssocSemiring.{u2} R (Ring.toNonAssocRing.{u2} R (CommRing.toRing.{u2} R _inst_1))))) => (α -> R) -> (RingHom.{u1, u2} (FreeCommRing.{u1} α) R (NonAssocRing.toNonAssocSemiring.{u1} (FreeCommRing.{u1} α) (Ring.toNonAssocRing.{u1} (FreeCommRing.{u1} α) (CommRing.toRing.{u1} (FreeCommRing.{u1} α) (FreeCommRing.instCommRing.{u1} α)))) (NonAssocRing.toNonAssocSemiring.{u2} R (Ring.toNonAssocRing.{u2} R (CommRing.toRing.{u2} R _inst_1))))) (Equiv.hasCoeToFun.{max (succ u1) (succ u2), max (succ u1) (succ u2)} (α -> R) (RingHom.{u1, u2} (FreeCommRing.{u1} α) R (NonAssocRing.toNonAssocSemiring.{u1} (FreeCommRing.{u1} α) (Ring.toNonAssocRing.{u1} (FreeCommRing.{u1} α) (CommRing.toRing.{u1} (FreeCommRing.{u1} α) (FreeCommRing.instCommRing.{u1} α)))) (NonAssocRing.toNonAssocSemiring.{u2} R (Ring.toNonAssocRing.{u2} R (CommRing.toRing.{u2} R _inst_1))))) (FreeCommRing.lift.{u1, u2} α R _inst_1) f) (FreeCommRing.of.{u1} α x)) (f x)
 but is expected to have type
-  forall {α : Type.{u1}} {R : Type.{u2}} [_inst_1 : CommRing.{u2} R] (f : α -> R) (x : α), Eq.{succ u2} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : FreeCommRing.{u1} α) => R) (FreeCommRing.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} (FreeCommRing.{u1} α) R (Semiring.toNonAssocSemiring.{u1} (FreeCommRing.{u1} α) (CommSemiring.toSemiring.{u1} (FreeCommRing.{u1} α) (CommRing.toCommSemiring.{u1} (FreeCommRing.{u1} α) (FreeCommRing.instCommRing.{u1} α)))) (Semiring.toNonAssocSemiring.{u2} R (CommSemiring.toSemiring.{u2} R (CommRing.toCommSemiring.{u2} R _inst_1)))) f) (FreeCommRing.{u1} α) (fun (_x : FreeCommRing.{u1} α) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : FreeCommRing.{u1} α) => R) _x) (MulHomClass.toFunLike.{max u1 u2, u1, u2} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : α -> R) => RingHom.{u1, u2} (FreeCommRing.{u1} α) R (Semiring.toNonAssocSemiring.{u1} (FreeCommRing.{u1} α) (CommSemiring.toSemiring.{u1} (FreeCommRing.{u1} α) (CommRing.toCommSemiring.{u1} (FreeCommRing.{u1} α) (FreeCommRing.instCommRing.{u1} α)))) (Semiring.toNonAssocSemiring.{u2} R (CommSemiring.toSemiring.{u2} R (CommRing.toCommSemiring.{u2} R _inst_1)))) f) (FreeCommRing.{u1} α) R (NonUnitalNonAssocSemiring.toMul.{u1} (FreeCommRing.{u1} α) (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u1} (FreeCommRing.{u1} α) (Semiring.toNonAssocSemiring.{u1} (FreeCommRing.{u1} α) (CommSemiring.toSemiring.{u1} (FreeCommRing.{u1} α) (CommRing.toCommSemiring.{u1} (FreeCommRing.{u1} α) (FreeCommRing.instCommRing.{u1} α)))))) (NonUnitalNonAssocSemiring.toMul.{u2} R (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u2} R (Semiring.toNonAssocSemiring.{u2} R (CommSemiring.toSemiring.{u2} R (CommRing.toCommSemiring.{u2} R _inst_1))))) (NonUnitalRingHomClass.toMulHomClass.{max u1 u2, u1, u2} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : α -> R) => RingHom.{u1, u2} (FreeCommRing.{u1} α) R (Semiring.toNonAssocSemiring.{u1} (FreeCommRing.{u1} α) (CommSemiring.toSemiring.{u1} (FreeCommRing.{u1} α) (CommRing.toCommSemiring.{u1} (FreeCommRing.{u1} α) (FreeCommRing.instCommRing.{u1} α)))) (Semiring.toNonAssocSemiring.{u2} R (CommSemiring.toSemiring.{u2} R (CommRing.toCommSemiring.{u2} R _inst_1)))) f) (FreeCommRing.{u1} α) R (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u1} (FreeCommRing.{u1} α) (Semiring.toNonAssocSemiring.{u1} (FreeCommRing.{u1} α) (CommSemiring.toSemiring.{u1} (FreeCommRing.{u1} α) (CommRing.toCommSemiring.{u1} (FreeCommRing.{u1} α) (FreeCommRing.instCommRing.{u1} α))))) (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u2} R (Semiring.toNonAssocSemiring.{u2} R (CommSemiring.toSemiring.{u2} R (CommRing.toCommSemiring.{u2} R _inst_1)))) (RingHomClass.toNonUnitalRingHomClass.{max u1 u2, u1, u2} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : α -> R) => RingHom.{u1, u2} (FreeCommRing.{u1} α) R (Semiring.toNonAssocSemiring.{u1} (FreeCommRing.{u1} α) (CommSemiring.toSemiring.{u1} (FreeCommRing.{u1} α) (CommRing.toCommSemiring.{u1} (FreeCommRing.{u1} α) (FreeCommRing.instCommRing.{u1} α)))) (Semiring.toNonAssocSemiring.{u2} R (CommSemiring.toSemiring.{u2} R (CommRing.toCommSemiring.{u2} R _inst_1)))) f) (FreeCommRing.{u1} α) R (Semiring.toNonAssocSemiring.{u1} (FreeCommRing.{u1} α) (CommSemiring.toSemiring.{u1} (FreeCommRing.{u1} α) (CommRing.toCommSemiring.{u1} (FreeCommRing.{u1} α) (FreeCommRing.instCommRing.{u1} α)))) (Semiring.toNonAssocSemiring.{u2} R (CommSemiring.toSemiring.{u2} R (CommRing.toCommSemiring.{u2} R _inst_1))) (RingHom.instRingHomClassRingHom.{u1, u2} (FreeCommRing.{u1} α) R (Semiring.toNonAssocSemiring.{u1} (FreeCommRing.{u1} α) (CommSemiring.toSemiring.{u1} (FreeCommRing.{u1} α) (CommRing.toCommSemiring.{u1} (FreeCommRing.{u1} α) (FreeCommRing.instCommRing.{u1} α)))) (Semiring.toNonAssocSemiring.{u2} R (CommSemiring.toSemiring.{u2} R (CommRing.toCommSemiring.{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} (FreeCommRing.{u1} α) R (Semiring.toNonAssocSemiring.{u1} (FreeCommRing.{u1} α) (CommSemiring.toSemiring.{u1} (FreeCommRing.{u1} α) (CommRing.toCommSemiring.{u1} (FreeCommRing.{u1} α) (FreeCommRing.instCommRing.{u1} α)))) (Semiring.toNonAssocSemiring.{u2} R (CommSemiring.toSemiring.{u2} R (CommRing.toCommSemiring.{u2} R _inst_1))))) (α -> R) (fun (_x : α -> R) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : α -> R) => RingHom.{u1, u2} (FreeCommRing.{u1} α) R (Semiring.toNonAssocSemiring.{u1} (FreeCommRing.{u1} α) (CommSemiring.toSemiring.{u1} (FreeCommRing.{u1} α) (CommRing.toCommSemiring.{u1} (FreeCommRing.{u1} α) (FreeCommRing.instCommRing.{u1} α)))) (Semiring.toNonAssocSemiring.{u2} R (CommSemiring.toSemiring.{u2} R (CommRing.toCommSemiring.{u2} R _inst_1)))) _x) (Equiv.instFunLikeEquiv.{max (succ u2) (succ u1), max (succ u2) (succ u1)} (α -> R) (RingHom.{u1, u2} (FreeCommRing.{u1} α) R (Semiring.toNonAssocSemiring.{u1} (FreeCommRing.{u1} α) (CommSemiring.toSemiring.{u1} (FreeCommRing.{u1} α) (CommRing.toCommSemiring.{u1} (FreeCommRing.{u1} α) (FreeCommRing.instCommRing.{u1} α)))) (Semiring.toNonAssocSemiring.{u2} R (CommSemiring.toSemiring.{u2} R (CommRing.toCommSemiring.{u2} R _inst_1))))) (FreeCommRing.lift.{u1, u2} α R _inst_1) f) (FreeCommRing.of.{u1} α x)) (f x)
+  forall {α : Type.{u1}} {R : Type.{u2}} [_inst_1 : CommRing.{u2} R] (f : α -> R) (x : α), Eq.{succ u2} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2397 : FreeCommRing.{u1} α) => R) (FreeCommRing.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} (FreeCommRing.{u1} α) R (Semiring.toNonAssocSemiring.{u1} (FreeCommRing.{u1} α) (CommSemiring.toSemiring.{u1} (FreeCommRing.{u1} α) (CommRing.toCommSemiring.{u1} (FreeCommRing.{u1} α) (FreeCommRing.instCommRing.{u1} α)))) (Semiring.toNonAssocSemiring.{u2} R (CommSemiring.toSemiring.{u2} R (CommRing.toCommSemiring.{u2} R _inst_1)))) f) (FreeCommRing.{u1} α) (fun (_x : FreeCommRing.{u1} α) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2397 : FreeCommRing.{u1} α) => R) _x) (MulHomClass.toFunLike.{max u1 u2, u1, u2} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : α -> R) => RingHom.{u1, u2} (FreeCommRing.{u1} α) R (Semiring.toNonAssocSemiring.{u1} (FreeCommRing.{u1} α) (CommSemiring.toSemiring.{u1} (FreeCommRing.{u1} α) (CommRing.toCommSemiring.{u1} (FreeCommRing.{u1} α) (FreeCommRing.instCommRing.{u1} α)))) (Semiring.toNonAssocSemiring.{u2} R (CommSemiring.toSemiring.{u2} R (CommRing.toCommSemiring.{u2} R _inst_1)))) f) (FreeCommRing.{u1} α) R (NonUnitalNonAssocSemiring.toMul.{u1} (FreeCommRing.{u1} α) (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u1} (FreeCommRing.{u1} α) (Semiring.toNonAssocSemiring.{u1} (FreeCommRing.{u1} α) (CommSemiring.toSemiring.{u1} (FreeCommRing.{u1} α) (CommRing.toCommSemiring.{u1} (FreeCommRing.{u1} α) (FreeCommRing.instCommRing.{u1} α)))))) (NonUnitalNonAssocSemiring.toMul.{u2} R (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u2} R (Semiring.toNonAssocSemiring.{u2} R (CommSemiring.toSemiring.{u2} R (CommRing.toCommSemiring.{u2} R _inst_1))))) (NonUnitalRingHomClass.toMulHomClass.{max u1 u2, u1, u2} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : α -> R) => RingHom.{u1, u2} (FreeCommRing.{u1} α) R (Semiring.toNonAssocSemiring.{u1} (FreeCommRing.{u1} α) (CommSemiring.toSemiring.{u1} (FreeCommRing.{u1} α) (CommRing.toCommSemiring.{u1} (FreeCommRing.{u1} α) (FreeCommRing.instCommRing.{u1} α)))) (Semiring.toNonAssocSemiring.{u2} R (CommSemiring.toSemiring.{u2} R (CommRing.toCommSemiring.{u2} R _inst_1)))) f) (FreeCommRing.{u1} α) R (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u1} (FreeCommRing.{u1} α) (Semiring.toNonAssocSemiring.{u1} (FreeCommRing.{u1} α) (CommSemiring.toSemiring.{u1} (FreeCommRing.{u1} α) (CommRing.toCommSemiring.{u1} (FreeCommRing.{u1} α) (FreeCommRing.instCommRing.{u1} α))))) (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u2} R (Semiring.toNonAssocSemiring.{u2} R (CommSemiring.toSemiring.{u2} R (CommRing.toCommSemiring.{u2} R _inst_1)))) (RingHomClass.toNonUnitalRingHomClass.{max u1 u2, u1, u2} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : α -> R) => RingHom.{u1, u2} (FreeCommRing.{u1} α) R (Semiring.toNonAssocSemiring.{u1} (FreeCommRing.{u1} α) (CommSemiring.toSemiring.{u1} (FreeCommRing.{u1} α) (CommRing.toCommSemiring.{u1} (FreeCommRing.{u1} α) (FreeCommRing.instCommRing.{u1} α)))) (Semiring.toNonAssocSemiring.{u2} R (CommSemiring.toSemiring.{u2} R (CommRing.toCommSemiring.{u2} R _inst_1)))) f) (FreeCommRing.{u1} α) R (Semiring.toNonAssocSemiring.{u1} (FreeCommRing.{u1} α) (CommSemiring.toSemiring.{u1} (FreeCommRing.{u1} α) (CommRing.toCommSemiring.{u1} (FreeCommRing.{u1} α) (FreeCommRing.instCommRing.{u1} α)))) (Semiring.toNonAssocSemiring.{u2} R (CommSemiring.toSemiring.{u2} R (CommRing.toCommSemiring.{u2} R _inst_1))) (RingHom.instRingHomClassRingHom.{u1, u2} (FreeCommRing.{u1} α) R (Semiring.toNonAssocSemiring.{u1} (FreeCommRing.{u1} α) (CommSemiring.toSemiring.{u1} (FreeCommRing.{u1} α) (CommRing.toCommSemiring.{u1} (FreeCommRing.{u1} α) (FreeCommRing.instCommRing.{u1} α)))) (Semiring.toNonAssocSemiring.{u2} R (CommSemiring.toSemiring.{u2} R (CommRing.toCommSemiring.{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} (FreeCommRing.{u1} α) R (Semiring.toNonAssocSemiring.{u1} (FreeCommRing.{u1} α) (CommSemiring.toSemiring.{u1} (FreeCommRing.{u1} α) (CommRing.toCommSemiring.{u1} (FreeCommRing.{u1} α) (FreeCommRing.instCommRing.{u1} α)))) (Semiring.toNonAssocSemiring.{u2} R (CommSemiring.toSemiring.{u2} R (CommRing.toCommSemiring.{u2} R _inst_1))))) (α -> R) (fun (_x : α -> R) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : α -> R) => RingHom.{u1, u2} (FreeCommRing.{u1} α) R (Semiring.toNonAssocSemiring.{u1} (FreeCommRing.{u1} α) (CommSemiring.toSemiring.{u1} (FreeCommRing.{u1} α) (CommRing.toCommSemiring.{u1} (FreeCommRing.{u1} α) (FreeCommRing.instCommRing.{u1} α)))) (Semiring.toNonAssocSemiring.{u2} R (CommSemiring.toSemiring.{u2} R (CommRing.toCommSemiring.{u2} R _inst_1)))) _x) (Equiv.instFunLikeEquiv.{max (succ u2) (succ u1), max (succ u2) (succ u1)} (α -> R) (RingHom.{u1, u2} (FreeCommRing.{u1} α) R (Semiring.toNonAssocSemiring.{u1} (FreeCommRing.{u1} α) (CommSemiring.toSemiring.{u1} (FreeCommRing.{u1} α) (CommRing.toCommSemiring.{u1} (FreeCommRing.{u1} α) (FreeCommRing.instCommRing.{u1} α)))) (Semiring.toNonAssocSemiring.{u2} R (CommSemiring.toSemiring.{u2} R (CommRing.toCommSemiring.{u2} R _inst_1))))) (FreeCommRing.lift.{u1, u2} α R _inst_1) f) (FreeCommRing.of.{u1} α x)) (f x)
 Case conversion may be inaccurate. Consider using '#align free_comm_ring.lift_of FreeCommRing.lift_ofₓ'. -/
 @[simp]
 theorem lift_of (x : α) : lift f (of x) = f x :=
@@ -169,7 +169,7 @@ theorem lift_comp_of (f : FreeCommRing α →+* R) : lift (f ∘ of) = f :=
 lean 3 declaration is
   forall {α : Type.{u1}} {R : Type.{u2}} [_inst_1 : CommRing.{u2} R] {{f : RingHom.{u1, u2} (FreeCommRing.{u1} α) R (NonAssocRing.toNonAssocSemiring.{u1} (FreeCommRing.{u1} α) (Ring.toNonAssocRing.{u1} (FreeCommRing.{u1} α) (CommRing.toRing.{u1} (FreeCommRing.{u1} α) (FreeCommRing.instCommRing.{u1} α)))) (NonAssocRing.toNonAssocSemiring.{u2} R (Ring.toNonAssocRing.{u2} R (CommRing.toRing.{u2} R _inst_1)))}} {{g : RingHom.{u1, u2} (FreeCommRing.{u1} α) R (NonAssocRing.toNonAssocSemiring.{u1} (FreeCommRing.{u1} α) (Ring.toNonAssocRing.{u1} (FreeCommRing.{u1} α) (CommRing.toRing.{u1} (FreeCommRing.{u1} α) (FreeCommRing.instCommRing.{u1} α)))) (NonAssocRing.toNonAssocSemiring.{u2} R (Ring.toNonAssocRing.{u2} R (CommRing.toRing.{u2} R _inst_1)))}}, (forall (x : α), Eq.{succ u2} R (coeFn.{max (succ u1) (succ u2), max (succ u1) (succ u2)} (RingHom.{u1, u2} (FreeCommRing.{u1} α) R (NonAssocRing.toNonAssocSemiring.{u1} (FreeCommRing.{u1} α) (Ring.toNonAssocRing.{u1} (FreeCommRing.{u1} α) (CommRing.toRing.{u1} (FreeCommRing.{u1} α) (FreeCommRing.instCommRing.{u1} α)))) (NonAssocRing.toNonAssocSemiring.{u2} R (Ring.toNonAssocRing.{u2} R (CommRing.toRing.{u2} R _inst_1)))) (fun (_x : RingHom.{u1, u2} (FreeCommRing.{u1} α) R (NonAssocRing.toNonAssocSemiring.{u1} (FreeCommRing.{u1} α) (Ring.toNonAssocRing.{u1} (FreeCommRing.{u1} α) (CommRing.toRing.{u1} (FreeCommRing.{u1} α) (FreeCommRing.instCommRing.{u1} α)))) (NonAssocRing.toNonAssocSemiring.{u2} R (Ring.toNonAssocRing.{u2} R (CommRing.toRing.{u2} R _inst_1)))) => (FreeCommRing.{u1} α) -> R) (RingHom.hasCoeToFun.{u1, u2} (FreeCommRing.{u1} α) R (NonAssocRing.toNonAssocSemiring.{u1} (FreeCommRing.{u1} α) (Ring.toNonAssocRing.{u1} (FreeCommRing.{u1} α) (CommRing.toRing.{u1} (FreeCommRing.{u1} α) (FreeCommRing.instCommRing.{u1} α)))) (NonAssocRing.toNonAssocSemiring.{u2} R (Ring.toNonAssocRing.{u2} R (CommRing.toRing.{u2} R _inst_1)))) f (FreeCommRing.of.{u1} α x)) (coeFn.{max (succ u1) (succ u2), max (succ u1) (succ u2)} (RingHom.{u1, u2} (FreeCommRing.{u1} α) R (NonAssocRing.toNonAssocSemiring.{u1} (FreeCommRing.{u1} α) (Ring.toNonAssocRing.{u1} (FreeCommRing.{u1} α) (CommRing.toRing.{u1} (FreeCommRing.{u1} α) (FreeCommRing.instCommRing.{u1} α)))) (NonAssocRing.toNonAssocSemiring.{u2} R (Ring.toNonAssocRing.{u2} R (CommRing.toRing.{u2} R _inst_1)))) (fun (_x : RingHom.{u1, u2} (FreeCommRing.{u1} α) R (NonAssocRing.toNonAssocSemiring.{u1} (FreeCommRing.{u1} α) (Ring.toNonAssocRing.{u1} (FreeCommRing.{u1} α) (CommRing.toRing.{u1} (FreeCommRing.{u1} α) (FreeCommRing.instCommRing.{u1} α)))) (NonAssocRing.toNonAssocSemiring.{u2} R (Ring.toNonAssocRing.{u2} R (CommRing.toRing.{u2} R _inst_1)))) => (FreeCommRing.{u1} α) -> R) (RingHom.hasCoeToFun.{u1, u2} (FreeCommRing.{u1} α) R (NonAssocRing.toNonAssocSemiring.{u1} (FreeCommRing.{u1} α) (Ring.toNonAssocRing.{u1} (FreeCommRing.{u1} α) (CommRing.toRing.{u1} (FreeCommRing.{u1} α) (FreeCommRing.instCommRing.{u1} α)))) (NonAssocRing.toNonAssocSemiring.{u2} R (Ring.toNonAssocRing.{u2} R (CommRing.toRing.{u2} R _inst_1)))) g (FreeCommRing.of.{u1} α x))) -> (Eq.{max (succ u1) (succ u2)} (RingHom.{u1, u2} (FreeCommRing.{u1} α) R (NonAssocRing.toNonAssocSemiring.{u1} (FreeCommRing.{u1} α) (Ring.toNonAssocRing.{u1} (FreeCommRing.{u1} α) (CommRing.toRing.{u1} (FreeCommRing.{u1} α) (FreeCommRing.instCommRing.{u1} α)))) (NonAssocRing.toNonAssocSemiring.{u2} R (Ring.toNonAssocRing.{u2} R (CommRing.toRing.{u2} R _inst_1)))) f g)
 but is expected to have type
-  forall {α : Type.{u1}} {R : Type.{u2}} [_inst_1 : CommRing.{u2} R] {{f : RingHom.{u1, u2} (FreeCommRing.{u1} α) R (Semiring.toNonAssocSemiring.{u1} (FreeCommRing.{u1} α) (CommSemiring.toSemiring.{u1} (FreeCommRing.{u1} α) (CommRing.toCommSemiring.{u1} (FreeCommRing.{u1} α) (FreeCommRing.instCommRing.{u1} α)))) (Semiring.toNonAssocSemiring.{u2} R (CommSemiring.toSemiring.{u2} R (CommRing.toCommSemiring.{u2} R _inst_1)))}} {{g : RingHom.{u1, u2} (FreeCommRing.{u1} α) R (Semiring.toNonAssocSemiring.{u1} (FreeCommRing.{u1} α) (CommSemiring.toSemiring.{u1} (FreeCommRing.{u1} α) (CommRing.toCommSemiring.{u1} (FreeCommRing.{u1} α) (FreeCommRing.instCommRing.{u1} α)))) (Semiring.toNonAssocSemiring.{u2} R (CommSemiring.toSemiring.{u2} R (CommRing.toCommSemiring.{u2} R _inst_1)))}}, (forall (x : α), Eq.{succ u2} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : FreeCommRing.{u1} α) => R) (FreeCommRing.of.{u1} α x)) (FunLike.coe.{max (succ u1) (succ u2), succ u1, succ u2} (RingHom.{u1, u2} (FreeCommRing.{u1} α) R (Semiring.toNonAssocSemiring.{u1} (FreeCommRing.{u1} α) (CommSemiring.toSemiring.{u1} (FreeCommRing.{u1} α) (CommRing.toCommSemiring.{u1} (FreeCommRing.{u1} α) (FreeCommRing.instCommRing.{u1} α)))) (Semiring.toNonAssocSemiring.{u2} R (CommSemiring.toSemiring.{u2} R (CommRing.toCommSemiring.{u2} R _inst_1)))) (FreeCommRing.{u1} α) (fun (_x : FreeCommRing.{u1} α) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : FreeCommRing.{u1} α) => R) _x) (MulHomClass.toFunLike.{max u1 u2, u1, u2} (RingHom.{u1, u2} (FreeCommRing.{u1} α) R (Semiring.toNonAssocSemiring.{u1} (FreeCommRing.{u1} α) (CommSemiring.toSemiring.{u1} (FreeCommRing.{u1} α) (CommRing.toCommSemiring.{u1} (FreeCommRing.{u1} α) (FreeCommRing.instCommRing.{u1} α)))) (Semiring.toNonAssocSemiring.{u2} R (CommSemiring.toSemiring.{u2} R (CommRing.toCommSemiring.{u2} R _inst_1)))) (FreeCommRing.{u1} α) R (NonUnitalNonAssocSemiring.toMul.{u1} (FreeCommRing.{u1} α) (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u1} (FreeCommRing.{u1} α) (Semiring.toNonAssocSemiring.{u1} (FreeCommRing.{u1} α) (CommSemiring.toSemiring.{u1} (FreeCommRing.{u1} α) (CommRing.toCommSemiring.{u1} (FreeCommRing.{u1} α) (FreeCommRing.instCommRing.{u1} α)))))) (NonUnitalNonAssocSemiring.toMul.{u2} R (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u2} R (Semiring.toNonAssocSemiring.{u2} R (CommSemiring.toSemiring.{u2} R (CommRing.toCommSemiring.{u2} R _inst_1))))) (NonUnitalRingHomClass.toMulHomClass.{max u1 u2, u1, u2} (RingHom.{u1, u2} (FreeCommRing.{u1} α) R (Semiring.toNonAssocSemiring.{u1} (FreeCommRing.{u1} α) (CommSemiring.toSemiring.{u1} (FreeCommRing.{u1} α) (CommRing.toCommSemiring.{u1} (FreeCommRing.{u1} α) (FreeCommRing.instCommRing.{u1} α)))) (Semiring.toNonAssocSemiring.{u2} R (CommSemiring.toSemiring.{u2} R (CommRing.toCommSemiring.{u2} R _inst_1)))) (FreeCommRing.{u1} α) R (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u1} (FreeCommRing.{u1} α) (Semiring.toNonAssocSemiring.{u1} (FreeCommRing.{u1} α) (CommSemiring.toSemiring.{u1} (FreeCommRing.{u1} α) (CommRing.toCommSemiring.{u1} (FreeCommRing.{u1} α) (FreeCommRing.instCommRing.{u1} α))))) (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u2} R (Semiring.toNonAssocSemiring.{u2} R (CommSemiring.toSemiring.{u2} R (CommRing.toCommSemiring.{u2} R _inst_1)))) (RingHomClass.toNonUnitalRingHomClass.{max u1 u2, u1, u2} (RingHom.{u1, u2} (FreeCommRing.{u1} α) R (Semiring.toNonAssocSemiring.{u1} (FreeCommRing.{u1} α) (CommSemiring.toSemiring.{u1} (FreeCommRing.{u1} α) (CommRing.toCommSemiring.{u1} (FreeCommRing.{u1} α) (FreeCommRing.instCommRing.{u1} α)))) (Semiring.toNonAssocSemiring.{u2} R (CommSemiring.toSemiring.{u2} R (CommRing.toCommSemiring.{u2} R _inst_1)))) (FreeCommRing.{u1} α) R (Semiring.toNonAssocSemiring.{u1} (FreeCommRing.{u1} α) (CommSemiring.toSemiring.{u1} (FreeCommRing.{u1} α) (CommRing.toCommSemiring.{u1} (FreeCommRing.{u1} α) (FreeCommRing.instCommRing.{u1} α)))) (Semiring.toNonAssocSemiring.{u2} R (CommSemiring.toSemiring.{u2} R (CommRing.toCommSemiring.{u2} R _inst_1))) (RingHom.instRingHomClassRingHom.{u1, u2} (FreeCommRing.{u1} α) R (Semiring.toNonAssocSemiring.{u1} (FreeCommRing.{u1} α) (CommSemiring.toSemiring.{u1} (FreeCommRing.{u1} α) (CommRing.toCommSemiring.{u1} (FreeCommRing.{u1} α) (FreeCommRing.instCommRing.{u1} α)))) (Semiring.toNonAssocSemiring.{u2} R (CommSemiring.toSemiring.{u2} R (CommRing.toCommSemiring.{u2} R _inst_1))))))) f (FreeCommRing.of.{u1} α x)) (FunLike.coe.{max (succ u1) (succ u2), succ u1, succ u2} (RingHom.{u1, u2} (FreeCommRing.{u1} α) R (Semiring.toNonAssocSemiring.{u1} (FreeCommRing.{u1} α) (CommSemiring.toSemiring.{u1} (FreeCommRing.{u1} α) (CommRing.toCommSemiring.{u1} (FreeCommRing.{u1} α) (FreeCommRing.instCommRing.{u1} α)))) (Semiring.toNonAssocSemiring.{u2} R (CommSemiring.toSemiring.{u2} R (CommRing.toCommSemiring.{u2} R _inst_1)))) (FreeCommRing.{u1} α) (fun (_x : FreeCommRing.{u1} α) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : FreeCommRing.{u1} α) => R) _x) (MulHomClass.toFunLike.{max u1 u2, u1, u2} (RingHom.{u1, u2} (FreeCommRing.{u1} α) R (Semiring.toNonAssocSemiring.{u1} (FreeCommRing.{u1} α) (CommSemiring.toSemiring.{u1} (FreeCommRing.{u1} α) (CommRing.toCommSemiring.{u1} (FreeCommRing.{u1} α) (FreeCommRing.instCommRing.{u1} α)))) (Semiring.toNonAssocSemiring.{u2} R (CommSemiring.toSemiring.{u2} R (CommRing.toCommSemiring.{u2} R _inst_1)))) (FreeCommRing.{u1} α) R (NonUnitalNonAssocSemiring.toMul.{u1} (FreeCommRing.{u1} α) (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u1} (FreeCommRing.{u1} α) (Semiring.toNonAssocSemiring.{u1} (FreeCommRing.{u1} α) (CommSemiring.toSemiring.{u1} (FreeCommRing.{u1} α) (CommRing.toCommSemiring.{u1} (FreeCommRing.{u1} α) (FreeCommRing.instCommRing.{u1} α)))))) (NonUnitalNonAssocSemiring.toMul.{u2} R (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u2} R (Semiring.toNonAssocSemiring.{u2} R (CommSemiring.toSemiring.{u2} R (CommRing.toCommSemiring.{u2} R _inst_1))))) (NonUnitalRingHomClass.toMulHomClass.{max u1 u2, u1, u2} (RingHom.{u1, u2} (FreeCommRing.{u1} α) R (Semiring.toNonAssocSemiring.{u1} (FreeCommRing.{u1} α) (CommSemiring.toSemiring.{u1} (FreeCommRing.{u1} α) (CommRing.toCommSemiring.{u1} (FreeCommRing.{u1} α) (FreeCommRing.instCommRing.{u1} α)))) (Semiring.toNonAssocSemiring.{u2} R (CommSemiring.toSemiring.{u2} R (CommRing.toCommSemiring.{u2} R _inst_1)))) (FreeCommRing.{u1} α) R (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u1} (FreeCommRing.{u1} α) (Semiring.toNonAssocSemiring.{u1} (FreeCommRing.{u1} α) (CommSemiring.toSemiring.{u1} (FreeCommRing.{u1} α) (CommRing.toCommSemiring.{u1} (FreeCommRing.{u1} α) (FreeCommRing.instCommRing.{u1} α))))) (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u2} R (Semiring.toNonAssocSemiring.{u2} R (CommSemiring.toSemiring.{u2} R (CommRing.toCommSemiring.{u2} R _inst_1)))) (RingHomClass.toNonUnitalRingHomClass.{max u1 u2, u1, u2} (RingHom.{u1, u2} (FreeCommRing.{u1} α) R (Semiring.toNonAssocSemiring.{u1} (FreeCommRing.{u1} α) (CommSemiring.toSemiring.{u1} (FreeCommRing.{u1} α) (CommRing.toCommSemiring.{u1} (FreeCommRing.{u1} α) (FreeCommRing.instCommRing.{u1} α)))) (Semiring.toNonAssocSemiring.{u2} R (CommSemiring.toSemiring.{u2} R (CommRing.toCommSemiring.{u2} R _inst_1)))) (FreeCommRing.{u1} α) R (Semiring.toNonAssocSemiring.{u1} (FreeCommRing.{u1} α) (CommSemiring.toSemiring.{u1} (FreeCommRing.{u1} α) (CommRing.toCommSemiring.{u1} (FreeCommRing.{u1} α) (FreeCommRing.instCommRing.{u1} α)))) (Semiring.toNonAssocSemiring.{u2} R (CommSemiring.toSemiring.{u2} R (CommRing.toCommSemiring.{u2} R _inst_1))) (RingHom.instRingHomClassRingHom.{u1, u2} (FreeCommRing.{u1} α) R (Semiring.toNonAssocSemiring.{u1} (FreeCommRing.{u1} α) (CommSemiring.toSemiring.{u1} (FreeCommRing.{u1} α) (CommRing.toCommSemiring.{u1} (FreeCommRing.{u1} α) (FreeCommRing.instCommRing.{u1} α)))) (Semiring.toNonAssocSemiring.{u2} R (CommSemiring.toSemiring.{u2} R (CommRing.toCommSemiring.{u2} R _inst_1))))))) g (FreeCommRing.of.{u1} α x))) -> (Eq.{max (succ u1) (succ u2)} (RingHom.{u1, u2} (FreeCommRing.{u1} α) R (Semiring.toNonAssocSemiring.{u1} (FreeCommRing.{u1} α) (CommSemiring.toSemiring.{u1} (FreeCommRing.{u1} α) (CommRing.toCommSemiring.{u1} (FreeCommRing.{u1} α) (FreeCommRing.instCommRing.{u1} α)))) (Semiring.toNonAssocSemiring.{u2} R (CommSemiring.toSemiring.{u2} R (CommRing.toCommSemiring.{u2} R _inst_1)))) f g)
+  forall {α : Type.{u1}} {R : Type.{u2}} [_inst_1 : CommRing.{u2} R] {{f : RingHom.{u1, u2} (FreeCommRing.{u1} α) R (Semiring.toNonAssocSemiring.{u1} (FreeCommRing.{u1} α) (CommSemiring.toSemiring.{u1} (FreeCommRing.{u1} α) (CommRing.toCommSemiring.{u1} (FreeCommRing.{u1} α) (FreeCommRing.instCommRing.{u1} α)))) (Semiring.toNonAssocSemiring.{u2} R (CommSemiring.toSemiring.{u2} R (CommRing.toCommSemiring.{u2} R _inst_1)))}} {{g : RingHom.{u1, u2} (FreeCommRing.{u1} α) R (Semiring.toNonAssocSemiring.{u1} (FreeCommRing.{u1} α) (CommSemiring.toSemiring.{u1} (FreeCommRing.{u1} α) (CommRing.toCommSemiring.{u1} (FreeCommRing.{u1} α) (FreeCommRing.instCommRing.{u1} α)))) (Semiring.toNonAssocSemiring.{u2} R (CommSemiring.toSemiring.{u2} R (CommRing.toCommSemiring.{u2} R _inst_1)))}}, (forall (x : α), Eq.{succ u2} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2397 : FreeCommRing.{u1} α) => R) (FreeCommRing.of.{u1} α x)) (FunLike.coe.{max (succ u1) (succ u2), succ u1, succ u2} (RingHom.{u1, u2} (FreeCommRing.{u1} α) R (Semiring.toNonAssocSemiring.{u1} (FreeCommRing.{u1} α) (CommSemiring.toSemiring.{u1} (FreeCommRing.{u1} α) (CommRing.toCommSemiring.{u1} (FreeCommRing.{u1} α) (FreeCommRing.instCommRing.{u1} α)))) (Semiring.toNonAssocSemiring.{u2} R (CommSemiring.toSemiring.{u2} R (CommRing.toCommSemiring.{u2} R _inst_1)))) (FreeCommRing.{u1} α) (fun (_x : FreeCommRing.{u1} α) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2397 : FreeCommRing.{u1} α) => R) _x) (MulHomClass.toFunLike.{max u1 u2, u1, u2} (RingHom.{u1, u2} (FreeCommRing.{u1} α) R (Semiring.toNonAssocSemiring.{u1} (FreeCommRing.{u1} α) (CommSemiring.toSemiring.{u1} (FreeCommRing.{u1} α) (CommRing.toCommSemiring.{u1} (FreeCommRing.{u1} α) (FreeCommRing.instCommRing.{u1} α)))) (Semiring.toNonAssocSemiring.{u2} R (CommSemiring.toSemiring.{u2} R (CommRing.toCommSemiring.{u2} R _inst_1)))) (FreeCommRing.{u1} α) R (NonUnitalNonAssocSemiring.toMul.{u1} (FreeCommRing.{u1} α) (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u1} (FreeCommRing.{u1} α) (Semiring.toNonAssocSemiring.{u1} (FreeCommRing.{u1} α) (CommSemiring.toSemiring.{u1} (FreeCommRing.{u1} α) (CommRing.toCommSemiring.{u1} (FreeCommRing.{u1} α) (FreeCommRing.instCommRing.{u1} α)))))) (NonUnitalNonAssocSemiring.toMul.{u2} R (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u2} R (Semiring.toNonAssocSemiring.{u2} R (CommSemiring.toSemiring.{u2} R (CommRing.toCommSemiring.{u2} R _inst_1))))) (NonUnitalRingHomClass.toMulHomClass.{max u1 u2, u1, u2} (RingHom.{u1, u2} (FreeCommRing.{u1} α) R (Semiring.toNonAssocSemiring.{u1} (FreeCommRing.{u1} α) (CommSemiring.toSemiring.{u1} (FreeCommRing.{u1} α) (CommRing.toCommSemiring.{u1} (FreeCommRing.{u1} α) (FreeCommRing.instCommRing.{u1} α)))) (Semiring.toNonAssocSemiring.{u2} R (CommSemiring.toSemiring.{u2} R (CommRing.toCommSemiring.{u2} R _inst_1)))) (FreeCommRing.{u1} α) R (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u1} (FreeCommRing.{u1} α) (Semiring.toNonAssocSemiring.{u1} (FreeCommRing.{u1} α) (CommSemiring.toSemiring.{u1} (FreeCommRing.{u1} α) (CommRing.toCommSemiring.{u1} (FreeCommRing.{u1} α) (FreeCommRing.instCommRing.{u1} α))))) (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u2} R (Semiring.toNonAssocSemiring.{u2} R (CommSemiring.toSemiring.{u2} R (CommRing.toCommSemiring.{u2} R _inst_1)))) (RingHomClass.toNonUnitalRingHomClass.{max u1 u2, u1, u2} (RingHom.{u1, u2} (FreeCommRing.{u1} α) R (Semiring.toNonAssocSemiring.{u1} (FreeCommRing.{u1} α) (CommSemiring.toSemiring.{u1} (FreeCommRing.{u1} α) (CommRing.toCommSemiring.{u1} (FreeCommRing.{u1} α) (FreeCommRing.instCommRing.{u1} α)))) (Semiring.toNonAssocSemiring.{u2} R (CommSemiring.toSemiring.{u2} R (CommRing.toCommSemiring.{u2} R _inst_1)))) (FreeCommRing.{u1} α) R (Semiring.toNonAssocSemiring.{u1} (FreeCommRing.{u1} α) (CommSemiring.toSemiring.{u1} (FreeCommRing.{u1} α) (CommRing.toCommSemiring.{u1} (FreeCommRing.{u1} α) (FreeCommRing.instCommRing.{u1} α)))) (Semiring.toNonAssocSemiring.{u2} R (CommSemiring.toSemiring.{u2} R (CommRing.toCommSemiring.{u2} R _inst_1))) (RingHom.instRingHomClassRingHom.{u1, u2} (FreeCommRing.{u1} α) R (Semiring.toNonAssocSemiring.{u1} (FreeCommRing.{u1} α) (CommSemiring.toSemiring.{u1} (FreeCommRing.{u1} α) (CommRing.toCommSemiring.{u1} (FreeCommRing.{u1} α) (FreeCommRing.instCommRing.{u1} α)))) (Semiring.toNonAssocSemiring.{u2} R (CommSemiring.toSemiring.{u2} R (CommRing.toCommSemiring.{u2} R _inst_1))))))) f (FreeCommRing.of.{u1} α x)) (FunLike.coe.{max (succ u1) (succ u2), succ u1, succ u2} (RingHom.{u1, u2} (FreeCommRing.{u1} α) R (Semiring.toNonAssocSemiring.{u1} (FreeCommRing.{u1} α) (CommSemiring.toSemiring.{u1} (FreeCommRing.{u1} α) (CommRing.toCommSemiring.{u1} (FreeCommRing.{u1} α) (FreeCommRing.instCommRing.{u1} α)))) (Semiring.toNonAssocSemiring.{u2} R (CommSemiring.toSemiring.{u2} R (CommRing.toCommSemiring.{u2} R _inst_1)))) (FreeCommRing.{u1} α) (fun (_x : FreeCommRing.{u1} α) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2397 : FreeCommRing.{u1} α) => R) _x) (MulHomClass.toFunLike.{max u1 u2, u1, u2} (RingHom.{u1, u2} (FreeCommRing.{u1} α) R (Semiring.toNonAssocSemiring.{u1} (FreeCommRing.{u1} α) (CommSemiring.toSemiring.{u1} (FreeCommRing.{u1} α) (CommRing.toCommSemiring.{u1} (FreeCommRing.{u1} α) (FreeCommRing.instCommRing.{u1} α)))) (Semiring.toNonAssocSemiring.{u2} R (CommSemiring.toSemiring.{u2} R (CommRing.toCommSemiring.{u2} R _inst_1)))) (FreeCommRing.{u1} α) R (NonUnitalNonAssocSemiring.toMul.{u1} (FreeCommRing.{u1} α) (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u1} (FreeCommRing.{u1} α) (Semiring.toNonAssocSemiring.{u1} (FreeCommRing.{u1} α) (CommSemiring.toSemiring.{u1} (FreeCommRing.{u1} α) (CommRing.toCommSemiring.{u1} (FreeCommRing.{u1} α) (FreeCommRing.instCommRing.{u1} α)))))) (NonUnitalNonAssocSemiring.toMul.{u2} R (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u2} R (Semiring.toNonAssocSemiring.{u2} R (CommSemiring.toSemiring.{u2} R (CommRing.toCommSemiring.{u2} R _inst_1))))) (NonUnitalRingHomClass.toMulHomClass.{max u1 u2, u1, u2} (RingHom.{u1, u2} (FreeCommRing.{u1} α) R (Semiring.toNonAssocSemiring.{u1} (FreeCommRing.{u1} α) (CommSemiring.toSemiring.{u1} (FreeCommRing.{u1} α) (CommRing.toCommSemiring.{u1} (FreeCommRing.{u1} α) (FreeCommRing.instCommRing.{u1} α)))) (Semiring.toNonAssocSemiring.{u2} R (CommSemiring.toSemiring.{u2} R (CommRing.toCommSemiring.{u2} R _inst_1)))) (FreeCommRing.{u1} α) R (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u1} (FreeCommRing.{u1} α) (Semiring.toNonAssocSemiring.{u1} (FreeCommRing.{u1} α) (CommSemiring.toSemiring.{u1} (FreeCommRing.{u1} α) (CommRing.toCommSemiring.{u1} (FreeCommRing.{u1} α) (FreeCommRing.instCommRing.{u1} α))))) (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u2} R (Semiring.toNonAssocSemiring.{u2} R (CommSemiring.toSemiring.{u2} R (CommRing.toCommSemiring.{u2} R _inst_1)))) (RingHomClass.toNonUnitalRingHomClass.{max u1 u2, u1, u2} (RingHom.{u1, u2} (FreeCommRing.{u1} α) R (Semiring.toNonAssocSemiring.{u1} (FreeCommRing.{u1} α) (CommSemiring.toSemiring.{u1} (FreeCommRing.{u1} α) (CommRing.toCommSemiring.{u1} (FreeCommRing.{u1} α) (FreeCommRing.instCommRing.{u1} α)))) (Semiring.toNonAssocSemiring.{u2} R (CommSemiring.toSemiring.{u2} R (CommRing.toCommSemiring.{u2} R _inst_1)))) (FreeCommRing.{u1} α) R (Semiring.toNonAssocSemiring.{u1} (FreeCommRing.{u1} α) (CommSemiring.toSemiring.{u1} (FreeCommRing.{u1} α) (CommRing.toCommSemiring.{u1} (FreeCommRing.{u1} α) (FreeCommRing.instCommRing.{u1} α)))) (Semiring.toNonAssocSemiring.{u2} R (CommSemiring.toSemiring.{u2} R (CommRing.toCommSemiring.{u2} R _inst_1))) (RingHom.instRingHomClassRingHom.{u1, u2} (FreeCommRing.{u1} α) R (Semiring.toNonAssocSemiring.{u1} (FreeCommRing.{u1} α) (CommSemiring.toSemiring.{u1} (FreeCommRing.{u1} α) (CommRing.toCommSemiring.{u1} (FreeCommRing.{u1} α) (FreeCommRing.instCommRing.{u1} α)))) (Semiring.toNonAssocSemiring.{u2} R (CommSemiring.toSemiring.{u2} R (CommRing.toCommSemiring.{u2} R _inst_1))))))) g (FreeCommRing.of.{u1} α x))) -> (Eq.{max (succ u1) (succ u2)} (RingHom.{u1, u2} (FreeCommRing.{u1} α) R (Semiring.toNonAssocSemiring.{u1} (FreeCommRing.{u1} α) (CommSemiring.toSemiring.{u1} (FreeCommRing.{u1} α) (CommRing.toCommSemiring.{u1} (FreeCommRing.{u1} α) (FreeCommRing.instCommRing.{u1} α)))) (Semiring.toNonAssocSemiring.{u2} R (CommSemiring.toSemiring.{u2} R (CommRing.toCommSemiring.{u2} R _inst_1)))) f g)
 Case conversion may be inaccurate. Consider using '#align free_comm_ring.hom_ext FreeCommRing.hom_extₓ'. -/
 @[ext]
 theorem hom_ext ⦃f g : FreeCommRing α →+* R⦄ (h : ∀ x, f (of x) = g (of x)) : f = g :=
@@ -191,7 +191,7 @@ def map : FreeCommRing α →+* FreeCommRing β :=
 lean 3 declaration is
   forall {α : Type.{u1}} {β : Type.{u2}} (f : α -> β) (x : α), Eq.{succ u2} (FreeCommRing.{u2} β) (coeFn.{max (succ u1) (succ u2), max (succ u1) (succ u2)} (RingHom.{u1, u2} (FreeCommRing.{u1} α) (FreeCommRing.{u2} β) (NonAssocRing.toNonAssocSemiring.{u1} (FreeCommRing.{u1} α) (Ring.toNonAssocRing.{u1} (FreeCommRing.{u1} α) (CommRing.toRing.{u1} (FreeCommRing.{u1} α) (FreeCommRing.instCommRing.{u1} α)))) (NonAssocRing.toNonAssocSemiring.{u2} (FreeCommRing.{u2} β) (Ring.toNonAssocRing.{u2} (FreeCommRing.{u2} β) (CommRing.toRing.{u2} (FreeCommRing.{u2} β) (FreeCommRing.instCommRing.{u2} β))))) (fun (_x : RingHom.{u1, u2} (FreeCommRing.{u1} α) (FreeCommRing.{u2} β) (NonAssocRing.toNonAssocSemiring.{u1} (FreeCommRing.{u1} α) (Ring.toNonAssocRing.{u1} (FreeCommRing.{u1} α) (CommRing.toRing.{u1} (FreeCommRing.{u1} α) (FreeCommRing.instCommRing.{u1} α)))) (NonAssocRing.toNonAssocSemiring.{u2} (FreeCommRing.{u2} β) (Ring.toNonAssocRing.{u2} (FreeCommRing.{u2} β) (CommRing.toRing.{u2} (FreeCommRing.{u2} β) (FreeCommRing.instCommRing.{u2} β))))) => (FreeCommRing.{u1} α) -> (FreeCommRing.{u2} β)) (RingHom.hasCoeToFun.{u1, u2} (FreeCommRing.{u1} α) (FreeCommRing.{u2} β) (NonAssocRing.toNonAssocSemiring.{u1} (FreeCommRing.{u1} α) (Ring.toNonAssocRing.{u1} (FreeCommRing.{u1} α) (CommRing.toRing.{u1} (FreeCommRing.{u1} α) (FreeCommRing.instCommRing.{u1} α)))) (NonAssocRing.toNonAssocSemiring.{u2} (FreeCommRing.{u2} β) (Ring.toNonAssocRing.{u2} (FreeCommRing.{u2} β) (CommRing.toRing.{u2} (FreeCommRing.{u2} β) (FreeCommRing.instCommRing.{u2} β))))) (FreeCommRing.map.{u1, u2} α β f) (FreeCommRing.of.{u1} α x)) (FreeCommRing.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 : FreeCommRing.{u1} α) => FreeCommRing.{u2} β) (FreeCommRing.of.{u1} α x)) (FunLike.coe.{max (succ u1) (succ u2), succ u1, succ u2} (RingHom.{u1, u2} (FreeCommRing.{u1} α) (FreeCommRing.{u2} β) (Semiring.toNonAssocSemiring.{u1} (FreeCommRing.{u1} α) (CommSemiring.toSemiring.{u1} (FreeCommRing.{u1} α) (CommRing.toCommSemiring.{u1} (FreeCommRing.{u1} α) (FreeCommRing.instCommRing.{u1} α)))) (Semiring.toNonAssocSemiring.{u2} (FreeCommRing.{u2} β) (CommSemiring.toSemiring.{u2} (FreeCommRing.{u2} β) (CommRing.toCommSemiring.{u2} (FreeCommRing.{u2} β) (FreeCommRing.instCommRing.{u2} β))))) (FreeCommRing.{u1} α) (fun (_x : FreeCommRing.{u1} α) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : FreeCommRing.{u1} α) => FreeCommRing.{u2} β) _x) (MulHomClass.toFunLike.{max u1 u2, u1, u2} (RingHom.{u1, u2} (FreeCommRing.{u1} α) (FreeCommRing.{u2} β) (Semiring.toNonAssocSemiring.{u1} (FreeCommRing.{u1} α) (CommSemiring.toSemiring.{u1} (FreeCommRing.{u1} α) (CommRing.toCommSemiring.{u1} (FreeCommRing.{u1} α) (FreeCommRing.instCommRing.{u1} α)))) (Semiring.toNonAssocSemiring.{u2} (FreeCommRing.{u2} β) (CommSemiring.toSemiring.{u2} (FreeCommRing.{u2} β) (CommRing.toCommSemiring.{u2} (FreeCommRing.{u2} β) (FreeCommRing.instCommRing.{u2} β))))) (FreeCommRing.{u1} α) (FreeCommRing.{u2} β) (NonUnitalNonAssocSemiring.toMul.{u1} (FreeCommRing.{u1} α) (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u1} (FreeCommRing.{u1} α) (Semiring.toNonAssocSemiring.{u1} (FreeCommRing.{u1} α) (CommSemiring.toSemiring.{u1} (FreeCommRing.{u1} α) (CommRing.toCommSemiring.{u1} (FreeCommRing.{u1} α) (FreeCommRing.instCommRing.{u1} α)))))) (NonUnitalNonAssocSemiring.toMul.{u2} (FreeCommRing.{u2} β) (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u2} (FreeCommRing.{u2} β) (Semiring.toNonAssocSemiring.{u2} (FreeCommRing.{u2} β) (CommSemiring.toSemiring.{u2} (FreeCommRing.{u2} β) (CommRing.toCommSemiring.{u2} (FreeCommRing.{u2} β) (FreeCommRing.instCommRing.{u2} β)))))) (NonUnitalRingHomClass.toMulHomClass.{max u1 u2, u1, u2} (RingHom.{u1, u2} (FreeCommRing.{u1} α) (FreeCommRing.{u2} β) (Semiring.toNonAssocSemiring.{u1} (FreeCommRing.{u1} α) (CommSemiring.toSemiring.{u1} (FreeCommRing.{u1} α) (CommRing.toCommSemiring.{u1} (FreeCommRing.{u1} α) (FreeCommRing.instCommRing.{u1} α)))) (Semiring.toNonAssocSemiring.{u2} (FreeCommRing.{u2} β) (CommSemiring.toSemiring.{u2} (FreeCommRing.{u2} β) (CommRing.toCommSemiring.{u2} (FreeCommRing.{u2} β) (FreeCommRing.instCommRing.{u2} β))))) (FreeCommRing.{u1} α) (FreeCommRing.{u2} β) (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u1} (FreeCommRing.{u1} α) (Semiring.toNonAssocSemiring.{u1} (FreeCommRing.{u1} α) (CommSemiring.toSemiring.{u1} (FreeCommRing.{u1} α) (CommRing.toCommSemiring.{u1} (FreeCommRing.{u1} α) (FreeCommRing.instCommRing.{u1} α))))) (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u2} (FreeCommRing.{u2} β) (Semiring.toNonAssocSemiring.{u2} (FreeCommRing.{u2} β) (CommSemiring.toSemiring.{u2} (FreeCommRing.{u2} β) (CommRing.toCommSemiring.{u2} (FreeCommRing.{u2} β) (FreeCommRing.instCommRing.{u2} β))))) (RingHomClass.toNonUnitalRingHomClass.{max u1 u2, u1, u2} (RingHom.{u1, u2} (FreeCommRing.{u1} α) (FreeCommRing.{u2} β) (Semiring.toNonAssocSemiring.{u1} (FreeCommRing.{u1} α) (CommSemiring.toSemiring.{u1} (FreeCommRing.{u1} α) (CommRing.toCommSemiring.{u1} (FreeCommRing.{u1} α) (FreeCommRing.instCommRing.{u1} α)))) (Semiring.toNonAssocSemiring.{u2} (FreeCommRing.{u2} β) (CommSemiring.toSemiring.{u2} (FreeCommRing.{u2} β) (CommRing.toCommSemiring.{u2} (FreeCommRing.{u2} β) (FreeCommRing.instCommRing.{u2} β))))) (FreeCommRing.{u1} α) (FreeCommRing.{u2} β) (Semiring.toNonAssocSemiring.{u1} (FreeCommRing.{u1} α) (CommSemiring.toSemiring.{u1} (FreeCommRing.{u1} α) (CommRing.toCommSemiring.{u1} (FreeCommRing.{u1} α) (FreeCommRing.instCommRing.{u1} α)))) (Semiring.toNonAssocSemiring.{u2} (FreeCommRing.{u2} β) (CommSemiring.toSemiring.{u2} (FreeCommRing.{u2} β) (CommRing.toCommSemiring.{u2} (FreeCommRing.{u2} β) (FreeCommRing.instCommRing.{u2} β)))) (RingHom.instRingHomClassRingHom.{u1, u2} (FreeCommRing.{u1} α) (FreeCommRing.{u2} β) (Semiring.toNonAssocSemiring.{u1} (FreeCommRing.{u1} α) (CommSemiring.toSemiring.{u1} (FreeCommRing.{u1} α) (CommRing.toCommSemiring.{u1} (FreeCommRing.{u1} α) (FreeCommRing.instCommRing.{u1} α)))) (Semiring.toNonAssocSemiring.{u2} (FreeCommRing.{u2} β) (CommSemiring.toSemiring.{u2} (FreeCommRing.{u2} β) (CommRing.toCommSemiring.{u2} (FreeCommRing.{u2} β) (FreeCommRing.instCommRing.{u2} β)))))))) (FreeCommRing.map.{u1, u2} α β f) (FreeCommRing.of.{u1} α x)) (FreeCommRing.of.{u2} β (f x))
+  forall {α : Type.{u1}} {β : Type.{u2}} (f : α -> β) (x : α), Eq.{succ u2} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2397 : FreeCommRing.{u1} α) => FreeCommRing.{u2} β) (FreeCommRing.of.{u1} α x)) (FunLike.coe.{max (succ u1) (succ u2), succ u1, succ u2} (RingHom.{u1, u2} (FreeCommRing.{u1} α) (FreeCommRing.{u2} β) (Semiring.toNonAssocSemiring.{u1} (FreeCommRing.{u1} α) (CommSemiring.toSemiring.{u1} (FreeCommRing.{u1} α) (CommRing.toCommSemiring.{u1} (FreeCommRing.{u1} α) (FreeCommRing.instCommRing.{u1} α)))) (Semiring.toNonAssocSemiring.{u2} (FreeCommRing.{u2} β) (CommSemiring.toSemiring.{u2} (FreeCommRing.{u2} β) (CommRing.toCommSemiring.{u2} (FreeCommRing.{u2} β) (FreeCommRing.instCommRing.{u2} β))))) (FreeCommRing.{u1} α) (fun (_x : FreeCommRing.{u1} α) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2397 : FreeCommRing.{u1} α) => FreeCommRing.{u2} β) _x) (MulHomClass.toFunLike.{max u1 u2, u1, u2} (RingHom.{u1, u2} (FreeCommRing.{u1} α) (FreeCommRing.{u2} β) (Semiring.toNonAssocSemiring.{u1} (FreeCommRing.{u1} α) (CommSemiring.toSemiring.{u1} (FreeCommRing.{u1} α) (CommRing.toCommSemiring.{u1} (FreeCommRing.{u1} α) (FreeCommRing.instCommRing.{u1} α)))) (Semiring.toNonAssocSemiring.{u2} (FreeCommRing.{u2} β) (CommSemiring.toSemiring.{u2} (FreeCommRing.{u2} β) (CommRing.toCommSemiring.{u2} (FreeCommRing.{u2} β) (FreeCommRing.instCommRing.{u2} β))))) (FreeCommRing.{u1} α) (FreeCommRing.{u2} β) (NonUnitalNonAssocSemiring.toMul.{u1} (FreeCommRing.{u1} α) (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u1} (FreeCommRing.{u1} α) (Semiring.toNonAssocSemiring.{u1} (FreeCommRing.{u1} α) (CommSemiring.toSemiring.{u1} (FreeCommRing.{u1} α) (CommRing.toCommSemiring.{u1} (FreeCommRing.{u1} α) (FreeCommRing.instCommRing.{u1} α)))))) (NonUnitalNonAssocSemiring.toMul.{u2} (FreeCommRing.{u2} β) (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u2} (FreeCommRing.{u2} β) (Semiring.toNonAssocSemiring.{u2} (FreeCommRing.{u2} β) (CommSemiring.toSemiring.{u2} (FreeCommRing.{u2} β) (CommRing.toCommSemiring.{u2} (FreeCommRing.{u2} β) (FreeCommRing.instCommRing.{u2} β)))))) (NonUnitalRingHomClass.toMulHomClass.{max u1 u2, u1, u2} (RingHom.{u1, u2} (FreeCommRing.{u1} α) (FreeCommRing.{u2} β) (Semiring.toNonAssocSemiring.{u1} (FreeCommRing.{u1} α) (CommSemiring.toSemiring.{u1} (FreeCommRing.{u1} α) (CommRing.toCommSemiring.{u1} (FreeCommRing.{u1} α) (FreeCommRing.instCommRing.{u1} α)))) (Semiring.toNonAssocSemiring.{u2} (FreeCommRing.{u2} β) (CommSemiring.toSemiring.{u2} (FreeCommRing.{u2} β) (CommRing.toCommSemiring.{u2} (FreeCommRing.{u2} β) (FreeCommRing.instCommRing.{u2} β))))) (FreeCommRing.{u1} α) (FreeCommRing.{u2} β) (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u1} (FreeCommRing.{u1} α) (Semiring.toNonAssocSemiring.{u1} (FreeCommRing.{u1} α) (CommSemiring.toSemiring.{u1} (FreeCommRing.{u1} α) (CommRing.toCommSemiring.{u1} (FreeCommRing.{u1} α) (FreeCommRing.instCommRing.{u1} α))))) (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u2} (FreeCommRing.{u2} β) (Semiring.toNonAssocSemiring.{u2} (FreeCommRing.{u2} β) (CommSemiring.toSemiring.{u2} (FreeCommRing.{u2} β) (CommRing.toCommSemiring.{u2} (FreeCommRing.{u2} β) (FreeCommRing.instCommRing.{u2} β))))) (RingHomClass.toNonUnitalRingHomClass.{max u1 u2, u1, u2} (RingHom.{u1, u2} (FreeCommRing.{u1} α) (FreeCommRing.{u2} β) (Semiring.toNonAssocSemiring.{u1} (FreeCommRing.{u1} α) (CommSemiring.toSemiring.{u1} (FreeCommRing.{u1} α) (CommRing.toCommSemiring.{u1} (FreeCommRing.{u1} α) (FreeCommRing.instCommRing.{u1} α)))) (Semiring.toNonAssocSemiring.{u2} (FreeCommRing.{u2} β) (CommSemiring.toSemiring.{u2} (FreeCommRing.{u2} β) (CommRing.toCommSemiring.{u2} (FreeCommRing.{u2} β) (FreeCommRing.instCommRing.{u2} β))))) (FreeCommRing.{u1} α) (FreeCommRing.{u2} β) (Semiring.toNonAssocSemiring.{u1} (FreeCommRing.{u1} α) (CommSemiring.toSemiring.{u1} (FreeCommRing.{u1} α) (CommRing.toCommSemiring.{u1} (FreeCommRing.{u1} α) (FreeCommRing.instCommRing.{u1} α)))) (Semiring.toNonAssocSemiring.{u2} (FreeCommRing.{u2} β) (CommSemiring.toSemiring.{u2} (FreeCommRing.{u2} β) (CommRing.toCommSemiring.{u2} (FreeCommRing.{u2} β) (FreeCommRing.instCommRing.{u2} β)))) (RingHom.instRingHomClassRingHom.{u1, u2} (FreeCommRing.{u1} α) (FreeCommRing.{u2} β) (Semiring.toNonAssocSemiring.{u1} (FreeCommRing.{u1} α) (CommSemiring.toSemiring.{u1} (FreeCommRing.{u1} α) (CommRing.toCommSemiring.{u1} (FreeCommRing.{u1} α) (FreeCommRing.instCommRing.{u1} α)))) (Semiring.toNonAssocSemiring.{u2} (FreeCommRing.{u2} β) (CommSemiring.toSemiring.{u2} (FreeCommRing.{u2} β) (CommRing.toCommSemiring.{u2} (FreeCommRing.{u2} β) (FreeCommRing.instCommRing.{u2} β)))))))) (FreeCommRing.map.{u1, u2} α β f) (FreeCommRing.of.{u1} α x)) (FreeCommRing.of.{u2} β (f x))
 Case conversion may be inaccurate. Consider using '#align free_comm_ring.map_of FreeCommRing.map_ofₓ'. -/
 @[simp]
 theorem map_of (x : α) : map f (of x) = of (f x) :=
@@ -305,7 +305,7 @@ variable (s : Set α) [DecidablePred (· ∈ s)] (x y : FreeCommRing α)
 lean 3 declaration is
   forall {α : Type.{u1}} (s : Set.{u1} α) [_inst_1 : DecidablePred.{succ u1} α (fun (_x : α) => Membership.Mem.{u1, u1} α (Set.{u1} α) (Set.hasMem.{u1} α) _x s)] (p : α), Eq.{succ u1} (FreeCommRing.{u1} (coeSort.{succ u1, succ (succ u1)} (Set.{u1} α) Type.{u1} (Set.hasCoeToSort.{u1} α) s)) (coeFn.{succ u1, succ u1} (RingHom.{u1, u1} (FreeCommRing.{u1} α) (FreeCommRing.{u1} (coeSort.{succ u1, succ (succ u1)} (Set.{u1} α) Type.{u1} (Set.hasCoeToSort.{u1} α) s)) (NonAssocRing.toNonAssocSemiring.{u1} (FreeCommRing.{u1} α) (Ring.toNonAssocRing.{u1} (FreeCommRing.{u1} α) (CommRing.toRing.{u1} (FreeCommRing.{u1} α) (FreeCommRing.instCommRing.{u1} α)))) (NonAssocRing.toNonAssocSemiring.{u1} (FreeCommRing.{u1} (coeSort.{succ u1, succ (succ u1)} (Set.{u1} α) Type.{u1} (Set.hasCoeToSort.{u1} α) s)) (Ring.toNonAssocRing.{u1} (FreeCommRing.{u1} (coeSort.{succ u1, succ (succ u1)} (Set.{u1} α) Type.{u1} (Set.hasCoeToSort.{u1} α) s)) (CommRing.toRing.{u1} (FreeCommRing.{u1} (coeSort.{succ u1, succ (succ u1)} (Set.{u1} α) Type.{u1} (Set.hasCoeToSort.{u1} α) s)) (FreeCommRing.instCommRing.{u1} (coeSort.{succ u1, succ (succ u1)} (Set.{u1} α) Type.{u1} (Set.hasCoeToSort.{u1} α) s)))))) (fun (_x : RingHom.{u1, u1} (FreeCommRing.{u1} α) (FreeCommRing.{u1} (coeSort.{succ u1, succ (succ u1)} (Set.{u1} α) Type.{u1} (Set.hasCoeToSort.{u1} α) s)) (NonAssocRing.toNonAssocSemiring.{u1} (FreeCommRing.{u1} α) (Ring.toNonAssocRing.{u1} (FreeCommRing.{u1} α) (CommRing.toRing.{u1} (FreeCommRing.{u1} α) (FreeCommRing.instCommRing.{u1} α)))) (NonAssocRing.toNonAssocSemiring.{u1} (FreeCommRing.{u1} (coeSort.{succ u1, succ (succ u1)} (Set.{u1} α) Type.{u1} (Set.hasCoeToSort.{u1} α) s)) (Ring.toNonAssocRing.{u1} (FreeCommRing.{u1} (coeSort.{succ u1, succ (succ u1)} (Set.{u1} α) Type.{u1} (Set.hasCoeToSort.{u1} α) s)) (CommRing.toRing.{u1} (FreeCommRing.{u1} (coeSort.{succ u1, succ (succ u1)} (Set.{u1} α) Type.{u1} (Set.hasCoeToSort.{u1} α) s)) (FreeCommRing.instCommRing.{u1} (coeSort.{succ u1, succ (succ u1)} (Set.{u1} α) Type.{u1} (Set.hasCoeToSort.{u1} α) s)))))) => (FreeCommRing.{u1} α) -> (FreeCommRing.{u1} (coeSort.{succ u1, succ (succ u1)} (Set.{u1} α) Type.{u1} (Set.hasCoeToSort.{u1} α) s))) (RingHom.hasCoeToFun.{u1, u1} (FreeCommRing.{u1} α) (FreeCommRing.{u1} (coeSort.{succ u1, succ (succ u1)} (Set.{u1} α) Type.{u1} (Set.hasCoeToSort.{u1} α) s)) (NonAssocRing.toNonAssocSemiring.{u1} (FreeCommRing.{u1} α) (Ring.toNonAssocRing.{u1} (FreeCommRing.{u1} α) (CommRing.toRing.{u1} (FreeCommRing.{u1} α) (FreeCommRing.instCommRing.{u1} α)))) (NonAssocRing.toNonAssocSemiring.{u1} (FreeCommRing.{u1} (coeSort.{succ u1, succ (succ u1)} (Set.{u1} α) Type.{u1} (Set.hasCoeToSort.{u1} α) s)) (Ring.toNonAssocRing.{u1} (FreeCommRing.{u1} (coeSort.{succ u1, succ (succ u1)} (Set.{u1} α) Type.{u1} (Set.hasCoeToSort.{u1} α) s)) (CommRing.toRing.{u1} (FreeCommRing.{u1} (coeSort.{succ u1, succ (succ u1)} (Set.{u1} α) Type.{u1} (Set.hasCoeToSort.{u1} α) s)) (FreeCommRing.instCommRing.{u1} (coeSort.{succ u1, succ (succ u1)} (Set.{u1} α) Type.{u1} (Set.hasCoeToSort.{u1} α) s)))))) (FreeCommRing.restriction.{u1} α s (fun (a : α) => _inst_1 a)) (FreeCommRing.of.{u1} α p)) (dite.{succ u1} (FreeCommRing.{u1} (coeSort.{succ u1, succ (succ u1)} (Set.{u1} α) Type.{u1} (Set.hasCoeToSort.{u1} α) s)) (Membership.Mem.{u1, u1} α (Set.{u1} α) (Set.hasMem.{u1} α) p s) (_inst_1 p) (fun (H : Membership.Mem.{u1, u1} α (Set.{u1} α) (Set.hasMem.{u1} α) p s) => FreeCommRing.of.{u1} (coeSort.{succ u1, succ (succ u1)} (Set.{u1} α) Type.{u1} (Set.hasCoeToSort.{u1} α) s) (Subtype.mk.{succ u1} α (fun (x : α) => Membership.Mem.{u1, u1} α (Set.{u1} α) (Set.hasMem.{u1} α) x s) p H)) (fun (H : Not (Membership.Mem.{u1, u1} α (Set.{u1} α) (Set.hasMem.{u1} α) p s)) => OfNat.ofNat.{u1} (FreeCommRing.{u1} (coeSort.{succ u1, succ (succ u1)} (Set.{u1} α) Type.{u1} (Set.hasCoeToSort.{u1} α) s)) 0 (OfNat.mk.{u1} (FreeCommRing.{u1} (coeSort.{succ u1, succ (succ u1)} (Set.{u1} α) Type.{u1} (Set.hasCoeToSort.{u1} α) s)) 0 (Zero.zero.{u1} (FreeCommRing.{u1} (coeSort.{succ u1, succ (succ u1)} (Set.{u1} α) Type.{u1} (Set.hasCoeToSort.{u1} α) s)) (MulZeroClass.toHasZero.{u1} (FreeCommRing.{u1} (coeSort.{succ u1, succ (succ u1)} (Set.{u1} α) Type.{u1} (Set.hasCoeToSort.{u1} α) s)) (NonUnitalNonAssocSemiring.toMulZeroClass.{u1} (FreeCommRing.{u1} (coeSort.{succ u1, succ (succ u1)} (Set.{u1} α) Type.{u1} (Set.hasCoeToSort.{u1} α) s)) (NonUnitalNonAssocRing.toNonUnitalNonAssocSemiring.{u1} (FreeCommRing.{u1} (coeSort.{succ u1, succ (succ u1)} (Set.{u1} α) Type.{u1} (Set.hasCoeToSort.{u1} α) s)) (NonAssocRing.toNonUnitalNonAssocRing.{u1} (FreeCommRing.{u1} (coeSort.{succ u1, succ (succ u1)} (Set.{u1} α) Type.{u1} (Set.hasCoeToSort.{u1} α) s)) (Ring.toNonAssocRing.{u1} (FreeCommRing.{u1} (coeSort.{succ u1, succ (succ u1)} (Set.{u1} α) Type.{u1} (Set.hasCoeToSort.{u1} α) s)) (CommRing.toRing.{u1} (FreeCommRing.{u1} (coeSort.{succ u1, succ (succ u1)} (Set.{u1} α) Type.{u1} (Set.hasCoeToSort.{u1} α) s)) (FreeCommRing.instCommRing.{u1} (coeSort.{succ u1, succ (succ u1)} (Set.{u1} α) Type.{u1} (Set.hasCoeToSort.{u1} α) s))))))))))))
 but is expected to have type
-  forall {α : Type.{u1}} (s : Set.{u1} α) [_inst_1 : DecidablePred.{succ u1} α (fun (_x : α) => Membership.mem.{u1, u1} α (Set.{u1} α) (Set.instMembershipSet.{u1} α) _x s)] (p : α), Eq.{succ u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : FreeCommRing.{u1} α) => FreeCommRing.{u1} (Set.Elem.{u1} α s)) (FreeCommRing.of.{u1} α p)) (FunLike.coe.{succ u1, succ u1, succ u1} (RingHom.{u1, u1} (FreeCommRing.{u1} α) (FreeCommRing.{u1} (Set.Elem.{u1} α s)) (Semiring.toNonAssocSemiring.{u1} (FreeCommRing.{u1} α) (CommSemiring.toSemiring.{u1} (FreeCommRing.{u1} α) (CommRing.toCommSemiring.{u1} (FreeCommRing.{u1} α) (FreeCommRing.instCommRing.{u1} α)))) (Semiring.toNonAssocSemiring.{u1} (FreeCommRing.{u1} (Set.Elem.{u1} α s)) (CommSemiring.toSemiring.{u1} (FreeCommRing.{u1} (Set.Elem.{u1} α s)) (CommRing.toCommSemiring.{u1} (FreeCommRing.{u1} (Set.Elem.{u1} α s)) (FreeCommRing.instCommRing.{u1} (Set.Elem.{u1} α s)))))) (FreeCommRing.{u1} α) (fun (_x : FreeCommRing.{u1} α) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : FreeCommRing.{u1} α) => FreeCommRing.{u1} (Set.Elem.{u1} α s)) _x) (MulHomClass.toFunLike.{u1, u1, u1} (RingHom.{u1, u1} (FreeCommRing.{u1} α) (FreeCommRing.{u1} (Set.Elem.{u1} α s)) (Semiring.toNonAssocSemiring.{u1} (FreeCommRing.{u1} α) (CommSemiring.toSemiring.{u1} (FreeCommRing.{u1} α) (CommRing.toCommSemiring.{u1} (FreeCommRing.{u1} α) (FreeCommRing.instCommRing.{u1} α)))) (Semiring.toNonAssocSemiring.{u1} (FreeCommRing.{u1} (Set.Elem.{u1} α s)) (CommSemiring.toSemiring.{u1} (FreeCommRing.{u1} (Set.Elem.{u1} α s)) (CommRing.toCommSemiring.{u1} (FreeCommRing.{u1} (Set.Elem.{u1} α s)) (FreeCommRing.instCommRing.{u1} (Set.Elem.{u1} α s)))))) (FreeCommRing.{u1} α) (FreeCommRing.{u1} (Set.Elem.{u1} α s)) (NonUnitalNonAssocSemiring.toMul.{u1} (FreeCommRing.{u1} α) (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u1} (FreeCommRing.{u1} α) (Semiring.toNonAssocSemiring.{u1} (FreeCommRing.{u1} α) (CommSemiring.toSemiring.{u1} (FreeCommRing.{u1} α) (CommRing.toCommSemiring.{u1} (FreeCommRing.{u1} α) (FreeCommRing.instCommRing.{u1} α)))))) (NonUnitalNonAssocSemiring.toMul.{u1} (FreeCommRing.{u1} (Set.Elem.{u1} α s)) (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u1} (FreeCommRing.{u1} (Set.Elem.{u1} α s)) (Semiring.toNonAssocSemiring.{u1} (FreeCommRing.{u1} (Set.Elem.{u1} α s)) (CommSemiring.toSemiring.{u1} (FreeCommRing.{u1} (Set.Elem.{u1} α s)) (CommRing.toCommSemiring.{u1} (FreeCommRing.{u1} (Set.Elem.{u1} α s)) (FreeCommRing.instCommRing.{u1} (Set.Elem.{u1} α s))))))) (NonUnitalRingHomClass.toMulHomClass.{u1, u1, u1} (RingHom.{u1, u1} (FreeCommRing.{u1} α) (FreeCommRing.{u1} (Set.Elem.{u1} α s)) (Semiring.toNonAssocSemiring.{u1} (FreeCommRing.{u1} α) (CommSemiring.toSemiring.{u1} (FreeCommRing.{u1} α) (CommRing.toCommSemiring.{u1} (FreeCommRing.{u1} α) (FreeCommRing.instCommRing.{u1} α)))) (Semiring.toNonAssocSemiring.{u1} (FreeCommRing.{u1} (Set.Elem.{u1} α s)) (CommSemiring.toSemiring.{u1} (FreeCommRing.{u1} (Set.Elem.{u1} α s)) (CommRing.toCommSemiring.{u1} (FreeCommRing.{u1} (Set.Elem.{u1} α s)) (FreeCommRing.instCommRing.{u1} (Set.Elem.{u1} α s)))))) (FreeCommRing.{u1} α) (FreeCommRing.{u1} (Set.Elem.{u1} α s)) (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u1} (FreeCommRing.{u1} α) (Semiring.toNonAssocSemiring.{u1} (FreeCommRing.{u1} α) (CommSemiring.toSemiring.{u1} (FreeCommRing.{u1} α) (CommRing.toCommSemiring.{u1} (FreeCommRing.{u1} α) (FreeCommRing.instCommRing.{u1} α))))) (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u1} (FreeCommRing.{u1} (Set.Elem.{u1} α s)) (Semiring.toNonAssocSemiring.{u1} (FreeCommRing.{u1} (Set.Elem.{u1} α s)) (CommSemiring.toSemiring.{u1} (FreeCommRing.{u1} (Set.Elem.{u1} α s)) (CommRing.toCommSemiring.{u1} (FreeCommRing.{u1} (Set.Elem.{u1} α s)) (FreeCommRing.instCommRing.{u1} (Set.Elem.{u1} α s)))))) (RingHomClass.toNonUnitalRingHomClass.{u1, u1, u1} (RingHom.{u1, u1} (FreeCommRing.{u1} α) (FreeCommRing.{u1} (Set.Elem.{u1} α s)) (Semiring.toNonAssocSemiring.{u1} (FreeCommRing.{u1} α) (CommSemiring.toSemiring.{u1} (FreeCommRing.{u1} α) (CommRing.toCommSemiring.{u1} (FreeCommRing.{u1} α) (FreeCommRing.instCommRing.{u1} α)))) (Semiring.toNonAssocSemiring.{u1} (FreeCommRing.{u1} (Set.Elem.{u1} α s)) (CommSemiring.toSemiring.{u1} (FreeCommRing.{u1} (Set.Elem.{u1} α s)) (CommRing.toCommSemiring.{u1} (FreeCommRing.{u1} (Set.Elem.{u1} α s)) (FreeCommRing.instCommRing.{u1} (Set.Elem.{u1} α s)))))) (FreeCommRing.{u1} α) (FreeCommRing.{u1} (Set.Elem.{u1} α s)) (Semiring.toNonAssocSemiring.{u1} (FreeCommRing.{u1} α) (CommSemiring.toSemiring.{u1} (FreeCommRing.{u1} α) (CommRing.toCommSemiring.{u1} (FreeCommRing.{u1} α) (FreeCommRing.instCommRing.{u1} α)))) (Semiring.toNonAssocSemiring.{u1} (FreeCommRing.{u1} (Set.Elem.{u1} α s)) (CommSemiring.toSemiring.{u1} (FreeCommRing.{u1} (Set.Elem.{u1} α s)) (CommRing.toCommSemiring.{u1} (FreeCommRing.{u1} (Set.Elem.{u1} α s)) (FreeCommRing.instCommRing.{u1} (Set.Elem.{u1} α s))))) (RingHom.instRingHomClassRingHom.{u1, u1} (FreeCommRing.{u1} α) (FreeCommRing.{u1} (Set.Elem.{u1} α s)) (Semiring.toNonAssocSemiring.{u1} (FreeCommRing.{u1} α) (CommSemiring.toSemiring.{u1} (FreeCommRing.{u1} α) (CommRing.toCommSemiring.{u1} (FreeCommRing.{u1} α) (FreeCommRing.instCommRing.{u1} α)))) (Semiring.toNonAssocSemiring.{u1} (FreeCommRing.{u1} (Set.Elem.{u1} α s)) (CommSemiring.toSemiring.{u1} (FreeCommRing.{u1} (Set.Elem.{u1} α s)) (CommRing.toCommSemiring.{u1} (FreeCommRing.{u1} (Set.Elem.{u1} α s)) (FreeCommRing.instCommRing.{u1} (Set.Elem.{u1} α s))))))))) (FreeCommRing.restriction.{u1} α s (fun (a : α) => _inst_1 a)) (FreeCommRing.of.{u1} α p)) (dite.{succ u1} (FreeCommRing.{u1} (Set.Elem.{u1} α s)) (Membership.mem.{u1, u1} α (Set.{u1} α) (Set.instMembershipSet.{u1} α) p s) (_inst_1 p) (fun (H : Membership.mem.{u1, u1} α (Set.{u1} α) (Set.instMembershipSet.{u1} α) p s) => FreeCommRing.of.{u1} (Set.Elem.{u1} α s) (Subtype.mk.{succ u1} α (fun (x : α) => Membership.mem.{u1, u1} α (Set.{u1} α) (Set.instMembershipSet.{u1} α) x s) p H)) (fun (H : Not (Membership.mem.{u1, u1} α (Set.{u1} α) (Set.instMembershipSet.{u1} α) p s)) => OfNat.ofNat.{u1} (FreeCommRing.{u1} (Set.Elem.{u1} α s)) 0 (Zero.toOfNat0.{u1} (FreeCommRing.{u1} (Set.Elem.{u1} α s)) (CommMonoidWithZero.toZero.{u1} (FreeCommRing.{u1} (Set.Elem.{u1} α s)) (CommSemiring.toCommMonoidWithZero.{u1} (FreeCommRing.{u1} (Set.Elem.{u1} α s)) (CommRing.toCommSemiring.{u1} (FreeCommRing.{u1} (Set.Elem.{u1} α s)) (FreeCommRing.instCommRing.{u1} (Set.Elem.{u1} α s))))))))
+  forall {α : Type.{u1}} (s : Set.{u1} α) [_inst_1 : DecidablePred.{succ u1} α (fun (_x : α) => Membership.mem.{u1, u1} α (Set.{u1} α) (Set.instMembershipSet.{u1} α) _x s)] (p : α), Eq.{succ u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2397 : FreeCommRing.{u1} α) => FreeCommRing.{u1} (Set.Elem.{u1} α s)) (FreeCommRing.of.{u1} α p)) (FunLike.coe.{succ u1, succ u1, succ u1} (RingHom.{u1, u1} (FreeCommRing.{u1} α) (FreeCommRing.{u1} (Set.Elem.{u1} α s)) (Semiring.toNonAssocSemiring.{u1} (FreeCommRing.{u1} α) (CommSemiring.toSemiring.{u1} (FreeCommRing.{u1} α) (CommRing.toCommSemiring.{u1} (FreeCommRing.{u1} α) (FreeCommRing.instCommRing.{u1} α)))) (Semiring.toNonAssocSemiring.{u1} (FreeCommRing.{u1} (Set.Elem.{u1} α s)) (CommSemiring.toSemiring.{u1} (FreeCommRing.{u1} (Set.Elem.{u1} α s)) (CommRing.toCommSemiring.{u1} (FreeCommRing.{u1} (Set.Elem.{u1} α s)) (FreeCommRing.instCommRing.{u1} (Set.Elem.{u1} α s)))))) (FreeCommRing.{u1} α) (fun (_x : FreeCommRing.{u1} α) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2397 : FreeCommRing.{u1} α) => FreeCommRing.{u1} (Set.Elem.{u1} α s)) _x) (MulHomClass.toFunLike.{u1, u1, u1} (RingHom.{u1, u1} (FreeCommRing.{u1} α) (FreeCommRing.{u1} (Set.Elem.{u1} α s)) (Semiring.toNonAssocSemiring.{u1} (FreeCommRing.{u1} α) (CommSemiring.toSemiring.{u1} (FreeCommRing.{u1} α) (CommRing.toCommSemiring.{u1} (FreeCommRing.{u1} α) (FreeCommRing.instCommRing.{u1} α)))) (Semiring.toNonAssocSemiring.{u1} (FreeCommRing.{u1} (Set.Elem.{u1} α s)) (CommSemiring.toSemiring.{u1} (FreeCommRing.{u1} (Set.Elem.{u1} α s)) (CommRing.toCommSemiring.{u1} (FreeCommRing.{u1} (Set.Elem.{u1} α s)) (FreeCommRing.instCommRing.{u1} (Set.Elem.{u1} α s)))))) (FreeCommRing.{u1} α) (FreeCommRing.{u1} (Set.Elem.{u1} α s)) (NonUnitalNonAssocSemiring.toMul.{u1} (FreeCommRing.{u1} α) (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u1} (FreeCommRing.{u1} α) (Semiring.toNonAssocSemiring.{u1} (FreeCommRing.{u1} α) (CommSemiring.toSemiring.{u1} (FreeCommRing.{u1} α) (CommRing.toCommSemiring.{u1} (FreeCommRing.{u1} α) (FreeCommRing.instCommRing.{u1} α)))))) (NonUnitalNonAssocSemiring.toMul.{u1} (FreeCommRing.{u1} (Set.Elem.{u1} α s)) (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u1} (FreeCommRing.{u1} (Set.Elem.{u1} α s)) (Semiring.toNonAssocSemiring.{u1} (FreeCommRing.{u1} (Set.Elem.{u1} α s)) (CommSemiring.toSemiring.{u1} (FreeCommRing.{u1} (Set.Elem.{u1} α s)) (CommRing.toCommSemiring.{u1} (FreeCommRing.{u1} (Set.Elem.{u1} α s)) (FreeCommRing.instCommRing.{u1} (Set.Elem.{u1} α s))))))) (NonUnitalRingHomClass.toMulHomClass.{u1, u1, u1} (RingHom.{u1, u1} (FreeCommRing.{u1} α) (FreeCommRing.{u1} (Set.Elem.{u1} α s)) (Semiring.toNonAssocSemiring.{u1} (FreeCommRing.{u1} α) (CommSemiring.toSemiring.{u1} (FreeCommRing.{u1} α) (CommRing.toCommSemiring.{u1} (FreeCommRing.{u1} α) (FreeCommRing.instCommRing.{u1} α)))) (Semiring.toNonAssocSemiring.{u1} (FreeCommRing.{u1} (Set.Elem.{u1} α s)) (CommSemiring.toSemiring.{u1} (FreeCommRing.{u1} (Set.Elem.{u1} α s)) (CommRing.toCommSemiring.{u1} (FreeCommRing.{u1} (Set.Elem.{u1} α s)) (FreeCommRing.instCommRing.{u1} (Set.Elem.{u1} α s)))))) (FreeCommRing.{u1} α) (FreeCommRing.{u1} (Set.Elem.{u1} α s)) (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u1} (FreeCommRing.{u1} α) (Semiring.toNonAssocSemiring.{u1} (FreeCommRing.{u1} α) (CommSemiring.toSemiring.{u1} (FreeCommRing.{u1} α) (CommRing.toCommSemiring.{u1} (FreeCommRing.{u1} α) (FreeCommRing.instCommRing.{u1} α))))) (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u1} (FreeCommRing.{u1} (Set.Elem.{u1} α s)) (Semiring.toNonAssocSemiring.{u1} (FreeCommRing.{u1} (Set.Elem.{u1} α s)) (CommSemiring.toSemiring.{u1} (FreeCommRing.{u1} (Set.Elem.{u1} α s)) (CommRing.toCommSemiring.{u1} (FreeCommRing.{u1} (Set.Elem.{u1} α s)) (FreeCommRing.instCommRing.{u1} (Set.Elem.{u1} α s)))))) (RingHomClass.toNonUnitalRingHomClass.{u1, u1, u1} (RingHom.{u1, u1} (FreeCommRing.{u1} α) (FreeCommRing.{u1} (Set.Elem.{u1} α s)) (Semiring.toNonAssocSemiring.{u1} (FreeCommRing.{u1} α) (CommSemiring.toSemiring.{u1} (FreeCommRing.{u1} α) (CommRing.toCommSemiring.{u1} (FreeCommRing.{u1} α) (FreeCommRing.instCommRing.{u1} α)))) (Semiring.toNonAssocSemiring.{u1} (FreeCommRing.{u1} (Set.Elem.{u1} α s)) (CommSemiring.toSemiring.{u1} (FreeCommRing.{u1} (Set.Elem.{u1} α s)) (CommRing.toCommSemiring.{u1} (FreeCommRing.{u1} (Set.Elem.{u1} α s)) (FreeCommRing.instCommRing.{u1} (Set.Elem.{u1} α s)))))) (FreeCommRing.{u1} α) (FreeCommRing.{u1} (Set.Elem.{u1} α s)) (Semiring.toNonAssocSemiring.{u1} (FreeCommRing.{u1} α) (CommSemiring.toSemiring.{u1} (FreeCommRing.{u1} α) (CommRing.toCommSemiring.{u1} (FreeCommRing.{u1} α) (FreeCommRing.instCommRing.{u1} α)))) (Semiring.toNonAssocSemiring.{u1} (FreeCommRing.{u1} (Set.Elem.{u1} α s)) (CommSemiring.toSemiring.{u1} (FreeCommRing.{u1} (Set.Elem.{u1} α s)) (CommRing.toCommSemiring.{u1} (FreeCommRing.{u1} (Set.Elem.{u1} α s)) (FreeCommRing.instCommRing.{u1} (Set.Elem.{u1} α s))))) (RingHom.instRingHomClassRingHom.{u1, u1} (FreeCommRing.{u1} α) (FreeCommRing.{u1} (Set.Elem.{u1} α s)) (Semiring.toNonAssocSemiring.{u1} (FreeCommRing.{u1} α) (CommSemiring.toSemiring.{u1} (FreeCommRing.{u1} α) (CommRing.toCommSemiring.{u1} (FreeCommRing.{u1} α) (FreeCommRing.instCommRing.{u1} α)))) (Semiring.toNonAssocSemiring.{u1} (FreeCommRing.{u1} (Set.Elem.{u1} α s)) (CommSemiring.toSemiring.{u1} (FreeCommRing.{u1} (Set.Elem.{u1} α s)) (CommRing.toCommSemiring.{u1} (FreeCommRing.{u1} (Set.Elem.{u1} α s)) (FreeCommRing.instCommRing.{u1} (Set.Elem.{u1} α s))))))))) (FreeCommRing.restriction.{u1} α s (fun (a : α) => _inst_1 a)) (FreeCommRing.of.{u1} α p)) (dite.{succ u1} (FreeCommRing.{u1} (Set.Elem.{u1} α s)) (Membership.mem.{u1, u1} α (Set.{u1} α) (Set.instMembershipSet.{u1} α) p s) (_inst_1 p) (fun (H : Membership.mem.{u1, u1} α (Set.{u1} α) (Set.instMembershipSet.{u1} α) p s) => FreeCommRing.of.{u1} (Set.Elem.{u1} α s) (Subtype.mk.{succ u1} α (fun (x : α) => Membership.mem.{u1, u1} α (Set.{u1} α) (Set.instMembershipSet.{u1} α) x s) p H)) (fun (H : Not (Membership.mem.{u1, u1} α (Set.{u1} α) (Set.instMembershipSet.{u1} α) p s)) => OfNat.ofNat.{u1} (FreeCommRing.{u1} (Set.Elem.{u1} α s)) 0 (Zero.toOfNat0.{u1} (FreeCommRing.{u1} (Set.Elem.{u1} α s)) (CommMonoidWithZero.toZero.{u1} (FreeCommRing.{u1} (Set.Elem.{u1} α s)) (CommSemiring.toCommMonoidWithZero.{u1} (FreeCommRing.{u1} (Set.Elem.{u1} α s)) (CommRing.toCommSemiring.{u1} (FreeCommRing.{u1} (Set.Elem.{u1} α s)) (FreeCommRing.instCommRing.{u1} (Set.Elem.{u1} α s))))))))
 Case conversion may be inaccurate. Consider using '#align free_comm_ring.restriction_of FreeCommRing.restriction_ofₓ'. -/
 @[simp]
 theorem restriction_of (p) : restriction s (of p) = if H : p ∈ s then of ⟨p, H⟩ else 0 :=
@@ -357,7 +357,7 @@ theorem isSupported_of {p} {s : Set α} : IsSupported (of p) s ↔ p ∈ s :=
 lean 3 declaration is
   forall {α : Type.{u1}} {x : FreeCommRing.{u1} α} (s : Set.{u1} α) [_inst_1 : DecidablePred.{succ u1} α (fun (_x : α) => Membership.Mem.{u1, u1} α (Set.{u1} α) (Set.hasMem.{u1} α) _x s)], (FreeCommRing.IsSupported.{u1} α x s) -> (Eq.{succ u1} (FreeCommRing.{u1} α) (coeFn.{succ u1, succ u1} (RingHom.{u1, u1} (FreeCommRing.{u1} (Subtype.{succ u1} α (fun (x : α) => Membership.Mem.{u1, u1} α (Set.{u1} α) (Set.hasMem.{u1} α) x s))) (FreeCommRing.{u1} α) (NonAssocRing.toNonAssocSemiring.{u1} (FreeCommRing.{u1} (Subtype.{succ u1} α (fun (x : α) => Membership.Mem.{u1, u1} α (Set.{u1} α) (Set.hasMem.{u1} α) x s))) (Ring.toNonAssocRing.{u1} (FreeCommRing.{u1} (Subtype.{succ u1} α (fun (x : α) => Membership.Mem.{u1, u1} α (Set.{u1} α) (Set.hasMem.{u1} α) x s))) (CommRing.toRing.{u1} (FreeCommRing.{u1} (Subtype.{succ u1} α (fun (x : α) => Membership.Mem.{u1, u1} α (Set.{u1} α) (Set.hasMem.{u1} α) x s))) (FreeCommRing.instCommRing.{u1} (Subtype.{succ u1} α (fun (x : α) => Membership.Mem.{u1, u1} α (Set.{u1} α) (Set.hasMem.{u1} α) x s)))))) (NonAssocRing.toNonAssocSemiring.{u1} (FreeCommRing.{u1} α) (Ring.toNonAssocRing.{u1} (FreeCommRing.{u1} α) (CommRing.toRing.{u1} (FreeCommRing.{u1} α) (FreeCommRing.instCommRing.{u1} α))))) (fun (_x : RingHom.{u1, u1} (FreeCommRing.{u1} (Subtype.{succ u1} α (fun (x : α) => Membership.Mem.{u1, u1} α (Set.{u1} α) (Set.hasMem.{u1} α) x s))) (FreeCommRing.{u1} α) (NonAssocRing.toNonAssocSemiring.{u1} (FreeCommRing.{u1} (Subtype.{succ u1} α (fun (x : α) => Membership.Mem.{u1, u1} α (Set.{u1} α) (Set.hasMem.{u1} α) x s))) (Ring.toNonAssocRing.{u1} (FreeCommRing.{u1} (Subtype.{succ u1} α (fun (x : α) => Membership.Mem.{u1, u1} α (Set.{u1} α) (Set.hasMem.{u1} α) x s))) (CommRing.toRing.{u1} (FreeCommRing.{u1} (Subtype.{succ u1} α (fun (x : α) => Membership.Mem.{u1, u1} α (Set.{u1} α) (Set.hasMem.{u1} α) x s))) (FreeCommRing.instCommRing.{u1} (Subtype.{succ u1} α (fun (x : α) => Membership.Mem.{u1, u1} α (Set.{u1} α) (Set.hasMem.{u1} α) x s)))))) (NonAssocRing.toNonAssocSemiring.{u1} (FreeCommRing.{u1} α) (Ring.toNonAssocRing.{u1} (FreeCommRing.{u1} α) (CommRing.toRing.{u1} (FreeCommRing.{u1} α) (FreeCommRing.instCommRing.{u1} α))))) => (FreeCommRing.{u1} (Subtype.{succ u1} α (fun (x : α) => Membership.Mem.{u1, u1} α (Set.{u1} α) (Set.hasMem.{u1} α) x s))) -> (FreeCommRing.{u1} α)) (RingHom.hasCoeToFun.{u1, u1} (FreeCommRing.{u1} (Subtype.{succ u1} α (fun (x : α) => Membership.Mem.{u1, u1} α (Set.{u1} α) (Set.hasMem.{u1} α) x s))) (FreeCommRing.{u1} α) (NonAssocRing.toNonAssocSemiring.{u1} (FreeCommRing.{u1} (Subtype.{succ u1} α (fun (x : α) => Membership.Mem.{u1, u1} α (Set.{u1} α) (Set.hasMem.{u1} α) x s))) (Ring.toNonAssocRing.{u1} (FreeCommRing.{u1} (Subtype.{succ u1} α (fun (x : α) => Membership.Mem.{u1, u1} α (Set.{u1} α) (Set.hasMem.{u1} α) x s))) (CommRing.toRing.{u1} (FreeCommRing.{u1} (Subtype.{succ u1} α (fun (x : α) => Membership.Mem.{u1, u1} α (Set.{u1} α) (Set.hasMem.{u1} α) x s))) (FreeCommRing.instCommRing.{u1} (Subtype.{succ u1} α (fun (x : α) => Membership.Mem.{u1, u1} α (Set.{u1} α) (Set.hasMem.{u1} α) x s)))))) (NonAssocRing.toNonAssocSemiring.{u1} (FreeCommRing.{u1} α) (Ring.toNonAssocRing.{u1} (FreeCommRing.{u1} α) (CommRing.toRing.{u1} (FreeCommRing.{u1} α) (FreeCommRing.instCommRing.{u1} α))))) (FreeCommRing.map.{u1, u1} (Subtype.{succ u1} α (fun (x : α) => Membership.Mem.{u1, u1} α (Set.{u1} α) (Set.hasMem.{u1} α) x s)) α (Subtype.val.{succ u1} α (fun (x : α) => Membership.Mem.{u1, u1} α (Set.{u1} α) (Set.hasMem.{u1} α) x s))) (coeFn.{succ u1, succ u1} (RingHom.{u1, u1} (FreeCommRing.{u1} α) (FreeCommRing.{u1} (coeSort.{succ u1, succ (succ u1)} (Set.{u1} α) Type.{u1} (Set.hasCoeToSort.{u1} α) s)) (NonAssocRing.toNonAssocSemiring.{u1} (FreeCommRing.{u1} α) (Ring.toNonAssocRing.{u1} (FreeCommRing.{u1} α) (CommRing.toRing.{u1} (FreeCommRing.{u1} α) (FreeCommRing.instCommRing.{u1} α)))) (NonAssocRing.toNonAssocSemiring.{u1} (FreeCommRing.{u1} (coeSort.{succ u1, succ (succ u1)} (Set.{u1} α) Type.{u1} (Set.hasCoeToSort.{u1} α) s)) (Ring.toNonAssocRing.{u1} (FreeCommRing.{u1} (coeSort.{succ u1, succ (succ u1)} (Set.{u1} α) Type.{u1} (Set.hasCoeToSort.{u1} α) s)) (CommRing.toRing.{u1} (FreeCommRing.{u1} (coeSort.{succ u1, succ (succ u1)} (Set.{u1} α) Type.{u1} (Set.hasCoeToSort.{u1} α) s)) (FreeCommRing.instCommRing.{u1} (coeSort.{succ u1, succ (succ u1)} (Set.{u1} α) Type.{u1} (Set.hasCoeToSort.{u1} α) s)))))) (fun (_x : RingHom.{u1, u1} (FreeCommRing.{u1} α) (FreeCommRing.{u1} (coeSort.{succ u1, succ (succ u1)} (Set.{u1} α) Type.{u1} (Set.hasCoeToSort.{u1} α) s)) (NonAssocRing.toNonAssocSemiring.{u1} (FreeCommRing.{u1} α) (Ring.toNonAssocRing.{u1} (FreeCommRing.{u1} α) (CommRing.toRing.{u1} (FreeCommRing.{u1} α) (FreeCommRing.instCommRing.{u1} α)))) (NonAssocRing.toNonAssocSemiring.{u1} (FreeCommRing.{u1} (coeSort.{succ u1, succ (succ u1)} (Set.{u1} α) Type.{u1} (Set.hasCoeToSort.{u1} α) s)) (Ring.toNonAssocRing.{u1} (FreeCommRing.{u1} (coeSort.{succ u1, succ (succ u1)} (Set.{u1} α) Type.{u1} (Set.hasCoeToSort.{u1} α) s)) (CommRing.toRing.{u1} (FreeCommRing.{u1} (coeSort.{succ u1, succ (succ u1)} (Set.{u1} α) Type.{u1} (Set.hasCoeToSort.{u1} α) s)) (FreeCommRing.instCommRing.{u1} (coeSort.{succ u1, succ (succ u1)} (Set.{u1} α) Type.{u1} (Set.hasCoeToSort.{u1} α) s)))))) => (FreeCommRing.{u1} α) -> (FreeCommRing.{u1} (coeSort.{succ u1, succ (succ u1)} (Set.{u1} α) Type.{u1} (Set.hasCoeToSort.{u1} α) s))) (RingHom.hasCoeToFun.{u1, u1} (FreeCommRing.{u1} α) (FreeCommRing.{u1} (coeSort.{succ u1, succ (succ u1)} (Set.{u1} α) Type.{u1} (Set.hasCoeToSort.{u1} α) s)) (NonAssocRing.toNonAssocSemiring.{u1} (FreeCommRing.{u1} α) (Ring.toNonAssocRing.{u1} (FreeCommRing.{u1} α) (CommRing.toRing.{u1} (FreeCommRing.{u1} α) (FreeCommRing.instCommRing.{u1} α)))) (NonAssocRing.toNonAssocSemiring.{u1} (FreeCommRing.{u1} (coeSort.{succ u1, succ (succ u1)} (Set.{u1} α) Type.{u1} (Set.hasCoeToSort.{u1} α) s)) (Ring.toNonAssocRing.{u1} (FreeCommRing.{u1} (coeSort.{succ u1, succ (succ u1)} (Set.{u1} α) Type.{u1} (Set.hasCoeToSort.{u1} α) s)) (CommRing.toRing.{u1} (FreeCommRing.{u1} (coeSort.{succ u1, succ (succ u1)} (Set.{u1} α) Type.{u1} (Set.hasCoeToSort.{u1} α) s)) (FreeCommRing.instCommRing.{u1} (coeSort.{succ u1, succ (succ u1)} (Set.{u1} α) Type.{u1} (Set.hasCoeToSort.{u1} α) s)))))) (FreeCommRing.restriction.{u1} α s (fun (a : α) => _inst_1 a)) x)) x)
 but is expected to have type
-  forall {α : Type.{u1}} {x : FreeCommRing.{u1} α} (s : Set.{u1} α) [_inst_1 : DecidablePred.{succ u1} α (fun (_x : α) => Membership.mem.{u1, u1} α (Set.{u1} α) (Set.instMembershipSet.{u1} α) _x s)], (FreeCommRing.IsSupported.{u1} α x s) -> (Eq.{succ u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : FreeCommRing.{u1} (Set.Elem.{u1} α s)) => FreeCommRing.{u1} α) (FunLike.coe.{succ u1, succ u1, succ u1} (RingHom.{u1, u1} (FreeCommRing.{u1} α) (FreeCommRing.{u1} (Set.Elem.{u1} α s)) (Semiring.toNonAssocSemiring.{u1} (FreeCommRing.{u1} α) (CommSemiring.toSemiring.{u1} (FreeCommRing.{u1} α) (CommRing.toCommSemiring.{u1} (FreeCommRing.{u1} α) (FreeCommRing.instCommRing.{u1} α)))) (Semiring.toNonAssocSemiring.{u1} (FreeCommRing.{u1} (Set.Elem.{u1} α s)) (CommSemiring.toSemiring.{u1} (FreeCommRing.{u1} (Set.Elem.{u1} α s)) (CommRing.toCommSemiring.{u1} (FreeCommRing.{u1} (Set.Elem.{u1} α s)) (FreeCommRing.instCommRing.{u1} (Set.Elem.{u1} α s)))))) (FreeCommRing.{u1} α) (fun (a : FreeCommRing.{u1} α) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : FreeCommRing.{u1} α) => FreeCommRing.{u1} (Set.Elem.{u1} α s)) a) (MulHomClass.toFunLike.{u1, u1, u1} (RingHom.{u1, u1} (FreeCommRing.{u1} α) (FreeCommRing.{u1} (Set.Elem.{u1} α s)) (Semiring.toNonAssocSemiring.{u1} (FreeCommRing.{u1} α) (CommSemiring.toSemiring.{u1} (FreeCommRing.{u1} α) (CommRing.toCommSemiring.{u1} (FreeCommRing.{u1} α) (FreeCommRing.instCommRing.{u1} α)))) (Semiring.toNonAssocSemiring.{u1} (FreeCommRing.{u1} (Set.Elem.{u1} α s)) (CommSemiring.toSemiring.{u1} (FreeCommRing.{u1} (Set.Elem.{u1} α s)) (CommRing.toCommSemiring.{u1} (FreeCommRing.{u1} (Set.Elem.{u1} α s)) (FreeCommRing.instCommRing.{u1} (Set.Elem.{u1} α s)))))) (FreeCommRing.{u1} α) (FreeCommRing.{u1} (Set.Elem.{u1} α s)) (NonUnitalNonAssocSemiring.toMul.{u1} (FreeCommRing.{u1} α) (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u1} (FreeCommRing.{u1} α) (Semiring.toNonAssocSemiring.{u1} (FreeCommRing.{u1} α) (CommSemiring.toSemiring.{u1} (FreeCommRing.{u1} α) (CommRing.toCommSemiring.{u1} (FreeCommRing.{u1} α) (FreeCommRing.instCommRing.{u1} α)))))) (NonUnitalNonAssocSemiring.toMul.{u1} (FreeCommRing.{u1} (Set.Elem.{u1} α s)) (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u1} (FreeCommRing.{u1} (Set.Elem.{u1} α s)) (Semiring.toNonAssocSemiring.{u1} (FreeCommRing.{u1} (Set.Elem.{u1} α s)) (CommSemiring.toSemiring.{u1} (FreeCommRing.{u1} (Set.Elem.{u1} α s)) (CommRing.toCommSemiring.{u1} (FreeCommRing.{u1} (Set.Elem.{u1} α s)) (FreeCommRing.instCommRing.{u1} (Set.Elem.{u1} α s))))))) (NonUnitalRingHomClass.toMulHomClass.{u1, u1, u1} (RingHom.{u1, u1} (FreeCommRing.{u1} α) (FreeCommRing.{u1} (Set.Elem.{u1} α s)) (Semiring.toNonAssocSemiring.{u1} (FreeCommRing.{u1} α) (CommSemiring.toSemiring.{u1} (FreeCommRing.{u1} α) (CommRing.toCommSemiring.{u1} (FreeCommRing.{u1} α) (FreeCommRing.instCommRing.{u1} α)))) (Semiring.toNonAssocSemiring.{u1} (FreeCommRing.{u1} (Set.Elem.{u1} α s)) (CommSemiring.toSemiring.{u1} (FreeCommRing.{u1} (Set.Elem.{u1} α s)) (CommRing.toCommSemiring.{u1} (FreeCommRing.{u1} (Set.Elem.{u1} α s)) (FreeCommRing.instCommRing.{u1} (Set.Elem.{u1} α s)))))) (FreeCommRing.{u1} α) (FreeCommRing.{u1} (Set.Elem.{u1} α s)) (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u1} (FreeCommRing.{u1} α) (Semiring.toNonAssocSemiring.{u1} (FreeCommRing.{u1} α) (CommSemiring.toSemiring.{u1} (FreeCommRing.{u1} α) (CommRing.toCommSemiring.{u1} (FreeCommRing.{u1} α) (FreeCommRing.instCommRing.{u1} α))))) (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u1} (FreeCommRing.{u1} (Set.Elem.{u1} α s)) (Semiring.toNonAssocSemiring.{u1} (FreeCommRing.{u1} (Set.Elem.{u1} α s)) (CommSemiring.toSemiring.{u1} (FreeCommRing.{u1} (Set.Elem.{u1} α s)) (CommRing.toCommSemiring.{u1} (FreeCommRing.{u1} (Set.Elem.{u1} α s)) (FreeCommRing.instCommRing.{u1} (Set.Elem.{u1} α s)))))) (RingHomClass.toNonUnitalRingHomClass.{u1, u1, u1} (RingHom.{u1, u1} (FreeCommRing.{u1} α) (FreeCommRing.{u1} (Set.Elem.{u1} α s)) (Semiring.toNonAssocSemiring.{u1} (FreeCommRing.{u1} α) (CommSemiring.toSemiring.{u1} (FreeCommRing.{u1} α) (CommRing.toCommSemiring.{u1} (FreeCommRing.{u1} α) (FreeCommRing.instCommRing.{u1} α)))) (Semiring.toNonAssocSemiring.{u1} (FreeCommRing.{u1} (Set.Elem.{u1} α s)) (CommSemiring.toSemiring.{u1} (FreeCommRing.{u1} (Set.Elem.{u1} α s)) (CommRing.toCommSemiring.{u1} (FreeCommRing.{u1} (Set.Elem.{u1} α s)) (FreeCommRing.instCommRing.{u1} (Set.Elem.{u1} α s)))))) (FreeCommRing.{u1} α) (FreeCommRing.{u1} (Set.Elem.{u1} α s)) (Semiring.toNonAssocSemiring.{u1} (FreeCommRing.{u1} α) (CommSemiring.toSemiring.{u1} (FreeCommRing.{u1} α) (CommRing.toCommSemiring.{u1} (FreeCommRing.{u1} α) (FreeCommRing.instCommRing.{u1} α)))) (Semiring.toNonAssocSemiring.{u1} (FreeCommRing.{u1} (Set.Elem.{u1} α s)) (CommSemiring.toSemiring.{u1} (FreeCommRing.{u1} (Set.Elem.{u1} α s)) (CommRing.toCommSemiring.{u1} (FreeCommRing.{u1} (Set.Elem.{u1} α s)) (FreeCommRing.instCommRing.{u1} (Set.Elem.{u1} α s))))) (RingHom.instRingHomClassRingHom.{u1, u1} (FreeCommRing.{u1} α) (FreeCommRing.{u1} (Set.Elem.{u1} α s)) (Semiring.toNonAssocSemiring.{u1} (FreeCommRing.{u1} α) (CommSemiring.toSemiring.{u1} (FreeCommRing.{u1} α) (CommRing.toCommSemiring.{u1} (FreeCommRing.{u1} α) (FreeCommRing.instCommRing.{u1} α)))) (Semiring.toNonAssocSemiring.{u1} (FreeCommRing.{u1} (Set.Elem.{u1} α s)) (CommSemiring.toSemiring.{u1} (FreeCommRing.{u1} (Set.Elem.{u1} α s)) (CommRing.toCommSemiring.{u1} (FreeCommRing.{u1} (Set.Elem.{u1} α s)) (FreeCommRing.instCommRing.{u1} (Set.Elem.{u1} α s))))))))) (FreeCommRing.restriction.{u1} α s (fun (a : α) => _inst_1 a)) x)) (FunLike.coe.{succ u1, succ u1, succ u1} (RingHom.{u1, u1} (FreeCommRing.{u1} (Set.Elem.{u1} α s)) (FreeCommRing.{u1} α) (Semiring.toNonAssocSemiring.{u1} (FreeCommRing.{u1} (Set.Elem.{u1} α s)) (CommSemiring.toSemiring.{u1} (FreeCommRing.{u1} (Set.Elem.{u1} α s)) (CommRing.toCommSemiring.{u1} (FreeCommRing.{u1} (Set.Elem.{u1} α s)) (FreeCommRing.instCommRing.{u1} (Set.Elem.{u1} α s))))) (Semiring.toNonAssocSemiring.{u1} (FreeCommRing.{u1} α) (CommSemiring.toSemiring.{u1} (FreeCommRing.{u1} α) (CommRing.toCommSemiring.{u1} (FreeCommRing.{u1} α) (FreeCommRing.instCommRing.{u1} α))))) (FreeCommRing.{u1} (Set.Elem.{u1} α s)) (fun (_x : FreeCommRing.{u1} (Set.Elem.{u1} α s)) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : FreeCommRing.{u1} (Set.Elem.{u1} α s)) => FreeCommRing.{u1} α) _x) (MulHomClass.toFunLike.{u1, u1, u1} (RingHom.{u1, u1} (FreeCommRing.{u1} (Set.Elem.{u1} α s)) (FreeCommRing.{u1} α) (Semiring.toNonAssocSemiring.{u1} (FreeCommRing.{u1} (Set.Elem.{u1} α s)) (CommSemiring.toSemiring.{u1} (FreeCommRing.{u1} (Set.Elem.{u1} α s)) (CommRing.toCommSemiring.{u1} (FreeCommRing.{u1} (Set.Elem.{u1} α s)) (FreeCommRing.instCommRing.{u1} (Set.Elem.{u1} α s))))) (Semiring.toNonAssocSemiring.{u1} (FreeCommRing.{u1} α) (CommSemiring.toSemiring.{u1} (FreeCommRing.{u1} α) (CommRing.toCommSemiring.{u1} (FreeCommRing.{u1} α) (FreeCommRing.instCommRing.{u1} α))))) (FreeCommRing.{u1} (Set.Elem.{u1} α s)) (FreeCommRing.{u1} α) (NonUnitalNonAssocSemiring.toMul.{u1} (FreeCommRing.{u1} (Set.Elem.{u1} α s)) (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u1} (FreeCommRing.{u1} (Set.Elem.{u1} α s)) (Semiring.toNonAssocSemiring.{u1} (FreeCommRing.{u1} (Set.Elem.{u1} α s)) (CommSemiring.toSemiring.{u1} (FreeCommRing.{u1} (Set.Elem.{u1} α s)) (CommRing.toCommSemiring.{u1} (FreeCommRing.{u1} (Set.Elem.{u1} α s)) (FreeCommRing.instCommRing.{u1} (Set.Elem.{u1} α s))))))) (NonUnitalNonAssocSemiring.toMul.{u1} (FreeCommRing.{u1} α) (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u1} (FreeCommRing.{u1} α) (Semiring.toNonAssocSemiring.{u1} (FreeCommRing.{u1} α) (CommSemiring.toSemiring.{u1} (FreeCommRing.{u1} α) (CommRing.toCommSemiring.{u1} (FreeCommRing.{u1} α) (FreeCommRing.instCommRing.{u1} α)))))) (NonUnitalRingHomClass.toMulHomClass.{u1, u1, u1} (RingHom.{u1, u1} (FreeCommRing.{u1} (Set.Elem.{u1} α s)) (FreeCommRing.{u1} α) (Semiring.toNonAssocSemiring.{u1} (FreeCommRing.{u1} (Set.Elem.{u1} α s)) (CommSemiring.toSemiring.{u1} (FreeCommRing.{u1} (Set.Elem.{u1} α s)) (CommRing.toCommSemiring.{u1} (FreeCommRing.{u1} (Set.Elem.{u1} α s)) (FreeCommRing.instCommRing.{u1} (Set.Elem.{u1} α s))))) (Semiring.toNonAssocSemiring.{u1} (FreeCommRing.{u1} α) (CommSemiring.toSemiring.{u1} (FreeCommRing.{u1} α) (CommRing.toCommSemiring.{u1} (FreeCommRing.{u1} α) (FreeCommRing.instCommRing.{u1} α))))) (FreeCommRing.{u1} (Set.Elem.{u1} α s)) (FreeCommRing.{u1} α) (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u1} (FreeCommRing.{u1} (Set.Elem.{u1} α s)) (Semiring.toNonAssocSemiring.{u1} (FreeCommRing.{u1} (Set.Elem.{u1} α s)) (CommSemiring.toSemiring.{u1} (FreeCommRing.{u1} (Set.Elem.{u1} α s)) (CommRing.toCommSemiring.{u1} (FreeCommRing.{u1} (Set.Elem.{u1} α s)) (FreeCommRing.instCommRing.{u1} (Set.Elem.{u1} α s)))))) (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u1} (FreeCommRing.{u1} α) (Semiring.toNonAssocSemiring.{u1} (FreeCommRing.{u1} α) (CommSemiring.toSemiring.{u1} (FreeCommRing.{u1} α) (CommRing.toCommSemiring.{u1} (FreeCommRing.{u1} α) (FreeCommRing.instCommRing.{u1} α))))) (RingHomClass.toNonUnitalRingHomClass.{u1, u1, u1} (RingHom.{u1, u1} (FreeCommRing.{u1} (Set.Elem.{u1} α s)) (FreeCommRing.{u1} α) (Semiring.toNonAssocSemiring.{u1} (FreeCommRing.{u1} (Set.Elem.{u1} α s)) (CommSemiring.toSemiring.{u1} (FreeCommRing.{u1} (Set.Elem.{u1} α s)) (CommRing.toCommSemiring.{u1} (FreeCommRing.{u1} (Set.Elem.{u1} α s)) (FreeCommRing.instCommRing.{u1} (Set.Elem.{u1} α s))))) (Semiring.toNonAssocSemiring.{u1} (FreeCommRing.{u1} α) (CommSemiring.toSemiring.{u1} (FreeCommRing.{u1} α) (CommRing.toCommSemiring.{u1} (FreeCommRing.{u1} α) (FreeCommRing.instCommRing.{u1} α))))) (FreeCommRing.{u1} (Set.Elem.{u1} α s)) (FreeCommRing.{u1} α) (Semiring.toNonAssocSemiring.{u1} (FreeCommRing.{u1} (Set.Elem.{u1} α s)) (CommSemiring.toSemiring.{u1} (FreeCommRing.{u1} (Set.Elem.{u1} α s)) (CommRing.toCommSemiring.{u1} (FreeCommRing.{u1} (Set.Elem.{u1} α s)) (FreeCommRing.instCommRing.{u1} (Set.Elem.{u1} α s))))) (Semiring.toNonAssocSemiring.{u1} (FreeCommRing.{u1} α) (CommSemiring.toSemiring.{u1} (FreeCommRing.{u1} α) (CommRing.toCommSemiring.{u1} (FreeCommRing.{u1} α) (FreeCommRing.instCommRing.{u1} α)))) (RingHom.instRingHomClassRingHom.{u1, u1} (FreeCommRing.{u1} (Set.Elem.{u1} α s)) (FreeCommRing.{u1} α) (Semiring.toNonAssocSemiring.{u1} (FreeCommRing.{u1} (Set.Elem.{u1} α s)) (CommSemiring.toSemiring.{u1} (FreeCommRing.{u1} (Set.Elem.{u1} α s)) (CommRing.toCommSemiring.{u1} (FreeCommRing.{u1} (Set.Elem.{u1} α s)) (FreeCommRing.instCommRing.{u1} (Set.Elem.{u1} α s))))) (Semiring.toNonAssocSemiring.{u1} (FreeCommRing.{u1} α) (CommSemiring.toSemiring.{u1} (FreeCommRing.{u1} α) (CommRing.toCommSemiring.{u1} (FreeCommRing.{u1} α) (FreeCommRing.instCommRing.{u1} α)))))))) (FreeCommRing.map.{u1, u1} (Set.Elem.{u1} α s) α (Subtype.val.{succ u1} α (fun (x : α) => Membership.mem.{u1, u1} α (Set.{u1} α) (Set.instMembershipSet.{u1} α) x s))) (FunLike.coe.{succ u1, succ u1, succ u1} (RingHom.{u1, u1} (FreeCommRing.{u1} α) (FreeCommRing.{u1} (Set.Elem.{u1} α s)) (Semiring.toNonAssocSemiring.{u1} (FreeCommRing.{u1} α) (CommSemiring.toSemiring.{u1} (FreeCommRing.{u1} α) (CommRing.toCommSemiring.{u1} (FreeCommRing.{u1} α) (FreeCommRing.instCommRing.{u1} α)))) (Semiring.toNonAssocSemiring.{u1} (FreeCommRing.{u1} (Set.Elem.{u1} α s)) (CommSemiring.toSemiring.{u1} (FreeCommRing.{u1} (Set.Elem.{u1} α s)) (CommRing.toCommSemiring.{u1} (FreeCommRing.{u1} (Set.Elem.{u1} α s)) (FreeCommRing.instCommRing.{u1} (Set.Elem.{u1} α s)))))) (FreeCommRing.{u1} α) (fun (_x : FreeCommRing.{u1} α) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : FreeCommRing.{u1} α) => FreeCommRing.{u1} (Set.Elem.{u1} α s)) _x) (MulHomClass.toFunLike.{u1, u1, u1} (RingHom.{u1, u1} (FreeCommRing.{u1} α) (FreeCommRing.{u1} (Set.Elem.{u1} α s)) (Semiring.toNonAssocSemiring.{u1} (FreeCommRing.{u1} α) (CommSemiring.toSemiring.{u1} (FreeCommRing.{u1} α) (CommRing.toCommSemiring.{u1} (FreeCommRing.{u1} α) (FreeCommRing.instCommRing.{u1} α)))) (Semiring.toNonAssocSemiring.{u1} (FreeCommRing.{u1} (Set.Elem.{u1} α s)) (CommSemiring.toSemiring.{u1} (FreeCommRing.{u1} (Set.Elem.{u1} α s)) (CommRing.toCommSemiring.{u1} (FreeCommRing.{u1} (Set.Elem.{u1} α s)) (FreeCommRing.instCommRing.{u1} (Set.Elem.{u1} α s)))))) (FreeCommRing.{u1} α) (FreeCommRing.{u1} (Set.Elem.{u1} α s)) (NonUnitalNonAssocSemiring.toMul.{u1} (FreeCommRing.{u1} α) (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u1} (FreeCommRing.{u1} α) (Semiring.toNonAssocSemiring.{u1} (FreeCommRing.{u1} α) (CommSemiring.toSemiring.{u1} (FreeCommRing.{u1} α) (CommRing.toCommSemiring.{u1} (FreeCommRing.{u1} α) (FreeCommRing.instCommRing.{u1} α)))))) (NonUnitalNonAssocSemiring.toMul.{u1} (FreeCommRing.{u1} (Set.Elem.{u1} α s)) (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u1} (FreeCommRing.{u1} (Set.Elem.{u1} α s)) (Semiring.toNonAssocSemiring.{u1} (FreeCommRing.{u1} (Set.Elem.{u1} α s)) (CommSemiring.toSemiring.{u1} (FreeCommRing.{u1} (Set.Elem.{u1} α s)) (CommRing.toCommSemiring.{u1} (FreeCommRing.{u1} (Set.Elem.{u1} α s)) (FreeCommRing.instCommRing.{u1} (Set.Elem.{u1} α s))))))) (NonUnitalRingHomClass.toMulHomClass.{u1, u1, u1} (RingHom.{u1, u1} (FreeCommRing.{u1} α) (FreeCommRing.{u1} (Set.Elem.{u1} α s)) (Semiring.toNonAssocSemiring.{u1} (FreeCommRing.{u1} α) (CommSemiring.toSemiring.{u1} (FreeCommRing.{u1} α) (CommRing.toCommSemiring.{u1} (FreeCommRing.{u1} α) (FreeCommRing.instCommRing.{u1} α)))) (Semiring.toNonAssocSemiring.{u1} (FreeCommRing.{u1} (Set.Elem.{u1} α s)) (CommSemiring.toSemiring.{u1} (FreeCommRing.{u1} (Set.Elem.{u1} α s)) (CommRing.toCommSemiring.{u1} (FreeCommRing.{u1} (Set.Elem.{u1} α s)) (FreeCommRing.instCommRing.{u1} (Set.Elem.{u1} α s)))))) (FreeCommRing.{u1} α) (FreeCommRing.{u1} (Set.Elem.{u1} α s)) (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u1} (FreeCommRing.{u1} α) (Semiring.toNonAssocSemiring.{u1} (FreeCommRing.{u1} α) (CommSemiring.toSemiring.{u1} (FreeCommRing.{u1} α) (CommRing.toCommSemiring.{u1} (FreeCommRing.{u1} α) (FreeCommRing.instCommRing.{u1} α))))) (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u1} (FreeCommRing.{u1} (Set.Elem.{u1} α s)) (Semiring.toNonAssocSemiring.{u1} (FreeCommRing.{u1} (Set.Elem.{u1} α s)) (CommSemiring.toSemiring.{u1} (FreeCommRing.{u1} (Set.Elem.{u1} α s)) (CommRing.toCommSemiring.{u1} (FreeCommRing.{u1} (Set.Elem.{u1} α s)) (FreeCommRing.instCommRing.{u1} (Set.Elem.{u1} α s)))))) (RingHomClass.toNonUnitalRingHomClass.{u1, u1, u1} (RingHom.{u1, u1} (FreeCommRing.{u1} α) (FreeCommRing.{u1} (Set.Elem.{u1} α s)) (Semiring.toNonAssocSemiring.{u1} (FreeCommRing.{u1} α) (CommSemiring.toSemiring.{u1} (FreeCommRing.{u1} α) (CommRing.toCommSemiring.{u1} (FreeCommRing.{u1} α) (FreeCommRing.instCommRing.{u1} α)))) (Semiring.toNonAssocSemiring.{u1} (FreeCommRing.{u1} (Set.Elem.{u1} α s)) (CommSemiring.toSemiring.{u1} (FreeCommRing.{u1} (Set.Elem.{u1} α s)) (CommRing.toCommSemiring.{u1} (FreeCommRing.{u1} (Set.Elem.{u1} α s)) (FreeCommRing.instCommRing.{u1} (Set.Elem.{u1} α s)))))) (FreeCommRing.{u1} α) (FreeCommRing.{u1} (Set.Elem.{u1} α s)) (Semiring.toNonAssocSemiring.{u1} (FreeCommRing.{u1} α) (CommSemiring.toSemiring.{u1} (FreeCommRing.{u1} α) (CommRing.toCommSemiring.{u1} (FreeCommRing.{u1} α) (FreeCommRing.instCommRing.{u1} α)))) (Semiring.toNonAssocSemiring.{u1} (FreeCommRing.{u1} (Set.Elem.{u1} α s)) (CommSemiring.toSemiring.{u1} (FreeCommRing.{u1} (Set.Elem.{u1} α s)) (CommRing.toCommSemiring.{u1} (FreeCommRing.{u1} (Set.Elem.{u1} α s)) (FreeCommRing.instCommRing.{u1} (Set.Elem.{u1} α s))))) (RingHom.instRingHomClassRingHom.{u1, u1} (FreeCommRing.{u1} α) (FreeCommRing.{u1} (Set.Elem.{u1} α s)) (Semiring.toNonAssocSemiring.{u1} (FreeCommRing.{u1} α) (CommSemiring.toSemiring.{u1} (FreeCommRing.{u1} α) (CommRing.toCommSemiring.{u1} (FreeCommRing.{u1} α) (FreeCommRing.instCommRing.{u1} α)))) (Semiring.toNonAssocSemiring.{u1} (FreeCommRing.{u1} (Set.Elem.{u1} α s)) (CommSemiring.toSemiring.{u1} (FreeCommRing.{u1} (Set.Elem.{u1} α s)) (CommRing.toCommSemiring.{u1} (FreeCommRing.{u1} (Set.Elem.{u1} α s)) (FreeCommRing.instCommRing.{u1} (Set.Elem.{u1} α s))))))))) (FreeCommRing.restriction.{u1} α s (fun (a : α) => _inst_1 a)) x)) x)
+  forall {α : Type.{u1}} {x : FreeCommRing.{u1} α} (s : Set.{u1} α) [_inst_1 : DecidablePred.{succ u1} α (fun (_x : α) => Membership.mem.{u1, u1} α (Set.{u1} α) (Set.instMembershipSet.{u1} α) _x s)], (FreeCommRing.IsSupported.{u1} α x s) -> (Eq.{succ u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2397 : FreeCommRing.{u1} (Set.Elem.{u1} α s)) => FreeCommRing.{u1} α) (FunLike.coe.{succ u1, succ u1, succ u1} (RingHom.{u1, u1} (FreeCommRing.{u1} α) (FreeCommRing.{u1} (Set.Elem.{u1} α s)) (Semiring.toNonAssocSemiring.{u1} (FreeCommRing.{u1} α) (CommSemiring.toSemiring.{u1} (FreeCommRing.{u1} α) (CommRing.toCommSemiring.{u1} (FreeCommRing.{u1} α) (FreeCommRing.instCommRing.{u1} α)))) (Semiring.toNonAssocSemiring.{u1} (FreeCommRing.{u1} (Set.Elem.{u1} α s)) (CommSemiring.toSemiring.{u1} (FreeCommRing.{u1} (Set.Elem.{u1} α s)) (CommRing.toCommSemiring.{u1} (FreeCommRing.{u1} (Set.Elem.{u1} α s)) (FreeCommRing.instCommRing.{u1} (Set.Elem.{u1} α s)))))) (FreeCommRing.{u1} α) (fun (a : FreeCommRing.{u1} α) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2397 : FreeCommRing.{u1} α) => FreeCommRing.{u1} (Set.Elem.{u1} α s)) a) (MulHomClass.toFunLike.{u1, u1, u1} (RingHom.{u1, u1} (FreeCommRing.{u1} α) (FreeCommRing.{u1} (Set.Elem.{u1} α s)) (Semiring.toNonAssocSemiring.{u1} (FreeCommRing.{u1} α) (CommSemiring.toSemiring.{u1} (FreeCommRing.{u1} α) (CommRing.toCommSemiring.{u1} (FreeCommRing.{u1} α) (FreeCommRing.instCommRing.{u1} α)))) (Semiring.toNonAssocSemiring.{u1} (FreeCommRing.{u1} (Set.Elem.{u1} α s)) (CommSemiring.toSemiring.{u1} (FreeCommRing.{u1} (Set.Elem.{u1} α s)) (CommRing.toCommSemiring.{u1} (FreeCommRing.{u1} (Set.Elem.{u1} α s)) (FreeCommRing.instCommRing.{u1} (Set.Elem.{u1} α s)))))) (FreeCommRing.{u1} α) (FreeCommRing.{u1} (Set.Elem.{u1} α s)) (NonUnitalNonAssocSemiring.toMul.{u1} (FreeCommRing.{u1} α) (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u1} (FreeCommRing.{u1} α) (Semiring.toNonAssocSemiring.{u1} (FreeCommRing.{u1} α) (CommSemiring.toSemiring.{u1} (FreeCommRing.{u1} α) (CommRing.toCommSemiring.{u1} (FreeCommRing.{u1} α) (FreeCommRing.instCommRing.{u1} α)))))) (NonUnitalNonAssocSemiring.toMul.{u1} (FreeCommRing.{u1} (Set.Elem.{u1} α s)) (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u1} (FreeCommRing.{u1} (Set.Elem.{u1} α s)) (Semiring.toNonAssocSemiring.{u1} (FreeCommRing.{u1} (Set.Elem.{u1} α s)) (CommSemiring.toSemiring.{u1} (FreeCommRing.{u1} (Set.Elem.{u1} α s)) (CommRing.toCommSemiring.{u1} (FreeCommRing.{u1} (Set.Elem.{u1} α s)) (FreeCommRing.instCommRing.{u1} (Set.Elem.{u1} α s))))))) (NonUnitalRingHomClass.toMulHomClass.{u1, u1, u1} (RingHom.{u1, u1} (FreeCommRing.{u1} α) (FreeCommRing.{u1} (Set.Elem.{u1} α s)) (Semiring.toNonAssocSemiring.{u1} (FreeCommRing.{u1} α) (CommSemiring.toSemiring.{u1} (FreeCommRing.{u1} α) (CommRing.toCommSemiring.{u1} (FreeCommRing.{u1} α) (FreeCommRing.instCommRing.{u1} α)))) (Semiring.toNonAssocSemiring.{u1} (FreeCommRing.{u1} (Set.Elem.{u1} α s)) (CommSemiring.toSemiring.{u1} (FreeCommRing.{u1} (Set.Elem.{u1} α s)) (CommRing.toCommSemiring.{u1} (FreeCommRing.{u1} (Set.Elem.{u1} α s)) (FreeCommRing.instCommRing.{u1} (Set.Elem.{u1} α s)))))) (FreeCommRing.{u1} α) (FreeCommRing.{u1} (Set.Elem.{u1} α s)) (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u1} (FreeCommRing.{u1} α) (Semiring.toNonAssocSemiring.{u1} (FreeCommRing.{u1} α) (CommSemiring.toSemiring.{u1} (FreeCommRing.{u1} α) (CommRing.toCommSemiring.{u1} (FreeCommRing.{u1} α) (FreeCommRing.instCommRing.{u1} α))))) (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u1} (FreeCommRing.{u1} (Set.Elem.{u1} α s)) (Semiring.toNonAssocSemiring.{u1} (FreeCommRing.{u1} (Set.Elem.{u1} α s)) (CommSemiring.toSemiring.{u1} (FreeCommRing.{u1} (Set.Elem.{u1} α s)) (CommRing.toCommSemiring.{u1} (FreeCommRing.{u1} (Set.Elem.{u1} α s)) (FreeCommRing.instCommRing.{u1} (Set.Elem.{u1} α s)))))) (RingHomClass.toNonUnitalRingHomClass.{u1, u1, u1} (RingHom.{u1, u1} (FreeCommRing.{u1} α) (FreeCommRing.{u1} (Set.Elem.{u1} α s)) (Semiring.toNonAssocSemiring.{u1} (FreeCommRing.{u1} α) (CommSemiring.toSemiring.{u1} (FreeCommRing.{u1} α) (CommRing.toCommSemiring.{u1} (FreeCommRing.{u1} α) (FreeCommRing.instCommRing.{u1} α)))) (Semiring.toNonAssocSemiring.{u1} (FreeCommRing.{u1} (Set.Elem.{u1} α s)) (CommSemiring.toSemiring.{u1} (FreeCommRing.{u1} (Set.Elem.{u1} α s)) (CommRing.toCommSemiring.{u1} (FreeCommRing.{u1} (Set.Elem.{u1} α s)) (FreeCommRing.instCommRing.{u1} (Set.Elem.{u1} α s)))))) (FreeCommRing.{u1} α) (FreeCommRing.{u1} (Set.Elem.{u1} α s)) (Semiring.toNonAssocSemiring.{u1} (FreeCommRing.{u1} α) (CommSemiring.toSemiring.{u1} (FreeCommRing.{u1} α) (CommRing.toCommSemiring.{u1} (FreeCommRing.{u1} α) (FreeCommRing.instCommRing.{u1} α)))) (Semiring.toNonAssocSemiring.{u1} (FreeCommRing.{u1} (Set.Elem.{u1} α s)) (CommSemiring.toSemiring.{u1} (FreeCommRing.{u1} (Set.Elem.{u1} α s)) (CommRing.toCommSemiring.{u1} (FreeCommRing.{u1} (Set.Elem.{u1} α s)) (FreeCommRing.instCommRing.{u1} (Set.Elem.{u1} α s))))) (RingHom.instRingHomClassRingHom.{u1, u1} (FreeCommRing.{u1} α) (FreeCommRing.{u1} (Set.Elem.{u1} α s)) (Semiring.toNonAssocSemiring.{u1} (FreeCommRing.{u1} α) (CommSemiring.toSemiring.{u1} (FreeCommRing.{u1} α) (CommRing.toCommSemiring.{u1} (FreeCommRing.{u1} α) (FreeCommRing.instCommRing.{u1} α)))) (Semiring.toNonAssocSemiring.{u1} (FreeCommRing.{u1} (Set.Elem.{u1} α s)) (CommSemiring.toSemiring.{u1} (FreeCommRing.{u1} (Set.Elem.{u1} α s)) (CommRing.toCommSemiring.{u1} (FreeCommRing.{u1} (Set.Elem.{u1} α s)) (FreeCommRing.instCommRing.{u1} (Set.Elem.{u1} α s))))))))) (FreeCommRing.restriction.{u1} α s (fun (a : α) => _inst_1 a)) x)) (FunLike.coe.{succ u1, succ u1, succ u1} (RingHom.{u1, u1} (FreeCommRing.{u1} (Set.Elem.{u1} α s)) (FreeCommRing.{u1} α) (Semiring.toNonAssocSemiring.{u1} (FreeCommRing.{u1} (Set.Elem.{u1} α s)) (CommSemiring.toSemiring.{u1} (FreeCommRing.{u1} (Set.Elem.{u1} α s)) (CommRing.toCommSemiring.{u1} (FreeCommRing.{u1} (Set.Elem.{u1} α s)) (FreeCommRing.instCommRing.{u1} (Set.Elem.{u1} α s))))) (Semiring.toNonAssocSemiring.{u1} (FreeCommRing.{u1} α) (CommSemiring.toSemiring.{u1} (FreeCommRing.{u1} α) (CommRing.toCommSemiring.{u1} (FreeCommRing.{u1} α) (FreeCommRing.instCommRing.{u1} α))))) (FreeCommRing.{u1} (Set.Elem.{u1} α s)) (fun (_x : FreeCommRing.{u1} (Set.Elem.{u1} α s)) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2397 : FreeCommRing.{u1} (Set.Elem.{u1} α s)) => FreeCommRing.{u1} α) _x) (MulHomClass.toFunLike.{u1, u1, u1} (RingHom.{u1, u1} (FreeCommRing.{u1} (Set.Elem.{u1} α s)) (FreeCommRing.{u1} α) (Semiring.toNonAssocSemiring.{u1} (FreeCommRing.{u1} (Set.Elem.{u1} α s)) (CommSemiring.toSemiring.{u1} (FreeCommRing.{u1} (Set.Elem.{u1} α s)) (CommRing.toCommSemiring.{u1} (FreeCommRing.{u1} (Set.Elem.{u1} α s)) (FreeCommRing.instCommRing.{u1} (Set.Elem.{u1} α s))))) (Semiring.toNonAssocSemiring.{u1} (FreeCommRing.{u1} α) (CommSemiring.toSemiring.{u1} (FreeCommRing.{u1} α) (CommRing.toCommSemiring.{u1} (FreeCommRing.{u1} α) (FreeCommRing.instCommRing.{u1} α))))) (FreeCommRing.{u1} (Set.Elem.{u1} α s)) (FreeCommRing.{u1} α) (NonUnitalNonAssocSemiring.toMul.{u1} (FreeCommRing.{u1} (Set.Elem.{u1} α s)) (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u1} (FreeCommRing.{u1} (Set.Elem.{u1} α s)) (Semiring.toNonAssocSemiring.{u1} (FreeCommRing.{u1} (Set.Elem.{u1} α s)) (CommSemiring.toSemiring.{u1} (FreeCommRing.{u1} (Set.Elem.{u1} α s)) (CommRing.toCommSemiring.{u1} (FreeCommRing.{u1} (Set.Elem.{u1} α s)) (FreeCommRing.instCommRing.{u1} (Set.Elem.{u1} α s))))))) (NonUnitalNonAssocSemiring.toMul.{u1} (FreeCommRing.{u1} α) (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u1} (FreeCommRing.{u1} α) (Semiring.toNonAssocSemiring.{u1} (FreeCommRing.{u1} α) (CommSemiring.toSemiring.{u1} (FreeCommRing.{u1} α) (CommRing.toCommSemiring.{u1} (FreeCommRing.{u1} α) (FreeCommRing.instCommRing.{u1} α)))))) (NonUnitalRingHomClass.toMulHomClass.{u1, u1, u1} (RingHom.{u1, u1} (FreeCommRing.{u1} (Set.Elem.{u1} α s)) (FreeCommRing.{u1} α) (Semiring.toNonAssocSemiring.{u1} (FreeCommRing.{u1} (Set.Elem.{u1} α s)) (CommSemiring.toSemiring.{u1} (FreeCommRing.{u1} (Set.Elem.{u1} α s)) (CommRing.toCommSemiring.{u1} (FreeCommRing.{u1} (Set.Elem.{u1} α s)) (FreeCommRing.instCommRing.{u1} (Set.Elem.{u1} α s))))) (Semiring.toNonAssocSemiring.{u1} (FreeCommRing.{u1} α) (CommSemiring.toSemiring.{u1} (FreeCommRing.{u1} α) (CommRing.toCommSemiring.{u1} (FreeCommRing.{u1} α) (FreeCommRing.instCommRing.{u1} α))))) (FreeCommRing.{u1} (Set.Elem.{u1} α s)) (FreeCommRing.{u1} α) (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u1} (FreeCommRing.{u1} (Set.Elem.{u1} α s)) (Semiring.toNonAssocSemiring.{u1} (FreeCommRing.{u1} (Set.Elem.{u1} α s)) (CommSemiring.toSemiring.{u1} (FreeCommRing.{u1} (Set.Elem.{u1} α s)) (CommRing.toCommSemiring.{u1} (FreeCommRing.{u1} (Set.Elem.{u1} α s)) (FreeCommRing.instCommRing.{u1} (Set.Elem.{u1} α s)))))) (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u1} (FreeCommRing.{u1} α) (Semiring.toNonAssocSemiring.{u1} (FreeCommRing.{u1} α) (CommSemiring.toSemiring.{u1} (FreeCommRing.{u1} α) (CommRing.toCommSemiring.{u1} (FreeCommRing.{u1} α) (FreeCommRing.instCommRing.{u1} α))))) (RingHomClass.toNonUnitalRingHomClass.{u1, u1, u1} (RingHom.{u1, u1} (FreeCommRing.{u1} (Set.Elem.{u1} α s)) (FreeCommRing.{u1} α) (Semiring.toNonAssocSemiring.{u1} (FreeCommRing.{u1} (Set.Elem.{u1} α s)) (CommSemiring.toSemiring.{u1} (FreeCommRing.{u1} (Set.Elem.{u1} α s)) (CommRing.toCommSemiring.{u1} (FreeCommRing.{u1} (Set.Elem.{u1} α s)) (FreeCommRing.instCommRing.{u1} (Set.Elem.{u1} α s))))) (Semiring.toNonAssocSemiring.{u1} (FreeCommRing.{u1} α) (CommSemiring.toSemiring.{u1} (FreeCommRing.{u1} α) (CommRing.toCommSemiring.{u1} (FreeCommRing.{u1} α) (FreeCommRing.instCommRing.{u1} α))))) (FreeCommRing.{u1} (Set.Elem.{u1} α s)) (FreeCommRing.{u1} α) (Semiring.toNonAssocSemiring.{u1} (FreeCommRing.{u1} (Set.Elem.{u1} α s)) (CommSemiring.toSemiring.{u1} (FreeCommRing.{u1} (Set.Elem.{u1} α s)) (CommRing.toCommSemiring.{u1} (FreeCommRing.{u1} (Set.Elem.{u1} α s)) (FreeCommRing.instCommRing.{u1} (Set.Elem.{u1} α s))))) (Semiring.toNonAssocSemiring.{u1} (FreeCommRing.{u1} α) (CommSemiring.toSemiring.{u1} (FreeCommRing.{u1} α) (CommRing.toCommSemiring.{u1} (FreeCommRing.{u1} α) (FreeCommRing.instCommRing.{u1} α)))) (RingHom.instRingHomClassRingHom.{u1, u1} (FreeCommRing.{u1} (Set.Elem.{u1} α s)) (FreeCommRing.{u1} α) (Semiring.toNonAssocSemiring.{u1} (FreeCommRing.{u1} (Set.Elem.{u1} α s)) (CommSemiring.toSemiring.{u1} (FreeCommRing.{u1} (Set.Elem.{u1} α s)) (CommRing.toCommSemiring.{u1} (FreeCommRing.{u1} (Set.Elem.{u1} α s)) (FreeCommRing.instCommRing.{u1} (Set.Elem.{u1} α s))))) (Semiring.toNonAssocSemiring.{u1} (FreeCommRing.{u1} α) (CommSemiring.toSemiring.{u1} (FreeCommRing.{u1} α) (CommRing.toCommSemiring.{u1} (FreeCommRing.{u1} α) (FreeCommRing.instCommRing.{u1} α)))))))) (FreeCommRing.map.{u1, u1} (Set.Elem.{u1} α s) α (Subtype.val.{succ u1} α (fun (x : α) => Membership.mem.{u1, u1} α (Set.{u1} α) (Set.instMembershipSet.{u1} α) x s))) (FunLike.coe.{succ u1, succ u1, succ u1} (RingHom.{u1, u1} (FreeCommRing.{u1} α) (FreeCommRing.{u1} (Set.Elem.{u1} α s)) (Semiring.toNonAssocSemiring.{u1} (FreeCommRing.{u1} α) (CommSemiring.toSemiring.{u1} (FreeCommRing.{u1} α) (CommRing.toCommSemiring.{u1} (FreeCommRing.{u1} α) (FreeCommRing.instCommRing.{u1} α)))) (Semiring.toNonAssocSemiring.{u1} (FreeCommRing.{u1} (Set.Elem.{u1} α s)) (CommSemiring.toSemiring.{u1} (FreeCommRing.{u1} (Set.Elem.{u1} α s)) (CommRing.toCommSemiring.{u1} (FreeCommRing.{u1} (Set.Elem.{u1} α s)) (FreeCommRing.instCommRing.{u1} (Set.Elem.{u1} α s)))))) (FreeCommRing.{u1} α) (fun (_x : FreeCommRing.{u1} α) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2397 : FreeCommRing.{u1} α) => FreeCommRing.{u1} (Set.Elem.{u1} α s)) _x) (MulHomClass.toFunLike.{u1, u1, u1} (RingHom.{u1, u1} (FreeCommRing.{u1} α) (FreeCommRing.{u1} (Set.Elem.{u1} α s)) (Semiring.toNonAssocSemiring.{u1} (FreeCommRing.{u1} α) (CommSemiring.toSemiring.{u1} (FreeCommRing.{u1} α) (CommRing.toCommSemiring.{u1} (FreeCommRing.{u1} α) (FreeCommRing.instCommRing.{u1} α)))) (Semiring.toNonAssocSemiring.{u1} (FreeCommRing.{u1} (Set.Elem.{u1} α s)) (CommSemiring.toSemiring.{u1} (FreeCommRing.{u1} (Set.Elem.{u1} α s)) (CommRing.toCommSemiring.{u1} (FreeCommRing.{u1} (Set.Elem.{u1} α s)) (FreeCommRing.instCommRing.{u1} (Set.Elem.{u1} α s)))))) (FreeCommRing.{u1} α) (FreeCommRing.{u1} (Set.Elem.{u1} α s)) (NonUnitalNonAssocSemiring.toMul.{u1} (FreeCommRing.{u1} α) (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u1} (FreeCommRing.{u1} α) (Semiring.toNonAssocSemiring.{u1} (FreeCommRing.{u1} α) (CommSemiring.toSemiring.{u1} (FreeCommRing.{u1} α) (CommRing.toCommSemiring.{u1} (FreeCommRing.{u1} α) (FreeCommRing.instCommRing.{u1} α)))))) (NonUnitalNonAssocSemiring.toMul.{u1} (FreeCommRing.{u1} (Set.Elem.{u1} α s)) (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u1} (FreeCommRing.{u1} (Set.Elem.{u1} α s)) (Semiring.toNonAssocSemiring.{u1} (FreeCommRing.{u1} (Set.Elem.{u1} α s)) (CommSemiring.toSemiring.{u1} (FreeCommRing.{u1} (Set.Elem.{u1} α s)) (CommRing.toCommSemiring.{u1} (FreeCommRing.{u1} (Set.Elem.{u1} α s)) (FreeCommRing.instCommRing.{u1} (Set.Elem.{u1} α s))))))) (NonUnitalRingHomClass.toMulHomClass.{u1, u1, u1} (RingHom.{u1, u1} (FreeCommRing.{u1} α) (FreeCommRing.{u1} (Set.Elem.{u1} α s)) (Semiring.toNonAssocSemiring.{u1} (FreeCommRing.{u1} α) (CommSemiring.toSemiring.{u1} (FreeCommRing.{u1} α) (CommRing.toCommSemiring.{u1} (FreeCommRing.{u1} α) (FreeCommRing.instCommRing.{u1} α)))) (Semiring.toNonAssocSemiring.{u1} (FreeCommRing.{u1} (Set.Elem.{u1} α s)) (CommSemiring.toSemiring.{u1} (FreeCommRing.{u1} (Set.Elem.{u1} α s)) (CommRing.toCommSemiring.{u1} (FreeCommRing.{u1} (Set.Elem.{u1} α s)) (FreeCommRing.instCommRing.{u1} (Set.Elem.{u1} α s)))))) (FreeCommRing.{u1} α) (FreeCommRing.{u1} (Set.Elem.{u1} α s)) (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u1} (FreeCommRing.{u1} α) (Semiring.toNonAssocSemiring.{u1} (FreeCommRing.{u1} α) (CommSemiring.toSemiring.{u1} (FreeCommRing.{u1} α) (CommRing.toCommSemiring.{u1} (FreeCommRing.{u1} α) (FreeCommRing.instCommRing.{u1} α))))) (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u1} (FreeCommRing.{u1} (Set.Elem.{u1} α s)) (Semiring.toNonAssocSemiring.{u1} (FreeCommRing.{u1} (Set.Elem.{u1} α s)) (CommSemiring.toSemiring.{u1} (FreeCommRing.{u1} (Set.Elem.{u1} α s)) (CommRing.toCommSemiring.{u1} (FreeCommRing.{u1} (Set.Elem.{u1} α s)) (FreeCommRing.instCommRing.{u1} (Set.Elem.{u1} α s)))))) (RingHomClass.toNonUnitalRingHomClass.{u1, u1, u1} (RingHom.{u1, u1} (FreeCommRing.{u1} α) (FreeCommRing.{u1} (Set.Elem.{u1} α s)) (Semiring.toNonAssocSemiring.{u1} (FreeCommRing.{u1} α) (CommSemiring.toSemiring.{u1} (FreeCommRing.{u1} α) (CommRing.toCommSemiring.{u1} (FreeCommRing.{u1} α) (FreeCommRing.instCommRing.{u1} α)))) (Semiring.toNonAssocSemiring.{u1} (FreeCommRing.{u1} (Set.Elem.{u1} α s)) (CommSemiring.toSemiring.{u1} (FreeCommRing.{u1} (Set.Elem.{u1} α s)) (CommRing.toCommSemiring.{u1} (FreeCommRing.{u1} (Set.Elem.{u1} α s)) (FreeCommRing.instCommRing.{u1} (Set.Elem.{u1} α s)))))) (FreeCommRing.{u1} α) (FreeCommRing.{u1} (Set.Elem.{u1} α s)) (Semiring.toNonAssocSemiring.{u1} (FreeCommRing.{u1} α) (CommSemiring.toSemiring.{u1} (FreeCommRing.{u1} α) (CommRing.toCommSemiring.{u1} (FreeCommRing.{u1} α) (FreeCommRing.instCommRing.{u1} α)))) (Semiring.toNonAssocSemiring.{u1} (FreeCommRing.{u1} (Set.Elem.{u1} α s)) (CommSemiring.toSemiring.{u1} (FreeCommRing.{u1} (Set.Elem.{u1} α s)) (CommRing.toCommSemiring.{u1} (FreeCommRing.{u1} (Set.Elem.{u1} α s)) (FreeCommRing.instCommRing.{u1} (Set.Elem.{u1} α s))))) (RingHom.instRingHomClassRingHom.{u1, u1} (FreeCommRing.{u1} α) (FreeCommRing.{u1} (Set.Elem.{u1} α s)) (Semiring.toNonAssocSemiring.{u1} (FreeCommRing.{u1} α) (CommSemiring.toSemiring.{u1} (FreeCommRing.{u1} α) (CommRing.toCommSemiring.{u1} (FreeCommRing.{u1} α) (FreeCommRing.instCommRing.{u1} α)))) (Semiring.toNonAssocSemiring.{u1} (FreeCommRing.{u1} (Set.Elem.{u1} α s)) (CommSemiring.toSemiring.{u1} (FreeCommRing.{u1} (Set.Elem.{u1} α s)) (CommRing.toCommSemiring.{u1} (FreeCommRing.{u1} (Set.Elem.{u1} α s)) (FreeCommRing.instCommRing.{u1} (Set.Elem.{u1} α s))))))))) (FreeCommRing.restriction.{u1} α s (fun (a : α) => _inst_1 a)) x)) x)
 Case conversion may be inaccurate. Consider using '#align free_comm_ring.map_subtype_val_restriction FreeCommRing.map_subtype_val_restrictionₓ'. -/
 theorem map_subtype_val_restriction {x} (s : Set α) [DecidablePred (· ∈ s)]
     (hxs : IsSupported x s) : map (Subtype.val : s → α) (restriction s x) = x :=

50251fd6

bump to nightly-2023-05-19-03

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

9a2fedb8

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_comm_ring
-! leanprover-community/mathlib commit 62c0a4ef1441edb463095ea02a06e87f3dfe135c
+! leanprover-community/mathlib commit 50251fd6309cca5ca2e747882ffecd2729f38c5d
 ! Please do not edit these lines, except to modify the commit id
 ! if you have ported upstream changes.
 -/
@@ -16,6 +16,9 @@ import Mathbin.RingTheory.FreeRing
 /-!
 # Free commutative rings
 
+> THIS FILE IS SYNCHRONIZED WITH MATHLIB4.
+> Any changes to this file require a corresponding PR to mathlib4.
+
 The theory of the free commutative ring generated by a type `α`.
 It is isomorphic to the polynomial ring over ℤ with variables
 in `α`

62c0a4ef

bump to nightly-2023-05-17-08

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

311ac93c

Diff

@@ -61,25 +61,37 @@ universe u v
 
 variable (α : Type u)
 
+#print FreeCommRing /-
 /-- `free_comm_ring α` is the free commutative ring on the type `α`. -/
 def FreeCommRing (α : Type u) : Type u :=
   FreeAbelianGroup <| Multiplicative <| Multiset α deriving CommRing, Inhabited
 #align free_comm_ring FreeCommRing
+-/
 
 namespace FreeCommRing
 
 variable {α}
 
+#print FreeCommRing.of /-
 /-- The canonical map from `α` to the free commutative ring on `α`. -/
 def of (x : α) : FreeCommRing α :=
   FreeAbelianGroup.of <| Multiplicative.ofAdd ({x} : Multiset α)
 #align free_comm_ring.of FreeCommRing.of
+-/
 
+#print FreeCommRing.of_injective /-
 theorem of_injective : Function.Injective (of : α → FreeCommRing α) :=
   FreeAbelianGroup.of_injective.comp fun x y =>
     (Multiset.coe_eq_coe.trans List.singleton_perm_singleton).mp
 #align free_comm_ring.of_injective FreeCommRing.of_injective
+-/
 
+/- warning: free_comm_ring.induction_on -> FreeCommRing.induction_on is a dubious translation:
+lean 3 declaration is
+  forall {α : Type.{u1}} {C : (FreeCommRing.{u1} α) -> Prop} (z : FreeCommRing.{u1} α), (C (Neg.neg.{u1} (FreeCommRing.{u1} α) (SubNegMonoid.toHasNeg.{u1} (FreeCommRing.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeCommRing.{u1} α) (AddGroupWithOne.toAddGroup.{u1} (FreeCommRing.{u1} α) (AddCommGroupWithOne.toAddGroupWithOne.{u1} (FreeCommRing.{u1} α) (Ring.toAddCommGroupWithOne.{u1} (FreeCommRing.{u1} α) (CommRing.toRing.{u1} (FreeCommRing.{u1} α) (FreeCommRing.instCommRing.{u1} α))))))) (OfNat.ofNat.{u1} (FreeCommRing.{u1} α) 1 (OfNat.mk.{u1} (FreeCommRing.{u1} α) 1 (One.one.{u1} (FreeCommRing.{u1} α) (AddMonoidWithOne.toOne.{u1} (FreeCommRing.{u1} α) (AddGroupWithOne.toAddMonoidWithOne.{u1} (FreeCommRing.{u1} α) (AddCommGroupWithOne.toAddGroupWithOne.{u1} (FreeCommRing.{u1} α) (Ring.toAddCommGroupWithOne.{u1} (FreeCommRing.{u1} α) (CommRing.toRing.{u1} (FreeCommRing.{u1} α) (FreeCommRing.instCommRing.{u1} α))))))))))) -> (forall (b : α), C (FreeCommRing.of.{u1} α b)) -> (forall (x : FreeCommRing.{u1} α) (y : FreeCommRing.{u1} α), (C x) -> (C y) -> (C (HAdd.hAdd.{u1, u1, u1} (FreeCommRing.{u1} α) (FreeCommRing.{u1} α) (FreeCommRing.{u1} α) (instHAdd.{u1} (FreeCommRing.{u1} α) (Distrib.toHasAdd.{u1} (FreeCommRing.{u1} α) (Ring.toDistrib.{u1} (FreeCommRing.{u1} α) (CommRing.toRing.{u1} (FreeCommRing.{u1} α) (FreeCommRing.instCommRing.{u1} α))))) x y))) -> (forall (x : FreeCommRing.{u1} α) (y : FreeCommRing.{u1} α), (C x) -> (C y) -> (C (HMul.hMul.{u1, u1, u1} (FreeCommRing.{u1} α) (FreeCommRing.{u1} α) (FreeCommRing.{u1} α) (instHMul.{u1} (FreeCommRing.{u1} α) (Distrib.toHasMul.{u1} (FreeCommRing.{u1} α) (Ring.toDistrib.{u1} (FreeCommRing.{u1} α) (CommRing.toRing.{u1} (FreeCommRing.{u1} α) (FreeCommRing.instCommRing.{u1} α))))) x y))) -> (C z)
+but is expected to have type
+  forall {α : Type.{u1}} {C : (FreeCommRing.{u1} α) -> Prop} (z : FreeCommRing.{u1} α), (C (Neg.neg.{u1} (FreeCommRing.{u1} α) (Ring.toNeg.{u1} (FreeCommRing.{u1} α) (CommRing.toRing.{u1} (FreeCommRing.{u1} α) (FreeCommRing.instCommRing.{u1} α))) (OfNat.ofNat.{u1} (FreeCommRing.{u1} α) 1 (One.toOfNat1.{u1} (FreeCommRing.{u1} α) (Semiring.toOne.{u1} (FreeCommRing.{u1} α) (CommSemiring.toSemiring.{u1} (FreeCommRing.{u1} α) (CommRing.toCommSemiring.{u1} (FreeCommRing.{u1} α) (FreeCommRing.instCommRing.{u1} α)))))))) -> (forall (b : α), C (FreeCommRing.of.{u1} α b)) -> (forall (x : FreeCommRing.{u1} α) (y : FreeCommRing.{u1} α), (C x) -> (C y) -> (C (HAdd.hAdd.{u1, u1, u1} (FreeCommRing.{u1} α) (FreeCommRing.{u1} α) (FreeCommRing.{u1} α) (instHAdd.{u1} (FreeCommRing.{u1} α) (Distrib.toAdd.{u1} (FreeCommRing.{u1} α) (NonUnitalNonAssocSemiring.toDistrib.{u1} (FreeCommRing.{u1} α) (NonUnitalNonAssocRing.toNonUnitalNonAssocSemiring.{u1} (FreeCommRing.{u1} α) (NonAssocRing.toNonUnitalNonAssocRing.{u1} (FreeCommRing.{u1} α) (Ring.toNonAssocRing.{u1} (FreeCommRing.{u1} α) (CommRing.toRing.{u1} (FreeCommRing.{u1} α) (FreeCommRing.instCommRing.{u1} α)))))))) x y))) -> (forall (x : FreeCommRing.{u1} α) (y : FreeCommRing.{u1} α), (C x) -> (C y) -> (C (HMul.hMul.{u1, u1, u1} (FreeCommRing.{u1} α) (FreeCommRing.{u1} α) (FreeCommRing.{u1} α) (instHMul.{u1} (FreeCommRing.{u1} α) (NonUnitalNonAssocRing.toMul.{u1} (FreeCommRing.{u1} α) (NonAssocRing.toNonUnitalNonAssocRing.{u1} (FreeCommRing.{u1} α) (Ring.toNonAssocRing.{u1} (FreeCommRing.{u1} α) (CommRing.toRing.{u1} (FreeCommRing.{u1} α) (FreeCommRing.instCommRing.{u1} α)))))) x y))) -> (C z)
+Case conversion may be inaccurate. Consider using '#align free_comm_ring.induction_on FreeCommRing.induction_onₓ'. -/
 @[elab_as_elim]
 protected theorem induction_on {C : FreeCommRing α → Prop} (z : FreeCommRing α) (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)) :
@@ -121,17 +133,26 @@ private def lift_to_multiset : (α → R) ≃ (Multiplicative (Multiset α) →*
         exact F.congr_arg (Multiset.sum_map_singleton x')
 #align free_comm_ring.lift_to_multiset free_comm_ring.lift_to_multiset
 
+#print FreeCommRing.lift /-
 /-- Lift a map `α → R` to a additive group homomorphism `free_comm_ring α → R`.
 For a version producing a bundled homomorphism, see `lift_hom`. -/
 def lift : (α → R) ≃ (FreeCommRing α →+* R) :=
   Equiv.trans liftToMultiset FreeAbelianGroup.liftMonoid
 #align free_comm_ring.lift FreeCommRing.lift
+-/
 
+/- warning: free_comm_ring.lift_of -> FreeCommRing.lift_of is a dubious translation:
+lean 3 declaration is
+  forall {α : Type.{u1}} {R : Type.{u2}} [_inst_1 : CommRing.{u2} R] (f : α -> R) (x : α), Eq.{succ u2} R (coeFn.{max (succ u1) (succ u2), max (succ u1) (succ u2)} (RingHom.{u1, u2} (FreeCommRing.{u1} α) R (NonAssocRing.toNonAssocSemiring.{u1} (FreeCommRing.{u1} α) (Ring.toNonAssocRing.{u1} (FreeCommRing.{u1} α) (CommRing.toRing.{u1} (FreeCommRing.{u1} α) (FreeCommRing.instCommRing.{u1} α)))) (NonAssocRing.toNonAssocSemiring.{u2} R (Ring.toNonAssocRing.{u2} R (CommRing.toRing.{u2} R _inst_1)))) (fun (_x : RingHom.{u1, u2} (FreeCommRing.{u1} α) R (NonAssocRing.toNonAssocSemiring.{u1} (FreeCommRing.{u1} α) (Ring.toNonAssocRing.{u1} (FreeCommRing.{u1} α) (CommRing.toRing.{u1} (FreeCommRing.{u1} α) (FreeCommRing.instCommRing.{u1} α)))) (NonAssocRing.toNonAssocSemiring.{u2} R (Ring.toNonAssocRing.{u2} R (CommRing.toRing.{u2} R _inst_1)))) => (FreeCommRing.{u1} α) -> R) (RingHom.hasCoeToFun.{u1, u2} (FreeCommRing.{u1} α) R (NonAssocRing.toNonAssocSemiring.{u1} (FreeCommRing.{u1} α) (Ring.toNonAssocRing.{u1} (FreeCommRing.{u1} α) (CommRing.toRing.{u1} (FreeCommRing.{u1} α) (FreeCommRing.instCommRing.{u1} α)))) (NonAssocRing.toNonAssocSemiring.{u2} R (Ring.toNonAssocRing.{u2} R (CommRing.toRing.{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} (FreeCommRing.{u1} α) R (NonAssocRing.toNonAssocSemiring.{u1} (FreeCommRing.{u1} α) (Ring.toNonAssocRing.{u1} (FreeCommRing.{u1} α) (CommRing.toRing.{u1} (FreeCommRing.{u1} α) (FreeCommRing.instCommRing.{u1} α)))) (NonAssocRing.toNonAssocSemiring.{u2} R (Ring.toNonAssocRing.{u2} R (CommRing.toRing.{u2} R _inst_1))))) (fun (_x : Equiv.{max (succ u1) (succ u2), max (succ u1) (succ u2)} (α -> R) (RingHom.{u1, u2} (FreeCommRing.{u1} α) R (NonAssocRing.toNonAssocSemiring.{u1} (FreeCommRing.{u1} α) (Ring.toNonAssocRing.{u1} (FreeCommRing.{u1} α) (CommRing.toRing.{u1} (FreeCommRing.{u1} α) (FreeCommRing.instCommRing.{u1} α)))) (NonAssocRing.toNonAssocSemiring.{u2} R (Ring.toNonAssocRing.{u2} R (CommRing.toRing.{u2} R _inst_1))))) => (α -> R) -> (RingHom.{u1, u2} (FreeCommRing.{u1} α) R (NonAssocRing.toNonAssocSemiring.{u1} (FreeCommRing.{u1} α) (Ring.toNonAssocRing.{u1} (FreeCommRing.{u1} α) (CommRing.toRing.{u1} (FreeCommRing.{u1} α) (FreeCommRing.instCommRing.{u1} α)))) (NonAssocRing.toNonAssocSemiring.{u2} R (Ring.toNonAssocRing.{u2} R (CommRing.toRing.{u2} R _inst_1))))) (Equiv.hasCoeToFun.{max (succ u1) (succ u2), max (succ u1) (succ u2)} (α -> R) (RingHom.{u1, u2} (FreeCommRing.{u1} α) R (NonAssocRing.toNonAssocSemiring.{u1} (FreeCommRing.{u1} α) (Ring.toNonAssocRing.{u1} (FreeCommRing.{u1} α) (CommRing.toRing.{u1} (FreeCommRing.{u1} α) (FreeCommRing.instCommRing.{u1} α)))) (NonAssocRing.toNonAssocSemiring.{u2} R (Ring.toNonAssocRing.{u2} R (CommRing.toRing.{u2} R _inst_1))))) (FreeCommRing.lift.{u1, u2} α R _inst_1) f) (FreeCommRing.of.{u1} α x)) (f x)
+but is expected to have type
+  forall {α : Type.{u1}} {R : Type.{u2}} [_inst_1 : CommRing.{u2} R] (f : α -> R) (x : α), Eq.{succ u2} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : FreeCommRing.{u1} α) => R) (FreeCommRing.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} (FreeCommRing.{u1} α) R (Semiring.toNonAssocSemiring.{u1} (FreeCommRing.{u1} α) (CommSemiring.toSemiring.{u1} (FreeCommRing.{u1} α) (CommRing.toCommSemiring.{u1} (FreeCommRing.{u1} α) (FreeCommRing.instCommRing.{u1} α)))) (Semiring.toNonAssocSemiring.{u2} R (CommSemiring.toSemiring.{u2} R (CommRing.toCommSemiring.{u2} R _inst_1)))) f) (FreeCommRing.{u1} α) (fun (_x : FreeCommRing.{u1} α) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : FreeCommRing.{u1} α) => R) _x) (MulHomClass.toFunLike.{max u1 u2, u1, u2} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : α -> R) => RingHom.{u1, u2} (FreeCommRing.{u1} α) R (Semiring.toNonAssocSemiring.{u1} (FreeCommRing.{u1} α) (CommSemiring.toSemiring.{u1} (FreeCommRing.{u1} α) (CommRing.toCommSemiring.{u1} (FreeCommRing.{u1} α) (FreeCommRing.instCommRing.{u1} α)))) (Semiring.toNonAssocSemiring.{u2} R (CommSemiring.toSemiring.{u2} R (CommRing.toCommSemiring.{u2} R _inst_1)))) f) (FreeCommRing.{u1} α) R (NonUnitalNonAssocSemiring.toMul.{u1} (FreeCommRing.{u1} α) (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u1} (FreeCommRing.{u1} α) (Semiring.toNonAssocSemiring.{u1} (FreeCommRing.{u1} α) (CommSemiring.toSemiring.{u1} (FreeCommRing.{u1} α) (CommRing.toCommSemiring.{u1} (FreeCommRing.{u1} α) (FreeCommRing.instCommRing.{u1} α)))))) (NonUnitalNonAssocSemiring.toMul.{u2} R (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u2} R (Semiring.toNonAssocSemiring.{u2} R (CommSemiring.toSemiring.{u2} R (CommRing.toCommSemiring.{u2} R _inst_1))))) (NonUnitalRingHomClass.toMulHomClass.{max u1 u2, u1, u2} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : α -> R) => RingHom.{u1, u2} (FreeCommRing.{u1} α) R (Semiring.toNonAssocSemiring.{u1} (FreeCommRing.{u1} α) (CommSemiring.toSemiring.{u1} (FreeCommRing.{u1} α) (CommRing.toCommSemiring.{u1} (FreeCommRing.{u1} α) (FreeCommRing.instCommRing.{u1} α)))) (Semiring.toNonAssocSemiring.{u2} R (CommSemiring.toSemiring.{u2} R (CommRing.toCommSemiring.{u2} R _inst_1)))) f) (FreeCommRing.{u1} α) R (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u1} (FreeCommRing.{u1} α) (Semiring.toNonAssocSemiring.{u1} (FreeCommRing.{u1} α) (CommSemiring.toSemiring.{u1} (FreeCommRing.{u1} α) (CommRing.toCommSemiring.{u1} (FreeCommRing.{u1} α) (FreeCommRing.instCommRing.{u1} α))))) (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u2} R (Semiring.toNonAssocSemiring.{u2} R (CommSemiring.toSemiring.{u2} R (CommRing.toCommSemiring.{u2} R _inst_1)))) (RingHomClass.toNonUnitalRingHomClass.{max u1 u2, u1, u2} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : α -> R) => RingHom.{u1, u2} (FreeCommRing.{u1} α) R (Semiring.toNonAssocSemiring.{u1} (FreeCommRing.{u1} α) (CommSemiring.toSemiring.{u1} (FreeCommRing.{u1} α) (CommRing.toCommSemiring.{u1} (FreeCommRing.{u1} α) (FreeCommRing.instCommRing.{u1} α)))) (Semiring.toNonAssocSemiring.{u2} R (CommSemiring.toSemiring.{u2} R (CommRing.toCommSemiring.{u2} R _inst_1)))) f) (FreeCommRing.{u1} α) R (Semiring.toNonAssocSemiring.{u1} (FreeCommRing.{u1} α) (CommSemiring.toSemiring.{u1} (FreeCommRing.{u1} α) (CommRing.toCommSemiring.{u1} (FreeCommRing.{u1} α) (FreeCommRing.instCommRing.{u1} α)))) (Semiring.toNonAssocSemiring.{u2} R (CommSemiring.toSemiring.{u2} R (CommRing.toCommSemiring.{u2} R _inst_1))) (RingHom.instRingHomClassRingHom.{u1, u2} (FreeCommRing.{u1} α) R (Semiring.toNonAssocSemiring.{u1} (FreeCommRing.{u1} α) (CommSemiring.toSemiring.{u1} (FreeCommRing.{u1} α) (CommRing.toCommSemiring.{u1} (FreeCommRing.{u1} α) (FreeCommRing.instCommRing.{u1} α)))) (Semiring.toNonAssocSemiring.{u2} R (CommSemiring.toSemiring.{u2} R (CommRing.toCommSemiring.{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} (FreeCommRing.{u1} α) R (Semiring.toNonAssocSemiring.{u1} (FreeCommRing.{u1} α) (CommSemiring.toSemiring.{u1} (FreeCommRing.{u1} α) (CommRing.toCommSemiring.{u1} (FreeCommRing.{u1} α) (FreeCommRing.instCommRing.{u1} α)))) (Semiring.toNonAssocSemiring.{u2} R (CommSemiring.toSemiring.{u2} R (CommRing.toCommSemiring.{u2} R _inst_1))))) (α -> R) (fun (_x : α -> R) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : α -> R) => RingHom.{u1, u2} (FreeCommRing.{u1} α) R (Semiring.toNonAssocSemiring.{u1} (FreeCommRing.{u1} α) (CommSemiring.toSemiring.{u1} (FreeCommRing.{u1} α) (CommRing.toCommSemiring.{u1} (FreeCommRing.{u1} α) (FreeCommRing.instCommRing.{u1} α)))) (Semiring.toNonAssocSemiring.{u2} R (CommSemiring.toSemiring.{u2} R (CommRing.toCommSemiring.{u2} R _inst_1)))) _x) (Equiv.instFunLikeEquiv.{max (succ u2) (succ u1), max (succ u2) (succ u1)} (α -> R) (RingHom.{u1, u2} (FreeCommRing.{u1} α) R (Semiring.toNonAssocSemiring.{u1} (FreeCommRing.{u1} α) (CommSemiring.toSemiring.{u1} (FreeCommRing.{u1} α) (CommRing.toCommSemiring.{u1} (FreeCommRing.{u1} α) (FreeCommRing.instCommRing.{u1} α)))) (Semiring.toNonAssocSemiring.{u2} R (CommSemiring.toSemiring.{u2} R (CommRing.toCommSemiring.{u2} R _inst_1))))) (FreeCommRing.lift.{u1, u2} α R _inst_1) f) (FreeCommRing.of.{u1} α x)) (f x)
+Case conversion may be inaccurate. Consider using '#align free_comm_ring.lift_of FreeCommRing.lift_ofₓ'. -/
 @[simp]
 theorem lift_of (x : α) : lift f (of x) = f x :=
   (FreeAbelianGroup.lift.of _ _).trans <| mul_one _
 #align free_comm_ring.lift_of FreeCommRing.lift_of
 
+#print FreeCommRing.lift_comp_of /-
 @[simp]
 theorem lift_comp_of (f : FreeCommRing α →+* R) : lift (f ∘ of) = f :=
   RingHom.ext fun x =>
@@ -139,7 +160,14 @@ theorem lift_comp_of (f : FreeCommRing α →+* R) : lift (f ∘ of) = f :=
       (lift_of _) (fun x y ihx ihy => by rw [RingHom.map_add, f.map_add, ihx, ihy])
       fun x y ihx ihy => by rw [RingHom.map_mul, f.map_mul, ihx, ihy]
 #align free_comm_ring.lift_comp_of FreeCommRing.lift_comp_of
+-/
 
+/- warning: free_comm_ring.hom_ext -> FreeCommRing.hom_ext is a dubious translation:
+lean 3 declaration is
+  forall {α : Type.{u1}} {R : Type.{u2}} [_inst_1 : CommRing.{u2} R] {{f : RingHom.{u1, u2} (FreeCommRing.{u1} α) R (NonAssocRing.toNonAssocSemiring.{u1} (FreeCommRing.{u1} α) (Ring.toNonAssocRing.{u1} (FreeCommRing.{u1} α) (CommRing.toRing.{u1} (FreeCommRing.{u1} α) (FreeCommRing.instCommRing.{u1} α)))) (NonAssocRing.toNonAssocSemiring.{u2} R (Ring.toNonAssocRing.{u2} R (CommRing.toRing.{u2} R _inst_1)))}} {{g : RingHom.{u1, u2} (FreeCommRing.{u1} α) R (NonAssocRing.toNonAssocSemiring.{u1} (FreeCommRing.{u1} α) (Ring.toNonAssocRing.{u1} (FreeCommRing.{u1} α) (CommRing.toRing.{u1} (FreeCommRing.{u1} α) (FreeCommRing.instCommRing.{u1} α)))) (NonAssocRing.toNonAssocSemiring.{u2} R (Ring.toNonAssocRing.{u2} R (CommRing.toRing.{u2} R _inst_1)))}}, (forall (x : α), Eq.{succ u2} R (coeFn.{max (succ u1) (succ u2), max (succ u1) (succ u2)} (RingHom.{u1, u2} (FreeCommRing.{u1} α) R (NonAssocRing.toNonAssocSemiring.{u1} (FreeCommRing.{u1} α) (Ring.toNonAssocRing.{u1} (FreeCommRing.{u1} α) (CommRing.toRing.{u1} (FreeCommRing.{u1} α) (FreeCommRing.instCommRing.{u1} α)))) (NonAssocRing.toNonAssocSemiring.{u2} R (Ring.toNonAssocRing.{u2} R (CommRing.toRing.{u2} R _inst_1)))) (fun (_x : RingHom.{u1, u2} (FreeCommRing.{u1} α) R (NonAssocRing.toNonAssocSemiring.{u1} (FreeCommRing.{u1} α) (Ring.toNonAssocRing.{u1} (FreeCommRing.{u1} α) (CommRing.toRing.{u1} (FreeCommRing.{u1} α) (FreeCommRing.instCommRing.{u1} α)))) (NonAssocRing.toNonAssocSemiring.{u2} R (Ring.toNonAssocRing.{u2} R (CommRing.toRing.{u2} R _inst_1)))) => (FreeCommRing.{u1} α) -> R) (RingHom.hasCoeToFun.{u1, u2} (FreeCommRing.{u1} α) R (NonAssocRing.toNonAssocSemiring.{u1} (FreeCommRing.{u1} α) (Ring.toNonAssocRing.{u1} (FreeCommRing.{u1} α) (CommRing.toRing.{u1} (FreeCommRing.{u1} α) (FreeCommRing.instCommRing.{u1} α)))) (NonAssocRing.toNonAssocSemiring.{u2} R (Ring.toNonAssocRing.{u2} R (CommRing.toRing.{u2} R _inst_1)))) f (FreeCommRing.of.{u1} α x)) (coeFn.{max (succ u1) (succ u2), max (succ u1) (succ u2)} (RingHom.{u1, u2} (FreeCommRing.{u1} α) R (NonAssocRing.toNonAssocSemiring.{u1} (FreeCommRing.{u1} α) (Ring.toNonAssocRing.{u1} (FreeCommRing.{u1} α) (CommRing.toRing.{u1} (FreeCommRing.{u1} α) (FreeCommRing.instCommRing.{u1} α)))) (NonAssocRing.toNonAssocSemiring.{u2} R (Ring.toNonAssocRing.{u2} R (CommRing.toRing.{u2} R _inst_1)))) (fun (_x : RingHom.{u1, u2} (FreeCommRing.{u1} α) R (NonAssocRing.toNonAssocSemiring.{u1} (FreeCommRing.{u1} α) (Ring.toNonAssocRing.{u1} (FreeCommRing.{u1} α) (CommRing.toRing.{u1} (FreeCommRing.{u1} α) (FreeCommRing.instCommRing.{u1} α)))) (NonAssocRing.toNonAssocSemiring.{u2} R (Ring.toNonAssocRing.{u2} R (CommRing.toRing.{u2} R _inst_1)))) => (FreeCommRing.{u1} α) -> R) (RingHom.hasCoeToFun.{u1, u2} (FreeCommRing.{u1} α) R (NonAssocRing.toNonAssocSemiring.{u1} (FreeCommRing.{u1} α) (Ring.toNonAssocRing.{u1} (FreeCommRing.{u1} α) (CommRing.toRing.{u1} (FreeCommRing.{u1} α) (FreeCommRing.instCommRing.{u1} α)))) (NonAssocRing.toNonAssocSemiring.{u2} R (Ring.toNonAssocRing.{u2} R (CommRing.toRing.{u2} R _inst_1)))) g (FreeCommRing.of.{u1} α x))) -> (Eq.{max (succ u1) (succ u2)} (RingHom.{u1, u2} (FreeCommRing.{u1} α) R (NonAssocRing.toNonAssocSemiring.{u1} (FreeCommRing.{u1} α) (Ring.toNonAssocRing.{u1} (FreeCommRing.{u1} α) (CommRing.toRing.{u1} (FreeCommRing.{u1} α) (FreeCommRing.instCommRing.{u1} α)))) (NonAssocRing.toNonAssocSemiring.{u2} R (Ring.toNonAssocRing.{u2} R (CommRing.toRing.{u2} R _inst_1)))) f g)
+but is expected to have type
+  forall {α : Type.{u1}} {R : Type.{u2}} [_inst_1 : CommRing.{u2} R] {{f : RingHom.{u1, u2} (FreeCommRing.{u1} α) R (Semiring.toNonAssocSemiring.{u1} (FreeCommRing.{u1} α) (CommSemiring.toSemiring.{u1} (FreeCommRing.{u1} α) (CommRing.toCommSemiring.{u1} (FreeCommRing.{u1} α) (FreeCommRing.instCommRing.{u1} α)))) (Semiring.toNonAssocSemiring.{u2} R (CommSemiring.toSemiring.{u2} R (CommRing.toCommSemiring.{u2} R _inst_1)))}} {{g : RingHom.{u1, u2} (FreeCommRing.{u1} α) R (Semiring.toNonAssocSemiring.{u1} (FreeCommRing.{u1} α) (CommSemiring.toSemiring.{u1} (FreeCommRing.{u1} α) (CommRing.toCommSemiring.{u1} (FreeCommRing.{u1} α) (FreeCommRing.instCommRing.{u1} α)))) (Semiring.toNonAssocSemiring.{u2} R (CommSemiring.toSemiring.{u2} R (CommRing.toCommSemiring.{u2} R _inst_1)))}}, (forall (x : α), Eq.{succ u2} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : FreeCommRing.{u1} α) => R) (FreeCommRing.of.{u1} α x)) (FunLike.coe.{max (succ u1) (succ u2), succ u1, succ u2} (RingHom.{u1, u2} (FreeCommRing.{u1} α) R (Semiring.toNonAssocSemiring.{u1} (FreeCommRing.{u1} α) (CommSemiring.toSemiring.{u1} (FreeCommRing.{u1} α) (CommRing.toCommSemiring.{u1} (FreeCommRing.{u1} α) (FreeCommRing.instCommRing.{u1} α)))) (Semiring.toNonAssocSemiring.{u2} R (CommSemiring.toSemiring.{u2} R (CommRing.toCommSemiring.{u2} R _inst_1)))) (FreeCommRing.{u1} α) (fun (_x : FreeCommRing.{u1} α) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : FreeCommRing.{u1} α) => R) _x) (MulHomClass.toFunLike.{max u1 u2, u1, u2} (RingHom.{u1, u2} (FreeCommRing.{u1} α) R (Semiring.toNonAssocSemiring.{u1} (FreeCommRing.{u1} α) (CommSemiring.toSemiring.{u1} (FreeCommRing.{u1} α) (CommRing.toCommSemiring.{u1} (FreeCommRing.{u1} α) (FreeCommRing.instCommRing.{u1} α)))) (Semiring.toNonAssocSemiring.{u2} R (CommSemiring.toSemiring.{u2} R (CommRing.toCommSemiring.{u2} R _inst_1)))) (FreeCommRing.{u1} α) R (NonUnitalNonAssocSemiring.toMul.{u1} (FreeCommRing.{u1} α) (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u1} (FreeCommRing.{u1} α) (Semiring.toNonAssocSemiring.{u1} (FreeCommRing.{u1} α) (CommSemiring.toSemiring.{u1} (FreeCommRing.{u1} α) (CommRing.toCommSemiring.{u1} (FreeCommRing.{u1} α) (FreeCommRing.instCommRing.{u1} α)))))) (NonUnitalNonAssocSemiring.toMul.{u2} R (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u2} R (Semiring.toNonAssocSemiring.{u2} R (CommSemiring.toSemiring.{u2} R (CommRing.toCommSemiring.{u2} R _inst_1))))) (NonUnitalRingHomClass.toMulHomClass.{max u1 u2, u1, u2} (RingHom.{u1, u2} (FreeCommRing.{u1} α) R (Semiring.toNonAssocSemiring.{u1} (FreeCommRing.{u1} α) (CommSemiring.toSemiring.{u1} (FreeCommRing.{u1} α) (CommRing.toCommSemiring.{u1} (FreeCommRing.{u1} α) (FreeCommRing.instCommRing.{u1} α)))) (Semiring.toNonAssocSemiring.{u2} R (CommSemiring.toSemiring.{u2} R (CommRing.toCommSemiring.{u2} R _inst_1)))) (FreeCommRing.{u1} α) R (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u1} (FreeCommRing.{u1} α) (Semiring.toNonAssocSemiring.{u1} (FreeCommRing.{u1} α) (CommSemiring.toSemiring.{u1} (FreeCommRing.{u1} α) (CommRing.toCommSemiring.{u1} (FreeCommRing.{u1} α) (FreeCommRing.instCommRing.{u1} α))))) (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u2} R (Semiring.toNonAssocSemiring.{u2} R (CommSemiring.toSemiring.{u2} R (CommRing.toCommSemiring.{u2} R _inst_1)))) (RingHomClass.toNonUnitalRingHomClass.{max u1 u2, u1, u2} (RingHom.{u1, u2} (FreeCommRing.{u1} α) R (Semiring.toNonAssocSemiring.{u1} (FreeCommRing.{u1} α) (CommSemiring.toSemiring.{u1} (FreeCommRing.{u1} α) (CommRing.toCommSemiring.{u1} (FreeCommRing.{u1} α) (FreeCommRing.instCommRing.{u1} α)))) (Semiring.toNonAssocSemiring.{u2} R (CommSemiring.toSemiring.{u2} R (CommRing.toCommSemiring.{u2} R _inst_1)))) (FreeCommRing.{u1} α) R (Semiring.toNonAssocSemiring.{u1} (FreeCommRing.{u1} α) (CommSemiring.toSemiring.{u1} (FreeCommRing.{u1} α) (CommRing.toCommSemiring.{u1} (FreeCommRing.{u1} α) (FreeCommRing.instCommRing.{u1} α)))) (Semiring.toNonAssocSemiring.{u2} R (CommSemiring.toSemiring.{u2} R (CommRing.toCommSemiring.{u2} R _inst_1))) (RingHom.instRingHomClassRingHom.{u1, u2} (FreeCommRing.{u1} α) R (Semiring.toNonAssocSemiring.{u1} (FreeCommRing.{u1} α) (CommSemiring.toSemiring.{u1} (FreeCommRing.{u1} α) (CommRing.toCommSemiring.{u1} (FreeCommRing.{u1} α) (FreeCommRing.instCommRing.{u1} α)))) (Semiring.toNonAssocSemiring.{u2} R (CommSemiring.toSemiring.{u2} R (CommRing.toCommSemiring.{u2} R _inst_1))))))) f (FreeCommRing.of.{u1} α x)) (FunLike.coe.{max (succ u1) (succ u2), succ u1, succ u2} (RingHom.{u1, u2} (FreeCommRing.{u1} α) R (Semiring.toNonAssocSemiring.{u1} (FreeCommRing.{u1} α) (CommSemiring.toSemiring.{u1} (FreeCommRing.{u1} α) (CommRing.toCommSemiring.{u1} (FreeCommRing.{u1} α) (FreeCommRing.instCommRing.{u1} α)))) (Semiring.toNonAssocSemiring.{u2} R (CommSemiring.toSemiring.{u2} R (CommRing.toCommSemiring.{u2} R _inst_1)))) (FreeCommRing.{u1} α) (fun (_x : FreeCommRing.{u1} α) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : FreeCommRing.{u1} α) => R) _x) (MulHomClass.toFunLike.{max u1 u2, u1, u2} (RingHom.{u1, u2} (FreeCommRing.{u1} α) R (Semiring.toNonAssocSemiring.{u1} (FreeCommRing.{u1} α) (CommSemiring.toSemiring.{u1} (FreeCommRing.{u1} α) (CommRing.toCommSemiring.{u1} (FreeCommRing.{u1} α) (FreeCommRing.instCommRing.{u1} α)))) (Semiring.toNonAssocSemiring.{u2} R (CommSemiring.toSemiring.{u2} R (CommRing.toCommSemiring.{u2} R _inst_1)))) (FreeCommRing.{u1} α) R (NonUnitalNonAssocSemiring.toMul.{u1} (FreeCommRing.{u1} α) (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u1} (FreeCommRing.{u1} α) (Semiring.toNonAssocSemiring.{u1} (FreeCommRing.{u1} α) (CommSemiring.toSemiring.{u1} (FreeCommRing.{u1} α) (CommRing.toCommSemiring.{u1} (FreeCommRing.{u1} α) (FreeCommRing.instCommRing.{u1} α)))))) (NonUnitalNonAssocSemiring.toMul.{u2} R (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u2} R (Semiring.toNonAssocSemiring.{u2} R (CommSemiring.toSemiring.{u2} R (CommRing.toCommSemiring.{u2} R _inst_1))))) (NonUnitalRingHomClass.toMulHomClass.{max u1 u2, u1, u2} (RingHom.{u1, u2} (FreeCommRing.{u1} α) R (Semiring.toNonAssocSemiring.{u1} (FreeCommRing.{u1} α) (CommSemiring.toSemiring.{u1} (FreeCommRing.{u1} α) (CommRing.toCommSemiring.{u1} (FreeCommRing.{u1} α) (FreeCommRing.instCommRing.{u1} α)))) (Semiring.toNonAssocSemiring.{u2} R (CommSemiring.toSemiring.{u2} R (CommRing.toCommSemiring.{u2} R _inst_1)))) (FreeCommRing.{u1} α) R (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u1} (FreeCommRing.{u1} α) (Semiring.toNonAssocSemiring.{u1} (FreeCommRing.{u1} α) (CommSemiring.toSemiring.{u1} (FreeCommRing.{u1} α) (CommRing.toCommSemiring.{u1} (FreeCommRing.{u1} α) (FreeCommRing.instCommRing.{u1} α))))) (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u2} R (Semiring.toNonAssocSemiring.{u2} R (CommSemiring.toSemiring.{u2} R (CommRing.toCommSemiring.{u2} R _inst_1)))) (RingHomClass.toNonUnitalRingHomClass.{max u1 u2, u1, u2} (RingHom.{u1, u2} (FreeCommRing.{u1} α) R (Semiring.toNonAssocSemiring.{u1} (FreeCommRing.{u1} α) (CommSemiring.toSemiring.{u1} (FreeCommRing.{u1} α) (CommRing.toCommSemiring.{u1} (FreeCommRing.{u1} α) (FreeCommRing.instCommRing.{u1} α)))) (Semiring.toNonAssocSemiring.{u2} R (CommSemiring.toSemiring.{u2} R (CommRing.toCommSemiring.{u2} R _inst_1)))) (FreeCommRing.{u1} α) R (Semiring.toNonAssocSemiring.{u1} (FreeCommRing.{u1} α) (CommSemiring.toSemiring.{u1} (FreeCommRing.{u1} α) (CommRing.toCommSemiring.{u1} (FreeCommRing.{u1} α) (FreeCommRing.instCommRing.{u1} α)))) (Semiring.toNonAssocSemiring.{u2} R (CommSemiring.toSemiring.{u2} R (CommRing.toCommSemiring.{u2} R _inst_1))) (RingHom.instRingHomClassRingHom.{u1, u2} (FreeCommRing.{u1} α) R (Semiring.toNonAssocSemiring.{u1} (FreeCommRing.{u1} α) (CommSemiring.toSemiring.{u1} (FreeCommRing.{u1} α) (CommRing.toCommSemiring.{u1} (FreeCommRing.{u1} α) (FreeCommRing.instCommRing.{u1} α)))) (Semiring.toNonAssocSemiring.{u2} R (CommSemiring.toSemiring.{u2} R (CommRing.toCommSemiring.{u2} R _inst_1))))))) g (FreeCommRing.of.{u1} α x))) -> (Eq.{max (succ u1) (succ u2)} (RingHom.{u1, u2} (FreeCommRing.{u1} α) R (Semiring.toNonAssocSemiring.{u1} (FreeCommRing.{u1} α) (CommSemiring.toSemiring.{u1} (FreeCommRing.{u1} α) (CommRing.toCommSemiring.{u1} (FreeCommRing.{u1} α) (FreeCommRing.instCommRing.{u1} α)))) (Semiring.toNonAssocSemiring.{u2} R (CommSemiring.toSemiring.{u2} R (CommRing.toCommSemiring.{u2} R _inst_1)))) f g)
+Case conversion may be inaccurate. Consider using '#align free_comm_ring.hom_ext FreeCommRing.hom_extₓ'. -/
 @[ext]
 theorem hom_ext ⦃f g : FreeCommRing α →+* R⦄ (h : ∀ x, f (of x) = g (of x)) : f = g :=
   lift.symm.Injective (funext h)
@@ -149,53 +177,107 @@ end lift
 
 variable {β : Type v} (f : α → β)
 
+#print FreeCommRing.map /-
 /-- A map `f : α → β` produces a ring homomorphism `free_comm_ring α →+* free_comm_ring β`. -/
 def map : FreeCommRing α →+* FreeCommRing β :=
   lift <| of ∘ f
 #align free_comm_ring.map FreeCommRing.map
+-/
 
+/- warning: free_comm_ring.map_of -> FreeCommRing.map_of is a dubious translation:
+lean 3 declaration is
+  forall {α : Type.{u1}} {β : Type.{u2}} (f : α -> β) (x : α), Eq.{succ u2} (FreeCommRing.{u2} β) (coeFn.{max (succ u1) (succ u2), max (succ u1) (succ u2)} (RingHom.{u1, u2} (FreeCommRing.{u1} α) (FreeCommRing.{u2} β) (NonAssocRing.toNonAssocSemiring.{u1} (FreeCommRing.{u1} α) (Ring.toNonAssocRing.{u1} (FreeCommRing.{u1} α) (CommRing.toRing.{u1} (FreeCommRing.{u1} α) (FreeCommRing.instCommRing.{u1} α)))) (NonAssocRing.toNonAssocSemiring.{u2} (FreeCommRing.{u2} β) (Ring.toNonAssocRing.{u2} (FreeCommRing.{u2} β) (CommRing.toRing.{u2} (FreeCommRing.{u2} β) (FreeCommRing.instCommRing.{u2} β))))) (fun (_x : RingHom.{u1, u2} (FreeCommRing.{u1} α) (FreeCommRing.{u2} β) (NonAssocRing.toNonAssocSemiring.{u1} (FreeCommRing.{u1} α) (Ring.toNonAssocRing.{u1} (FreeCommRing.{u1} α) (CommRing.toRing.{u1} (FreeCommRing.{u1} α) (FreeCommRing.instCommRing.{u1} α)))) (NonAssocRing.toNonAssocSemiring.{u2} (FreeCommRing.{u2} β) (Ring.toNonAssocRing.{u2} (FreeCommRing.{u2} β) (CommRing.toRing.{u2} (FreeCommRing.{u2} β) (FreeCommRing.instCommRing.{u2} β))))) => (FreeCommRing.{u1} α) -> (FreeCommRing.{u2} β)) (RingHom.hasCoeToFun.{u1, u2} (FreeCommRing.{u1} α) (FreeCommRing.{u2} β) (NonAssocRing.toNonAssocSemiring.{u1} (FreeCommRing.{u1} α) (Ring.toNonAssocRing.{u1} (FreeCommRing.{u1} α) (CommRing.toRing.{u1} (FreeCommRing.{u1} α) (FreeCommRing.instCommRing.{u1} α)))) (NonAssocRing.toNonAssocSemiring.{u2} (FreeCommRing.{u2} β) (Ring.toNonAssocRing.{u2} (FreeCommRing.{u2} β) (CommRing.toRing.{u2} (FreeCommRing.{u2} β) (FreeCommRing.instCommRing.{u2} β))))) (FreeCommRing.map.{u1, u2} α β f) (FreeCommRing.of.{u1} α x)) (FreeCommRing.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 : FreeCommRing.{u1} α) => FreeCommRing.{u2} β) (FreeCommRing.of.{u1} α x)) (FunLike.coe.{max (succ u1) (succ u2), succ u1, succ u2} (RingHom.{u1, u2} (FreeCommRing.{u1} α) (FreeCommRing.{u2} β) (Semiring.toNonAssocSemiring.{u1} (FreeCommRing.{u1} α) (CommSemiring.toSemiring.{u1} (FreeCommRing.{u1} α) (CommRing.toCommSemiring.{u1} (FreeCommRing.{u1} α) (FreeCommRing.instCommRing.{u1} α)))) (Semiring.toNonAssocSemiring.{u2} (FreeCommRing.{u2} β) (CommSemiring.toSemiring.{u2} (FreeCommRing.{u2} β) (CommRing.toCommSemiring.{u2} (FreeCommRing.{u2} β) (FreeCommRing.instCommRing.{u2} β))))) (FreeCommRing.{u1} α) (fun (_x : FreeCommRing.{u1} α) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : FreeCommRing.{u1} α) => FreeCommRing.{u2} β) _x) (MulHomClass.toFunLike.{max u1 u2, u1, u2} (RingHom.{u1, u2} (FreeCommRing.{u1} α) (FreeCommRing.{u2} β) (Semiring.toNonAssocSemiring.{u1} (FreeCommRing.{u1} α) (CommSemiring.toSemiring.{u1} (FreeCommRing.{u1} α) (CommRing.toCommSemiring.{u1} (FreeCommRing.{u1} α) (FreeCommRing.instCommRing.{u1} α)))) (Semiring.toNonAssocSemiring.{u2} (FreeCommRing.{u2} β) (CommSemiring.toSemiring.{u2} (FreeCommRing.{u2} β) (CommRing.toCommSemiring.{u2} (FreeCommRing.{u2} β) (FreeCommRing.instCommRing.{u2} β))))) (FreeCommRing.{u1} α) (FreeCommRing.{u2} β) (NonUnitalNonAssocSemiring.toMul.{u1} (FreeCommRing.{u1} α) (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u1} (FreeCommRing.{u1} α) (Semiring.toNonAssocSemiring.{u1} (FreeCommRing.{u1} α) (CommSemiring.toSemiring.{u1} (FreeCommRing.{u1} α) (CommRing.toCommSemiring.{u1} (FreeCommRing.{u1} α) (FreeCommRing.instCommRing.{u1} α)))))) (NonUnitalNonAssocSemiring.toMul.{u2} (FreeCommRing.{u2} β) (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u2} (FreeCommRing.{u2} β) (Semiring.toNonAssocSemiring.{u2} (FreeCommRing.{u2} β) (CommSemiring.toSemiring.{u2} (FreeCommRing.{u2} β) (CommRing.toCommSemiring.{u2} (FreeCommRing.{u2} β) (FreeCommRing.instCommRing.{u2} β)))))) (NonUnitalRingHomClass.toMulHomClass.{max u1 u2, u1, u2} (RingHom.{u1, u2} (FreeCommRing.{u1} α) (FreeCommRing.{u2} β) (Semiring.toNonAssocSemiring.{u1} (FreeCommRing.{u1} α) (CommSemiring.toSemiring.{u1} (FreeCommRing.{u1} α) (CommRing.toCommSemiring.{u1} (FreeCommRing.{u1} α) (FreeCommRing.instCommRing.{u1} α)))) (Semiring.toNonAssocSemiring.{u2} (FreeCommRing.{u2} β) (CommSemiring.toSemiring.{u2} (FreeCommRing.{u2} β) (CommRing.toCommSemiring.{u2} (FreeCommRing.{u2} β) (FreeCommRing.instCommRing.{u2} β))))) (FreeCommRing.{u1} α) (FreeCommRing.{u2} β) (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u1} (FreeCommRing.{u1} α) (Semiring.toNonAssocSemiring.{u1} (FreeCommRing.{u1} α) (CommSemiring.toSemiring.{u1} (FreeCommRing.{u1} α) (CommRing.toCommSemiring.{u1} (FreeCommRing.{u1} α) (FreeCommRing.instCommRing.{u1} α))))) (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u2} (FreeCommRing.{u2} β) (Semiring.toNonAssocSemiring.{u2} (FreeCommRing.{u2} β) (CommSemiring.toSemiring.{u2} (FreeCommRing.{u2} β) (CommRing.toCommSemiring.{u2} (FreeCommRing.{u2} β) (FreeCommRing.instCommRing.{u2} β))))) (RingHomClass.toNonUnitalRingHomClass.{max u1 u2, u1, u2} (RingHom.{u1, u2} (FreeCommRing.{u1} α) (FreeCommRing.{u2} β) (Semiring.toNonAssocSemiring.{u1} (FreeCommRing.{u1} α) (CommSemiring.toSemiring.{u1} (FreeCommRing.{u1} α) (CommRing.toCommSemiring.{u1} (FreeCommRing.{u1} α) (FreeCommRing.instCommRing.{u1} α)))) (Semiring.toNonAssocSemiring.{u2} (FreeCommRing.{u2} β) (CommSemiring.toSemiring.{u2} (FreeCommRing.{u2} β) (CommRing.toCommSemiring.{u2} (FreeCommRing.{u2} β) (FreeCommRing.instCommRing.{u2} β))))) (FreeCommRing.{u1} α) (FreeCommRing.{u2} β) (Semiring.toNonAssocSemiring.{u1} (FreeCommRing.{u1} α) (CommSemiring.toSemiring.{u1} (FreeCommRing.{u1} α) (CommRing.toCommSemiring.{u1} (FreeCommRing.{u1} α) (FreeCommRing.instCommRing.{u1} α)))) (Semiring.toNonAssocSemiring.{u2} (FreeCommRing.{u2} β) (CommSemiring.toSemiring.{u2} (FreeCommRing.{u2} β) (CommRing.toCommSemiring.{u2} (FreeCommRing.{u2} β) (FreeCommRing.instCommRing.{u2} β)))) (RingHom.instRingHomClassRingHom.{u1, u2} (FreeCommRing.{u1} α) (FreeCommRing.{u2} β) (Semiring.toNonAssocSemiring.{u1} (FreeCommRing.{u1} α) (CommSemiring.toSemiring.{u1} (FreeCommRing.{u1} α) (CommRing.toCommSemiring.{u1} (FreeCommRing.{u1} α) (FreeCommRing.instCommRing.{u1} α)))) (Semiring.toNonAssocSemiring.{u2} (FreeCommRing.{u2} β) (CommSemiring.toSemiring.{u2} (FreeCommRing.{u2} β) (CommRing.toCommSemiring.{u2} (FreeCommRing.{u2} β) (FreeCommRing.instCommRing.{u2} β)))))))) (FreeCommRing.map.{u1, u2} α β f) (FreeCommRing.of.{u1} α x)) (FreeCommRing.of.{u2} β (f x))
+Case conversion may be inaccurate. Consider using '#align free_comm_ring.map_of FreeCommRing.map_ofₓ'. -/
 @[simp]
 theorem map_of (x : α) : map f (of x) = of (f x) :=
   lift_of _ _
 #align free_comm_ring.map_of FreeCommRing.map_of
 
+#print FreeCommRing.IsSupported /-
 /-- `is_supported x s` means that all monomials showing up in `x` have variables in `s`. -/
 def IsSupported (x : FreeCommRing α) (s : Set α) : Prop :=
   x ∈ Subring.closure (of '' s)
 #align free_comm_ring.is_supported FreeCommRing.IsSupported
+-/
 
 section IsSupported
 
 variable {x y : FreeCommRing α} {s t : Set α}
 
+#print FreeCommRing.isSupported_upwards /-
 theorem isSupported_upwards (hs : IsSupported x s) (hst : s ⊆ t) : IsSupported x t :=
   Subring.closure_mono (Set.monotone_image hst) hs
 #align free_comm_ring.is_supported_upwards FreeCommRing.isSupported_upwards
+-/
 
+/- warning: free_comm_ring.is_supported_add -> FreeCommRing.isSupported_add is a dubious translation:
+lean 3 declaration is
+  forall {α : Type.{u1}} {x : FreeCommRing.{u1} α} {y : FreeCommRing.{u1} α} {s : Set.{u1} α}, (FreeCommRing.IsSupported.{u1} α x s) -> (FreeCommRing.IsSupported.{u1} α y s) -> (FreeCommRing.IsSupported.{u1} α (HAdd.hAdd.{u1, u1, u1} (FreeCommRing.{u1} α) (FreeCommRing.{u1} α) (FreeCommRing.{u1} α) (instHAdd.{u1} (FreeCommRing.{u1} α) (Distrib.toHasAdd.{u1} (FreeCommRing.{u1} α) (Ring.toDistrib.{u1} (FreeCommRing.{u1} α) (CommRing.toRing.{u1} (FreeCommRing.{u1} α) (FreeCommRing.instCommRing.{u1} α))))) x y) s)
+but is expected to have type
+  forall {α : Type.{u1}} {x : FreeCommRing.{u1} α} {y : FreeCommRing.{u1} α} {s : Set.{u1} α}, (FreeCommRing.IsSupported.{u1} α x s) -> (FreeCommRing.IsSupported.{u1} α y s) -> (FreeCommRing.IsSupported.{u1} α (HAdd.hAdd.{u1, u1, u1} (FreeCommRing.{u1} α) (FreeCommRing.{u1} α) (FreeCommRing.{u1} α) (instHAdd.{u1} (FreeCommRing.{u1} α) (Distrib.toAdd.{u1} (FreeCommRing.{u1} α) (NonUnitalNonAssocSemiring.toDistrib.{u1} (FreeCommRing.{u1} α) (NonUnitalNonAssocRing.toNonUnitalNonAssocSemiring.{u1} (FreeCommRing.{u1} α) (NonAssocRing.toNonUnitalNonAssocRing.{u1} (FreeCommRing.{u1} α) (Ring.toNonAssocRing.{u1} (FreeCommRing.{u1} α) (CommRing.toRing.{u1} (FreeCommRing.{u1} α) (FreeCommRing.instCommRing.{u1} α)))))))) x y) s)
+Case conversion may be inaccurate. Consider using '#align free_comm_ring.is_supported_add FreeCommRing.isSupported_addₓ'. -/
 theorem isSupported_add (hxs : IsSupported x s) (hys : IsSupported y s) : IsSupported (x + y) s :=
   Subring.add_mem _ hxs hys
 #align free_comm_ring.is_supported_add FreeCommRing.isSupported_add
 
+/- warning: free_comm_ring.is_supported_neg -> FreeCommRing.isSupported_neg is a dubious translation:
+lean 3 declaration is
+  forall {α : Type.{u1}} {x : FreeCommRing.{u1} α} {s : Set.{u1} α}, (FreeCommRing.IsSupported.{u1} α x s) -> (FreeCommRing.IsSupported.{u1} α (Neg.neg.{u1} (FreeCommRing.{u1} α) (SubNegMonoid.toHasNeg.{u1} (FreeCommRing.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeCommRing.{u1} α) (AddGroupWithOne.toAddGroup.{u1} (FreeCommRing.{u1} α) (AddCommGroupWithOne.toAddGroupWithOne.{u1} (FreeCommRing.{u1} α) (Ring.toAddCommGroupWithOne.{u1} (FreeCommRing.{u1} α) (CommRing.toRing.{u1} (FreeCommRing.{u1} α) (FreeCommRing.instCommRing.{u1} α))))))) x) s)
+but is expected to have type
+  forall {α : Type.{u1}} {x : FreeCommRing.{u1} α} {s : Set.{u1} α}, (FreeCommRing.IsSupported.{u1} α x s) -> (FreeCommRing.IsSupported.{u1} α (Neg.neg.{u1} (FreeCommRing.{u1} α) (Ring.toNeg.{u1} (FreeCommRing.{u1} α) (CommRing.toRing.{u1} (FreeCommRing.{u1} α) (FreeCommRing.instCommRing.{u1} α))) x) s)
+Case conversion may be inaccurate. Consider using '#align free_comm_ring.is_supported_neg FreeCommRing.isSupported_negₓ'. -/
 theorem isSupported_neg (hxs : IsSupported x s) : IsSupported (-x) s :=
   Subring.neg_mem _ hxs
 #align free_comm_ring.is_supported_neg FreeCommRing.isSupported_neg
 
+/- warning: free_comm_ring.is_supported_sub -> FreeCommRing.isSupported_sub is a dubious translation:
+lean 3 declaration is
+  forall {α : Type.{u1}} {x : FreeCommRing.{u1} α} {y : FreeCommRing.{u1} α} {s : Set.{u1} α}, (FreeCommRing.IsSupported.{u1} α x s) -> (FreeCommRing.IsSupported.{u1} α y s) -> (FreeCommRing.IsSupported.{u1} α (HSub.hSub.{u1, u1, u1} (FreeCommRing.{u1} α) (FreeCommRing.{u1} α) (FreeCommRing.{u1} α) (instHSub.{u1} (FreeCommRing.{u1} α) (SubNegMonoid.toHasSub.{u1} (FreeCommRing.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeCommRing.{u1} α) (AddGroupWithOne.toAddGroup.{u1} (FreeCommRing.{u1} α) (AddCommGroupWithOne.toAddGroupWithOne.{u1} (FreeCommRing.{u1} α) (Ring.toAddCommGroupWithOne.{u1} (FreeCommRing.{u1} α) (CommRing.toRing.{u1} (FreeCommRing.{u1} α) (FreeCommRing.instCommRing.{u1} α)))))))) x y) s)
+but is expected to have type
+  forall {α : Type.{u1}} {x : FreeCommRing.{u1} α} {y : FreeCommRing.{u1} α} {s : Set.{u1} α}, (FreeCommRing.IsSupported.{u1} α x s) -> (FreeCommRing.IsSupported.{u1} α y s) -> (FreeCommRing.IsSupported.{u1} α (HSub.hSub.{u1, u1, u1} (FreeCommRing.{u1} α) (FreeCommRing.{u1} α) (FreeCommRing.{u1} α) (instHSub.{u1} (FreeCommRing.{u1} α) (Ring.toSub.{u1} (FreeCommRing.{u1} α) (CommRing.toRing.{u1} (FreeCommRing.{u1} α) (FreeCommRing.instCommRing.{u1} α)))) x y) s)
+Case conversion may be inaccurate. Consider using '#align free_comm_ring.is_supported_sub FreeCommRing.isSupported_subₓ'. -/
 theorem isSupported_sub (hxs : IsSupported x s) (hys : IsSupported y s) : IsSupported (x - y) s :=
   Subring.sub_mem _ hxs hys
 #align free_comm_ring.is_supported_sub FreeCommRing.isSupported_sub
 
+/- warning: free_comm_ring.is_supported_mul -> FreeCommRing.isSupported_mul is a dubious translation:
+lean 3 declaration is
+  forall {α : Type.{u1}} {x : FreeCommRing.{u1} α} {y : FreeCommRing.{u1} α} {s : Set.{u1} α}, (FreeCommRing.IsSupported.{u1} α x s) -> (FreeCommRing.IsSupported.{u1} α y s) -> (FreeCommRing.IsSupported.{u1} α (HMul.hMul.{u1, u1, u1} (FreeCommRing.{u1} α) (FreeCommRing.{u1} α) (FreeCommRing.{u1} α) (instHMul.{u1} (FreeCommRing.{u1} α) (Distrib.toHasMul.{u1} (FreeCommRing.{u1} α) (Ring.toDistrib.{u1} (FreeCommRing.{u1} α) (CommRing.toRing.{u1} (FreeCommRing.{u1} α) (FreeCommRing.instCommRing.{u1} α))))) x y) s)
+but is expected to have type
+  forall {α : Type.{u1}} {x : FreeCommRing.{u1} α} {y : FreeCommRing.{u1} α} {s : Set.{u1} α}, (FreeCommRing.IsSupported.{u1} α x s) -> (FreeCommRing.IsSupported.{u1} α y s) -> (FreeCommRing.IsSupported.{u1} α (HMul.hMul.{u1, u1, u1} (FreeCommRing.{u1} α) (FreeCommRing.{u1} α) (FreeCommRing.{u1} α) (instHMul.{u1} (FreeCommRing.{u1} α) (NonUnitalNonAssocRing.toMul.{u1} (FreeCommRing.{u1} α) (NonAssocRing.toNonUnitalNonAssocRing.{u1} (FreeCommRing.{u1} α) (Ring.toNonAssocRing.{u1} (FreeCommRing.{u1} α) (CommRing.toRing.{u1} (FreeCommRing.{u1} α) (FreeCommRing.instCommRing.{u1} α)))))) x y) s)
+Case conversion may be inaccurate. Consider using '#align free_comm_ring.is_supported_mul FreeCommRing.isSupported_mulₓ'. -/
 theorem isSupported_mul (hxs : IsSupported x s) (hys : IsSupported y s) : IsSupported (x * y) s :=
   Subring.mul_mem _ hxs hys
 #align free_comm_ring.is_supported_mul FreeCommRing.isSupported_mul
 
+/- warning: free_comm_ring.is_supported_zero -> FreeCommRing.isSupported_zero is a dubious translation:
+lean 3 declaration is
+  forall {α : Type.{u1}} {s : Set.{u1} α}, FreeCommRing.IsSupported.{u1} α (OfNat.ofNat.{u1} (FreeCommRing.{u1} α) 0 (OfNat.mk.{u1} (FreeCommRing.{u1} α) 0 (Zero.zero.{u1} (FreeCommRing.{u1} α) (MulZeroClass.toHasZero.{u1} (FreeCommRing.{u1} α) (NonUnitalNonAssocSemiring.toMulZeroClass.{u1} (FreeCommRing.{u1} α) (NonUnitalNonAssocRing.toNonUnitalNonAssocSemiring.{u1} (FreeCommRing.{u1} α) (NonAssocRing.toNonUnitalNonAssocRing.{u1} (FreeCommRing.{u1} α) (Ring.toNonAssocRing.{u1} (FreeCommRing.{u1} α) (CommRing.toRing.{u1} (FreeCommRing.{u1} α) (FreeCommRing.instCommRing.{u1} α)))))))))) s
+but is expected to have type
+  forall {α : Type.{u1}} {s : Set.{u1} α}, FreeCommRing.IsSupported.{u1} α (OfNat.ofNat.{u1} (FreeCommRing.{u1} α) 0 (Zero.toOfNat0.{u1} (FreeCommRing.{u1} α) (CommMonoidWithZero.toZero.{u1} (FreeCommRing.{u1} α) (CommSemiring.toCommMonoidWithZero.{u1} (FreeCommRing.{u1} α) (CommRing.toCommSemiring.{u1} (FreeCommRing.{u1} α) (FreeCommRing.instCommRing.{u1} α)))))) s
+Case conversion may be inaccurate. Consider using '#align free_comm_ring.is_supported_zero FreeCommRing.isSupported_zeroₓ'. -/
 theorem isSupported_zero : IsSupported 0 s :=
   Subring.zero_mem _
 #align free_comm_ring.is_supported_zero FreeCommRing.isSupported_zero
 
+/- warning: free_comm_ring.is_supported_one -> FreeCommRing.isSupported_one is a dubious translation:
+lean 3 declaration is
+  forall {α : Type.{u1}} {s : Set.{u1} α}, FreeCommRing.IsSupported.{u1} α (OfNat.ofNat.{u1} (FreeCommRing.{u1} α) 1 (OfNat.mk.{u1} (FreeCommRing.{u1} α) 1 (One.one.{u1} (FreeCommRing.{u1} α) (AddMonoidWithOne.toOne.{u1} (FreeCommRing.{u1} α) (AddGroupWithOne.toAddMonoidWithOne.{u1} (FreeCommRing.{u1} α) (AddCommGroupWithOne.toAddGroupWithOne.{u1} (FreeCommRing.{u1} α) (Ring.toAddCommGroupWithOne.{u1} (FreeCommRing.{u1} α) (CommRing.toRing.{u1} (FreeCommRing.{u1} α) (FreeCommRing.instCommRing.{u1} α))))))))) s
+but is expected to have type
+  forall {α : Type.{u1}} {s : Set.{u1} α}, FreeCommRing.IsSupported.{u1} α (OfNat.ofNat.{u1} (FreeCommRing.{u1} α) 1 (One.toOfNat1.{u1} (FreeCommRing.{u1} α) (Semiring.toOne.{u1} (FreeCommRing.{u1} α) (CommSemiring.toSemiring.{u1} (FreeCommRing.{u1} α) (CommRing.toCommSemiring.{u1} (FreeCommRing.{u1} α) (FreeCommRing.instCommRing.{u1} α)))))) s
+Case conversion may be inaccurate. Consider using '#align free_comm_ring.is_supported_one FreeCommRing.isSupported_oneₓ'. -/
 theorem isSupported_one : IsSupported 1 s :=
   Subring.one_mem _
 #align free_comm_ring.is_supported_one FreeCommRing.isSupported_one
 
+/- warning: free_comm_ring.is_supported_int -> FreeCommRing.isSupported_int is a dubious translation:
+lean 3 declaration is
+  forall {α : Type.{u1}} {i : Int} {s : Set.{u1} α}, FreeCommRing.IsSupported.{u1} α ((fun (a : Type) (b : Type.{u1}) [self : HasLiftT.{1, succ u1} a b] => self.0) Int (FreeCommRing.{u1} α) (HasLiftT.mk.{1, succ u1} Int (FreeCommRing.{u1} α) (CoeTCₓ.coe.{1, succ u1} Int (FreeCommRing.{u1} α) (Int.castCoe.{u1} (FreeCommRing.{u1} α) (AddGroupWithOne.toHasIntCast.{u1} (FreeCommRing.{u1} α) (AddCommGroupWithOne.toAddGroupWithOne.{u1} (FreeCommRing.{u1} α) (Ring.toAddCommGroupWithOne.{u1} (FreeCommRing.{u1} α) (CommRing.toRing.{u1} (FreeCommRing.{u1} α) (FreeCommRing.instCommRing.{u1} α)))))))) i) s
+but is expected to have type
+  forall {α : Type.{u1}} {i : Int} {s : Set.{u1} α}, FreeCommRing.IsSupported.{u1} α (Int.cast.{u1} (FreeCommRing.{u1} α) (Ring.toIntCast.{u1} (FreeCommRing.{u1} α) (CommRing.toRing.{u1} (FreeCommRing.{u1} α) (FreeCommRing.instCommRing.{u1} α))) i) s
+Case conversion may be inaccurate. Consider using '#align free_comm_ring.is_supported_int FreeCommRing.isSupported_intₓ'. -/
 theorem isSupported_int {i : ℤ} {s : Set α} : IsSupported (↑i) s :=
   Int.induction_on i isSupported_zero
     (fun i hi => by rw [Int.cast_add, Int.cast_one] <;> exact is_supported_add hi is_supported_one)
@@ -204,16 +286,24 @@ theorem isSupported_int {i : ℤ} {s : Set α} : IsSupported (↑i) s :=
 
 end IsSupported
 
+#print FreeCommRing.restriction /-
 /-- The restriction map from `free_comm_ring α` to `free_comm_ring s` where `s : set α`, defined
   by sending all variables not in `s` to zero. -/
 def restriction (s : Set α) [DecidablePred (· ∈ s)] : FreeCommRing α →+* FreeCommRing s :=
   lift fun p => if H : p ∈ s then of (⟨p, H⟩ : s) else 0
 #align free_comm_ring.restriction FreeCommRing.restriction
+-/
 
 section Restriction
 
 variable (s : Set α) [DecidablePred (· ∈ s)] (x y : FreeCommRing α)
 
+/- warning: free_comm_ring.restriction_of -> FreeCommRing.restriction_of is a dubious translation:
+lean 3 declaration is
+  forall {α : Type.{u1}} (s : Set.{u1} α) [_inst_1 : DecidablePred.{succ u1} α (fun (_x : α) => Membership.Mem.{u1, u1} α (Set.{u1} α) (Set.hasMem.{u1} α) _x s)] (p : α), Eq.{succ u1} (FreeCommRing.{u1} (coeSort.{succ u1, succ (succ u1)} (Set.{u1} α) Type.{u1} (Set.hasCoeToSort.{u1} α) s)) (coeFn.{succ u1, succ u1} (RingHom.{u1, u1} (FreeCommRing.{u1} α) (FreeCommRing.{u1} (coeSort.{succ u1, succ (succ u1)} (Set.{u1} α) Type.{u1} (Set.hasCoeToSort.{u1} α) s)) (NonAssocRing.toNonAssocSemiring.{u1} (FreeCommRing.{u1} α) (Ring.toNonAssocRing.{u1} (FreeCommRing.{u1} α) (CommRing.toRing.{u1} (FreeCommRing.{u1} α) (FreeCommRing.instCommRing.{u1} α)))) (NonAssocRing.toNonAssocSemiring.{u1} (FreeCommRing.{u1} (coeSort.{succ u1, succ (succ u1)} (Set.{u1} α) Type.{u1} (Set.hasCoeToSort.{u1} α) s)) (Ring.toNonAssocRing.{u1} (FreeCommRing.{u1} (coeSort.{succ u1, succ (succ u1)} (Set.{u1} α) Type.{u1} (Set.hasCoeToSort.{u1} α) s)) (CommRing.toRing.{u1} (FreeCommRing.{u1} (coeSort.{succ u1, succ (succ u1)} (Set.{u1} α) Type.{u1} (Set.hasCoeToSort.{u1} α) s)) (FreeCommRing.instCommRing.{u1} (coeSort.{succ u1, succ (succ u1)} (Set.{u1} α) Type.{u1} (Set.hasCoeToSort.{u1} α) s)))))) (fun (_x : RingHom.{u1, u1} (FreeCommRing.{u1} α) (FreeCommRing.{u1} (coeSort.{succ u1, succ (succ u1)} (Set.{u1} α) Type.{u1} (Set.hasCoeToSort.{u1} α) s)) (NonAssocRing.toNonAssocSemiring.{u1} (FreeCommRing.{u1} α) (Ring.toNonAssocRing.{u1} (FreeCommRing.{u1} α) (CommRing.toRing.{u1} (FreeCommRing.{u1} α) (FreeCommRing.instCommRing.{u1} α)))) (NonAssocRing.toNonAssocSemiring.{u1} (FreeCommRing.{u1} (coeSort.{succ u1, succ (succ u1)} (Set.{u1} α) Type.{u1} (Set.hasCoeToSort.{u1} α) s)) (Ring.toNonAssocRing.{u1} (FreeCommRing.{u1} (coeSort.{succ u1, succ (succ u1)} (Set.{u1} α) Type.{u1} (Set.hasCoeToSort.{u1} α) s)) (CommRing.toRing.{u1} (FreeCommRing.{u1} (coeSort.{succ u1, succ (succ u1)} (Set.{u1} α) Type.{u1} (Set.hasCoeToSort.{u1} α) s)) (FreeCommRing.instCommRing.{u1} (coeSort.{succ u1, succ (succ u1)} (Set.{u1} α) Type.{u1} (Set.hasCoeToSort.{u1} α) s)))))) => (FreeCommRing.{u1} α) -> (FreeCommRing.{u1} (coeSort.{succ u1, succ (succ u1)} (Set.{u1} α) Type.{u1} (Set.hasCoeToSort.{u1} α) s))) (RingHom.hasCoeToFun.{u1, u1} (FreeCommRing.{u1} α) (FreeCommRing.{u1} (coeSort.{succ u1, succ (succ u1)} (Set.{u1} α) Type.{u1} (Set.hasCoeToSort.{u1} α) s)) (NonAssocRing.toNonAssocSemiring.{u1} (FreeCommRing.{u1} α) (Ring.toNonAssocRing.{u1} (FreeCommRing.{u1} α) (CommRing.toRing.{u1} (FreeCommRing.{u1} α) (FreeCommRing.instCommRing.{u1} α)))) (NonAssocRing.toNonAssocSemiring.{u1} (FreeCommRing.{u1} (coeSort.{succ u1, succ (succ u1)} (Set.{u1} α) Type.{u1} (Set.hasCoeToSort.{u1} α) s)) (Ring.toNonAssocRing.{u1} (FreeCommRing.{u1} (coeSort.{succ u1, succ (succ u1)} (Set.{u1} α) Type.{u1} (Set.hasCoeToSort.{u1} α) s)) (CommRing.toRing.{u1} (FreeCommRing.{u1} (coeSort.{succ u1, succ (succ u1)} (Set.{u1} α) Type.{u1} (Set.hasCoeToSort.{u1} α) s)) (FreeCommRing.instCommRing.{u1} (coeSort.{succ u1, succ (succ u1)} (Set.{u1} α) Type.{u1} (Set.hasCoeToSort.{u1} α) s)))))) (FreeCommRing.restriction.{u1} α s (fun (a : α) => _inst_1 a)) (FreeCommRing.of.{u1} α p)) (dite.{succ u1} (FreeCommRing.{u1} (coeSort.{succ u1, succ (succ u1)} (Set.{u1} α) Type.{u1} (Set.hasCoeToSort.{u1} α) s)) (Membership.Mem.{u1, u1} α (Set.{u1} α) (Set.hasMem.{u1} α) p s) (_inst_1 p) (fun (H : Membership.Mem.{u1, u1} α (Set.{u1} α) (Set.hasMem.{u1} α) p s) => FreeCommRing.of.{u1} (coeSort.{succ u1, succ (succ u1)} (Set.{u1} α) Type.{u1} (Set.hasCoeToSort.{u1} α) s) (Subtype.mk.{succ u1} α (fun (x : α) => Membership.Mem.{u1, u1} α (Set.{u1} α) (Set.hasMem.{u1} α) x s) p H)) (fun (H : Not (Membership.Mem.{u1, u1} α (Set.{u1} α) (Set.hasMem.{u1} α) p s)) => OfNat.ofNat.{u1} (FreeCommRing.{u1} (coeSort.{succ u1, succ (succ u1)} (Set.{u1} α) Type.{u1} (Set.hasCoeToSort.{u1} α) s)) 0 (OfNat.mk.{u1} (FreeCommRing.{u1} (coeSort.{succ u1, succ (succ u1)} (Set.{u1} α) Type.{u1} (Set.hasCoeToSort.{u1} α) s)) 0 (Zero.zero.{u1} (FreeCommRing.{u1} (coeSort.{succ u1, succ (succ u1)} (Set.{u1} α) Type.{u1} (Set.hasCoeToSort.{u1} α) s)) (MulZeroClass.toHasZero.{u1} (FreeCommRing.{u1} (coeSort.{succ u1, succ (succ u1)} (Set.{u1} α) Type.{u1} (Set.hasCoeToSort.{u1} α) s)) (NonUnitalNonAssocSemiring.toMulZeroClass.{u1} (FreeCommRing.{u1} (coeSort.{succ u1, succ (succ u1)} (Set.{u1} α) Type.{u1} (Set.hasCoeToSort.{u1} α) s)) (NonUnitalNonAssocRing.toNonUnitalNonAssocSemiring.{u1} (FreeCommRing.{u1} (coeSort.{succ u1, succ (succ u1)} (Set.{u1} α) Type.{u1} (Set.hasCoeToSort.{u1} α) s)) (NonAssocRing.toNonUnitalNonAssocRing.{u1} (FreeCommRing.{u1} (coeSort.{succ u1, succ (succ u1)} (Set.{u1} α) Type.{u1} (Set.hasCoeToSort.{u1} α) s)) (Ring.toNonAssocRing.{u1} (FreeCommRing.{u1} (coeSort.{succ u1, succ (succ u1)} (Set.{u1} α) Type.{u1} (Set.hasCoeToSort.{u1} α) s)) (CommRing.toRing.{u1} (FreeCommRing.{u1} (coeSort.{succ u1, succ (succ u1)} (Set.{u1} α) Type.{u1} (Set.hasCoeToSort.{u1} α) s)) (FreeCommRing.instCommRing.{u1} (coeSort.{succ u1, succ (succ u1)} (Set.{u1} α) Type.{u1} (Set.hasCoeToSort.{u1} α) s))))))))))))
+but is expected to have type
+  forall {α : Type.{u1}} (s : Set.{u1} α) [_inst_1 : DecidablePred.{succ u1} α (fun (_x : α) => Membership.mem.{u1, u1} α (Set.{u1} α) (Set.instMembershipSet.{u1} α) _x s)] (p : α), Eq.{succ u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : FreeCommRing.{u1} α) => FreeCommRing.{u1} (Set.Elem.{u1} α s)) (FreeCommRing.of.{u1} α p)) (FunLike.coe.{succ u1, succ u1, succ u1} (RingHom.{u1, u1} (FreeCommRing.{u1} α) (FreeCommRing.{u1} (Set.Elem.{u1} α s)) (Semiring.toNonAssocSemiring.{u1} (FreeCommRing.{u1} α) (CommSemiring.toSemiring.{u1} (FreeCommRing.{u1} α) (CommRing.toCommSemiring.{u1} (FreeCommRing.{u1} α) (FreeCommRing.instCommRing.{u1} α)))) (Semiring.toNonAssocSemiring.{u1} (FreeCommRing.{u1} (Set.Elem.{u1} α s)) (CommSemiring.toSemiring.{u1} (FreeCommRing.{u1} (Set.Elem.{u1} α s)) (CommRing.toCommSemiring.{u1} (FreeCommRing.{u1} (Set.Elem.{u1} α s)) (FreeCommRing.instCommRing.{u1} (Set.Elem.{u1} α s)))))) (FreeCommRing.{u1} α) (fun (_x : FreeCommRing.{u1} α) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : FreeCommRing.{u1} α) => FreeCommRing.{u1} (Set.Elem.{u1} α s)) _x) (MulHomClass.toFunLike.{u1, u1, u1} (RingHom.{u1, u1} (FreeCommRing.{u1} α) (FreeCommRing.{u1} (Set.Elem.{u1} α s)) (Semiring.toNonAssocSemiring.{u1} (FreeCommRing.{u1} α) (CommSemiring.toSemiring.{u1} (FreeCommRing.{u1} α) (CommRing.toCommSemiring.{u1} (FreeCommRing.{u1} α) (FreeCommRing.instCommRing.{u1} α)))) (Semiring.toNonAssocSemiring.{u1} (FreeCommRing.{u1} (Set.Elem.{u1} α s)) (CommSemiring.toSemiring.{u1} (FreeCommRing.{u1} (Set.Elem.{u1} α s)) (CommRing.toCommSemiring.{u1} (FreeCommRing.{u1} (Set.Elem.{u1} α s)) (FreeCommRing.instCommRing.{u1} (Set.Elem.{u1} α s)))))) (FreeCommRing.{u1} α) (FreeCommRing.{u1} (Set.Elem.{u1} α s)) (NonUnitalNonAssocSemiring.toMul.{u1} (FreeCommRing.{u1} α) (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u1} (FreeCommRing.{u1} α) (Semiring.toNonAssocSemiring.{u1} (FreeCommRing.{u1} α) (CommSemiring.toSemiring.{u1} (FreeCommRing.{u1} α) (CommRing.toCommSemiring.{u1} (FreeCommRing.{u1} α) (FreeCommRing.instCommRing.{u1} α)))))) (NonUnitalNonAssocSemiring.toMul.{u1} (FreeCommRing.{u1} (Set.Elem.{u1} α s)) (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u1} (FreeCommRing.{u1} (Set.Elem.{u1} α s)) (Semiring.toNonAssocSemiring.{u1} (FreeCommRing.{u1} (Set.Elem.{u1} α s)) (CommSemiring.toSemiring.{u1} (FreeCommRing.{u1} (Set.Elem.{u1} α s)) (CommRing.toCommSemiring.{u1} (FreeCommRing.{u1} (Set.Elem.{u1} α s)) (FreeCommRing.instCommRing.{u1} (Set.Elem.{u1} α s))))))) (NonUnitalRingHomClass.toMulHomClass.{u1, u1, u1} (RingHom.{u1, u1} (FreeCommRing.{u1} α) (FreeCommRing.{u1} (Set.Elem.{u1} α s)) (Semiring.toNonAssocSemiring.{u1} (FreeCommRing.{u1} α) (CommSemiring.toSemiring.{u1} (FreeCommRing.{u1} α) (CommRing.toCommSemiring.{u1} (FreeCommRing.{u1} α) (FreeCommRing.instCommRing.{u1} α)))) (Semiring.toNonAssocSemiring.{u1} (FreeCommRing.{u1} (Set.Elem.{u1} α s)) (CommSemiring.toSemiring.{u1} (FreeCommRing.{u1} (Set.Elem.{u1} α s)) (CommRing.toCommSemiring.{u1} (FreeCommRing.{u1} (Set.Elem.{u1} α s)) (FreeCommRing.instCommRing.{u1} (Set.Elem.{u1} α s)))))) (FreeCommRing.{u1} α) (FreeCommRing.{u1} (Set.Elem.{u1} α s)) (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u1} (FreeCommRing.{u1} α) (Semiring.toNonAssocSemiring.{u1} (FreeCommRing.{u1} α) (CommSemiring.toSemiring.{u1} (FreeCommRing.{u1} α) (CommRing.toCommSemiring.{u1} (FreeCommRing.{u1} α) (FreeCommRing.instCommRing.{u1} α))))) (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u1} (FreeCommRing.{u1} (Set.Elem.{u1} α s)) (Semiring.toNonAssocSemiring.{u1} (FreeCommRing.{u1} (Set.Elem.{u1} α s)) (CommSemiring.toSemiring.{u1} (FreeCommRing.{u1} (Set.Elem.{u1} α s)) (CommRing.toCommSemiring.{u1} (FreeCommRing.{u1} (Set.Elem.{u1} α s)) (FreeCommRing.instCommRing.{u1} (Set.Elem.{u1} α s)))))) (RingHomClass.toNonUnitalRingHomClass.{u1, u1, u1} (RingHom.{u1, u1} (FreeCommRing.{u1} α) (FreeCommRing.{u1} (Set.Elem.{u1} α s)) (Semiring.toNonAssocSemiring.{u1} (FreeCommRing.{u1} α) (CommSemiring.toSemiring.{u1} (FreeCommRing.{u1} α) (CommRing.toCommSemiring.{u1} (FreeCommRing.{u1} α) (FreeCommRing.instCommRing.{u1} α)))) (Semiring.toNonAssocSemiring.{u1} (FreeCommRing.{u1} (Set.Elem.{u1} α s)) (CommSemiring.toSemiring.{u1} (FreeCommRing.{u1} (Set.Elem.{u1} α s)) (CommRing.toCommSemiring.{u1} (FreeCommRing.{u1} (Set.Elem.{u1} α s)) (FreeCommRing.instCommRing.{u1} (Set.Elem.{u1} α s)))))) (FreeCommRing.{u1} α) (FreeCommRing.{u1} (Set.Elem.{u1} α s)) (Semiring.toNonAssocSemiring.{u1} (FreeCommRing.{u1} α) (CommSemiring.toSemiring.{u1} (FreeCommRing.{u1} α) (CommRing.toCommSemiring.{u1} (FreeCommRing.{u1} α) (FreeCommRing.instCommRing.{u1} α)))) (Semiring.toNonAssocSemiring.{u1} (FreeCommRing.{u1} (Set.Elem.{u1} α s)) (CommSemiring.toSemiring.{u1} (FreeCommRing.{u1} (Set.Elem.{u1} α s)) (CommRing.toCommSemiring.{u1} (FreeCommRing.{u1} (Set.Elem.{u1} α s)) (FreeCommRing.instCommRing.{u1} (Set.Elem.{u1} α s))))) (RingHom.instRingHomClassRingHom.{u1, u1} (FreeCommRing.{u1} α) (FreeCommRing.{u1} (Set.Elem.{u1} α s)) (Semiring.toNonAssocSemiring.{u1} (FreeCommRing.{u1} α) (CommSemiring.toSemiring.{u1} (FreeCommRing.{u1} α) (CommRing.toCommSemiring.{u1} (FreeCommRing.{u1} α) (FreeCommRing.instCommRing.{u1} α)))) (Semiring.toNonAssocSemiring.{u1} (FreeCommRing.{u1} (Set.Elem.{u1} α s)) (CommSemiring.toSemiring.{u1} (FreeCommRing.{u1} (Set.Elem.{u1} α s)) (CommRing.toCommSemiring.{u1} (FreeCommRing.{u1} (Set.Elem.{u1} α s)) (FreeCommRing.instCommRing.{u1} (Set.Elem.{u1} α s))))))))) (FreeCommRing.restriction.{u1} α s (fun (a : α) => _inst_1 a)) (FreeCommRing.of.{u1} α p)) (dite.{succ u1} (FreeCommRing.{u1} (Set.Elem.{u1} α s)) (Membership.mem.{u1, u1} α (Set.{u1} α) (Set.instMembershipSet.{u1} α) p s) (_inst_1 p) (fun (H : Membership.mem.{u1, u1} α (Set.{u1} α) (Set.instMembershipSet.{u1} α) p s) => FreeCommRing.of.{u1} (Set.Elem.{u1} α s) (Subtype.mk.{succ u1} α (fun (x : α) => Membership.mem.{u1, u1} α (Set.{u1} α) (Set.instMembershipSet.{u1} α) x s) p H)) (fun (H : Not (Membership.mem.{u1, u1} α (Set.{u1} α) (Set.instMembershipSet.{u1} α) p s)) => OfNat.ofNat.{u1} (FreeCommRing.{u1} (Set.Elem.{u1} α s)) 0 (Zero.toOfNat0.{u1} (FreeCommRing.{u1} (Set.Elem.{u1} α s)) (CommMonoidWithZero.toZero.{u1} (FreeCommRing.{u1} (Set.Elem.{u1} α s)) (CommSemiring.toCommMonoidWithZero.{u1} (FreeCommRing.{u1} (Set.Elem.{u1} α s)) (CommRing.toCommSemiring.{u1} (FreeCommRing.{u1} (Set.Elem.{u1} α s)) (FreeCommRing.instCommRing.{u1} (Set.Elem.{u1} α s))))))))
+Case conversion may be inaccurate. Consider using '#align free_comm_ring.restriction_of FreeCommRing.restriction_ofₓ'. -/
 @[simp]
 theorem restriction_of (p) : restriction s (of p) = if H : p ∈ s then of ⟨p, H⟩ else 0 :=
   lift_of _ _
@@ -221,6 +311,7 @@ theorem restriction_of (p) : restriction s (of p) = if H : p ∈ s then of ⟨p,
 
 end Restriction
 
+#print FreeCommRing.isSupported_of /-
 theorem isSupported_of {p} {s : Set α} : IsSupported (of p) s ↔ p ∈ s :=
   suffices IsSupported (of p) s → p ∈ s from ⟨this, fun hps => Subring.subset_closure ⟨p, hps, rfl⟩⟩
   fun hps : IsSupported (of p) s =>
@@ -257,7 +348,14 @@ theorem isSupported_of {p} {s : Set α} : IsSupported (of p) s ↔ p ∈ s :=
   have : polynomial.X.coeff 1 = (Polynomial.C ↑w).coeff 1 := by rw [H]
   rwa [Polynomial.coeff_C, if_neg (one_ne_zero : 1 ≠ 0), Polynomial.coeff_X, if_pos rfl] at this
 #align free_comm_ring.is_supported_of FreeCommRing.isSupported_of
+-/
 
+/- warning: free_comm_ring.map_subtype_val_restriction -> FreeCommRing.map_subtype_val_restriction is a dubious translation:
+lean 3 declaration is
+  forall {α : Type.{u1}} {x : FreeCommRing.{u1} α} (s : Set.{u1} α) [_inst_1 : DecidablePred.{succ u1} α (fun (_x : α) => Membership.Mem.{u1, u1} α (Set.{u1} α) (Set.hasMem.{u1} α) _x s)], (FreeCommRing.IsSupported.{u1} α x s) -> (Eq.{succ u1} (FreeCommRing.{u1} α) (coeFn.{succ u1, succ u1} (RingHom.{u1, u1} (FreeCommRing.{u1} (Subtype.{succ u1} α (fun (x : α) => Membership.Mem.{u1, u1} α (Set.{u1} α) (Set.hasMem.{u1} α) x s))) (FreeCommRing.{u1} α) (NonAssocRing.toNonAssocSemiring.{u1} (FreeCommRing.{u1} (Subtype.{succ u1} α (fun (x : α) => Membership.Mem.{u1, u1} α (Set.{u1} α) (Set.hasMem.{u1} α) x s))) (Ring.toNonAssocRing.{u1} (FreeCommRing.{u1} (Subtype.{succ u1} α (fun (x : α) => Membership.Mem.{u1, u1} α (Set.{u1} α) (Set.hasMem.{u1} α) x s))) (CommRing.toRing.{u1} (FreeCommRing.{u1} (Subtype.{succ u1} α (fun (x : α) => Membership.Mem.{u1, u1} α (Set.{u1} α) (Set.hasMem.{u1} α) x s))) (FreeCommRing.instCommRing.{u1} (Subtype.{succ u1} α (fun (x : α) => Membership.Mem.{u1, u1} α (Set.{u1} α) (Set.hasMem.{u1} α) x s)))))) (NonAssocRing.toNonAssocSemiring.{u1} (FreeCommRing.{u1} α) (Ring.toNonAssocRing.{u1} (FreeCommRing.{u1} α) (CommRing.toRing.{u1} (FreeCommRing.{u1} α) (FreeCommRing.instCommRing.{u1} α))))) (fun (_x : RingHom.{u1, u1} (FreeCommRing.{u1} (Subtype.{succ u1} α (fun (x : α) => Membership.Mem.{u1, u1} α (Set.{u1} α) (Set.hasMem.{u1} α) x s))) (FreeCommRing.{u1} α) (NonAssocRing.toNonAssocSemiring.{u1} (FreeCommRing.{u1} (Subtype.{succ u1} α (fun (x : α) => Membership.Mem.{u1, u1} α (Set.{u1} α) (Set.hasMem.{u1} α) x s))) (Ring.toNonAssocRing.{u1} (FreeCommRing.{u1} (Subtype.{succ u1} α (fun (x : α) => Membership.Mem.{u1, u1} α (Set.{u1} α) (Set.hasMem.{u1} α) x s))) (CommRing.toRing.{u1} (FreeCommRing.{u1} (Subtype.{succ u1} α (fun (x : α) => Membership.Mem.{u1, u1} α (Set.{u1} α) (Set.hasMem.{u1} α) x s))) (FreeCommRing.instCommRing.{u1} (Subtype.{succ u1} α (fun (x : α) => Membership.Mem.{u1, u1} α (Set.{u1} α) (Set.hasMem.{u1} α) x s)))))) (NonAssocRing.toNonAssocSemiring.{u1} (FreeCommRing.{u1} α) (Ring.toNonAssocRing.{u1} (FreeCommRing.{u1} α) (CommRing.toRing.{u1} (FreeCommRing.{u1} α) (FreeCommRing.instCommRing.{u1} α))))) => (FreeCommRing.{u1} (Subtype.{succ u1} α (fun (x : α) => Membership.Mem.{u1, u1} α (Set.{u1} α) (Set.hasMem.{u1} α) x s))) -> (FreeCommRing.{u1} α)) (RingHom.hasCoeToFun.{u1, u1} (FreeCommRing.{u1} (Subtype.{succ u1} α (fun (x : α) => Membership.Mem.{u1, u1} α (Set.{u1} α) (Set.hasMem.{u1} α) x s))) (FreeCommRing.{u1} α) (NonAssocRing.toNonAssocSemiring.{u1} (FreeCommRing.{u1} (Subtype.{succ u1} α (fun (x : α) => Membership.Mem.{u1, u1} α (Set.{u1} α) (Set.hasMem.{u1} α) x s))) (Ring.toNonAssocRing.{u1} (FreeCommRing.{u1} (Subtype.{succ u1} α (fun (x : α) => Membership.Mem.{u1, u1} α (Set.{u1} α) (Set.hasMem.{u1} α) x s))) (CommRing.toRing.{u1} (FreeCommRing.{u1} (Subtype.{succ u1} α (fun (x : α) => Membership.Mem.{u1, u1} α (Set.{u1} α) (Set.hasMem.{u1} α) x s))) (FreeCommRing.instCommRing.{u1} (Subtype.{succ u1} α (fun (x : α) => Membership.Mem.{u1, u1} α (Set.{u1} α) (Set.hasMem.{u1} α) x s)))))) (NonAssocRing.toNonAssocSemiring.{u1} (FreeCommRing.{u1} α) (Ring.toNonAssocRing.{u1} (FreeCommRing.{u1} α) (CommRing.toRing.{u1} (FreeCommRing.{u1} α) (FreeCommRing.instCommRing.{u1} α))))) (FreeCommRing.map.{u1, u1} (Subtype.{succ u1} α (fun (x : α) => Membership.Mem.{u1, u1} α (Set.{u1} α) (Set.hasMem.{u1} α) x s)) α (Subtype.val.{succ u1} α (fun (x : α) => Membership.Mem.{u1, u1} α (Set.{u1} α) (Set.hasMem.{u1} α) x s))) (coeFn.{succ u1, succ u1} (RingHom.{u1, u1} (FreeCommRing.{u1} α) (FreeCommRing.{u1} (coeSort.{succ u1, succ (succ u1)} (Set.{u1} α) Type.{u1} (Set.hasCoeToSort.{u1} α) s)) (NonAssocRing.toNonAssocSemiring.{u1} (FreeCommRing.{u1} α) (Ring.toNonAssocRing.{u1} (FreeCommRing.{u1} α) (CommRing.toRing.{u1} (FreeCommRing.{u1} α) (FreeCommRing.instCommRing.{u1} α)))) (NonAssocRing.toNonAssocSemiring.{u1} (FreeCommRing.{u1} (coeSort.{succ u1, succ (succ u1)} (Set.{u1} α) Type.{u1} (Set.hasCoeToSort.{u1} α) s)) (Ring.toNonAssocRing.{u1} (FreeCommRing.{u1} (coeSort.{succ u1, succ (succ u1)} (Set.{u1} α) Type.{u1} (Set.hasCoeToSort.{u1} α) s)) (CommRing.toRing.{u1} (FreeCommRing.{u1} (coeSort.{succ u1, succ (succ u1)} (Set.{u1} α) Type.{u1} (Set.hasCoeToSort.{u1} α) s)) (FreeCommRing.instCommRing.{u1} (coeSort.{succ u1, succ (succ u1)} (Set.{u1} α) Type.{u1} (Set.hasCoeToSort.{u1} α) s)))))) (fun (_x : RingHom.{u1, u1} (FreeCommRing.{u1} α) (FreeCommRing.{u1} (coeSort.{succ u1, succ (succ u1)} (Set.{u1} α) Type.{u1} (Set.hasCoeToSort.{u1} α) s)) (NonAssocRing.toNonAssocSemiring.{u1} (FreeCommRing.{u1} α) (Ring.toNonAssocRing.{u1} (FreeCommRing.{u1} α) (CommRing.toRing.{u1} (FreeCommRing.{u1} α) (FreeCommRing.instCommRing.{u1} α)))) (NonAssocRing.toNonAssocSemiring.{u1} (FreeCommRing.{u1} (coeSort.{succ u1, succ (succ u1)} (Set.{u1} α) Type.{u1} (Set.hasCoeToSort.{u1} α) s)) (Ring.toNonAssocRing.{u1} (FreeCommRing.{u1} (coeSort.{succ u1, succ (succ u1)} (Set.{u1} α) Type.{u1} (Set.hasCoeToSort.{u1} α) s)) (CommRing.toRing.{u1} (FreeCommRing.{u1} (coeSort.{succ u1, succ (succ u1)} (Set.{u1} α) Type.{u1} (Set.hasCoeToSort.{u1} α) s)) (FreeCommRing.instCommRing.{u1} (coeSort.{succ u1, succ (succ u1)} (Set.{u1} α) Type.{u1} (Set.hasCoeToSort.{u1} α) s)))))) => (FreeCommRing.{u1} α) -> (FreeCommRing.{u1} (coeSort.{succ u1, succ (succ u1)} (Set.{u1} α) Type.{u1} (Set.hasCoeToSort.{u1} α) s))) (RingHom.hasCoeToFun.{u1, u1} (FreeCommRing.{u1} α) (FreeCommRing.{u1} (coeSort.{succ u1, succ (succ u1)} (Set.{u1} α) Type.{u1} (Set.hasCoeToSort.{u1} α) s)) (NonAssocRing.toNonAssocSemiring.{u1} (FreeCommRing.{u1} α) (Ring.toNonAssocRing.{u1} (FreeCommRing.{u1} α) (CommRing.toRing.{u1} (FreeCommRing.{u1} α) (FreeCommRing.instCommRing.{u1} α)))) (NonAssocRing.toNonAssocSemiring.{u1} (FreeCommRing.{u1} (coeSort.{succ u1, succ (succ u1)} (Set.{u1} α) Type.{u1} (Set.hasCoeToSort.{u1} α) s)) (Ring.toNonAssocRing.{u1} (FreeCommRing.{u1} (coeSort.{succ u1, succ (succ u1)} (Set.{u1} α) Type.{u1} (Set.hasCoeToSort.{u1} α) s)) (CommRing.toRing.{u1} (FreeCommRing.{u1} (coeSort.{succ u1, succ (succ u1)} (Set.{u1} α) Type.{u1} (Set.hasCoeToSort.{u1} α) s)) (FreeCommRing.instCommRing.{u1} (coeSort.{succ u1, succ (succ u1)} (Set.{u1} α) Type.{u1} (Set.hasCoeToSort.{u1} α) s)))))) (FreeCommRing.restriction.{u1} α s (fun (a : α) => _inst_1 a)) x)) x)
+but is expected to have type
+  forall {α : Type.{u1}} {x : FreeCommRing.{u1} α} (s : Set.{u1} α) [_inst_1 : DecidablePred.{succ u1} α (fun (_x : α) => Membership.mem.{u1, u1} α (Set.{u1} α) (Set.instMembershipSet.{u1} α) _x s)], (FreeCommRing.IsSupported.{u1} α x s) -> (Eq.{succ u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : FreeCommRing.{u1} (Set.Elem.{u1} α s)) => FreeCommRing.{u1} α) (FunLike.coe.{succ u1, succ u1, succ u1} (RingHom.{u1, u1} (FreeCommRing.{u1} α) (FreeCommRing.{u1} (Set.Elem.{u1} α s)) (Semiring.toNonAssocSemiring.{u1} (FreeCommRing.{u1} α) (CommSemiring.toSemiring.{u1} (FreeCommRing.{u1} α) (CommRing.toCommSemiring.{u1} (FreeCommRing.{u1} α) (FreeCommRing.instCommRing.{u1} α)))) (Semiring.toNonAssocSemiring.{u1} (FreeCommRing.{u1} (Set.Elem.{u1} α s)) (CommSemiring.toSemiring.{u1} (FreeCommRing.{u1} (Set.Elem.{u1} α s)) (CommRing.toCommSemiring.{u1} (FreeCommRing.{u1} (Set.Elem.{u1} α s)) (FreeCommRing.instCommRing.{u1} (Set.Elem.{u1} α s)))))) (FreeCommRing.{u1} α) (fun (a : FreeCommRing.{u1} α) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : FreeCommRing.{u1} α) => FreeCommRing.{u1} (Set.Elem.{u1} α s)) a) (MulHomClass.toFunLike.{u1, u1, u1} (RingHom.{u1, u1} (FreeCommRing.{u1} α) (FreeCommRing.{u1} (Set.Elem.{u1} α s)) (Semiring.toNonAssocSemiring.{u1} (FreeCommRing.{u1} α) (CommSemiring.toSemiring.{u1} (FreeCommRing.{u1} α) (CommRing.toCommSemiring.{u1} (FreeCommRing.{u1} α) (FreeCommRing.instCommRing.{u1} α)))) (Semiring.toNonAssocSemiring.{u1} (FreeCommRing.{u1} (Set.Elem.{u1} α s)) (CommSemiring.toSemiring.{u1} (FreeCommRing.{u1} (Set.Elem.{u1} α s)) (CommRing.toCommSemiring.{u1} (FreeCommRing.{u1} (Set.Elem.{u1} α s)) (FreeCommRing.instCommRing.{u1} (Set.Elem.{u1} α s)))))) (FreeCommRing.{u1} α) (FreeCommRing.{u1} (Set.Elem.{u1} α s)) (NonUnitalNonAssocSemiring.toMul.{u1} (FreeCommRing.{u1} α) (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u1} (FreeCommRing.{u1} α) (Semiring.toNonAssocSemiring.{u1} (FreeCommRing.{u1} α) (CommSemiring.toSemiring.{u1} (FreeCommRing.{u1} α) (CommRing.toCommSemiring.{u1} (FreeCommRing.{u1} α) (FreeCommRing.instCommRing.{u1} α)))))) (NonUnitalNonAssocSemiring.toMul.{u1} (FreeCommRing.{u1} (Set.Elem.{u1} α s)) (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u1} (FreeCommRing.{u1} (Set.Elem.{u1} α s)) (Semiring.toNonAssocSemiring.{u1} (FreeCommRing.{u1} (Set.Elem.{u1} α s)) (CommSemiring.toSemiring.{u1} (FreeCommRing.{u1} (Set.Elem.{u1} α s)) (CommRing.toCommSemiring.{u1} (FreeCommRing.{u1} (Set.Elem.{u1} α s)) (FreeCommRing.instCommRing.{u1} (Set.Elem.{u1} α s))))))) (NonUnitalRingHomClass.toMulHomClass.{u1, u1, u1} (RingHom.{u1, u1} (FreeCommRing.{u1} α) (FreeCommRing.{u1} (Set.Elem.{u1} α s)) (Semiring.toNonAssocSemiring.{u1} (FreeCommRing.{u1} α) (CommSemiring.toSemiring.{u1} (FreeCommRing.{u1} α) (CommRing.toCommSemiring.{u1} (FreeCommRing.{u1} α) (FreeCommRing.instCommRing.{u1} α)))) (Semiring.toNonAssocSemiring.{u1} (FreeCommRing.{u1} (Set.Elem.{u1} α s)) (CommSemiring.toSemiring.{u1} (FreeCommRing.{u1} (Set.Elem.{u1} α s)) (CommRing.toCommSemiring.{u1} (FreeCommRing.{u1} (Set.Elem.{u1} α s)) (FreeCommRing.instCommRing.{u1} (Set.Elem.{u1} α s)))))) (FreeCommRing.{u1} α) (FreeCommRing.{u1} (Set.Elem.{u1} α s)) (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u1} (FreeCommRing.{u1} α) (Semiring.toNonAssocSemiring.{u1} (FreeCommRing.{u1} α) (CommSemiring.toSemiring.{u1} (FreeCommRing.{u1} α) (CommRing.toCommSemiring.{u1} (FreeCommRing.{u1} α) (FreeCommRing.instCommRing.{u1} α))))) (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u1} (FreeCommRing.{u1} (Set.Elem.{u1} α s)) (Semiring.toNonAssocSemiring.{u1} (FreeCommRing.{u1} (Set.Elem.{u1} α s)) (CommSemiring.toSemiring.{u1} (FreeCommRing.{u1} (Set.Elem.{u1} α s)) (CommRing.toCommSemiring.{u1} (FreeCommRing.{u1} (Set.Elem.{u1} α s)) (FreeCommRing.instCommRing.{u1} (Set.Elem.{u1} α s)))))) (RingHomClass.toNonUnitalRingHomClass.{u1, u1, u1} (RingHom.{u1, u1} (FreeCommRing.{u1} α) (FreeCommRing.{u1} (Set.Elem.{u1} α s)) (Semiring.toNonAssocSemiring.{u1} (FreeCommRing.{u1} α) (CommSemiring.toSemiring.{u1} (FreeCommRing.{u1} α) (CommRing.toCommSemiring.{u1} (FreeCommRing.{u1} α) (FreeCommRing.instCommRing.{u1} α)))) (Semiring.toNonAssocSemiring.{u1} (FreeCommRing.{u1} (Set.Elem.{u1} α s)) (CommSemiring.toSemiring.{u1} (FreeCommRing.{u1} (Set.Elem.{u1} α s)) (CommRing.toCommSemiring.{u1} (FreeCommRing.{u1} (Set.Elem.{u1} α s)) (FreeCommRing.instCommRing.{u1} (Set.Elem.{u1} α s)))))) (FreeCommRing.{u1} α) (FreeCommRing.{u1} (Set.Elem.{u1} α s)) (Semiring.toNonAssocSemiring.{u1} (FreeCommRing.{u1} α) (CommSemiring.toSemiring.{u1} (FreeCommRing.{u1} α) (CommRing.toCommSemiring.{u1} (FreeCommRing.{u1} α) (FreeCommRing.instCommRing.{u1} α)))) (Semiring.toNonAssocSemiring.{u1} (FreeCommRing.{u1} (Set.Elem.{u1} α s)) (CommSemiring.toSemiring.{u1} (FreeCommRing.{u1} (Set.Elem.{u1} α s)) (CommRing.toCommSemiring.{u1} (FreeCommRing.{u1} (Set.Elem.{u1} α s)) (FreeCommRing.instCommRing.{u1} (Set.Elem.{u1} α s))))) (RingHom.instRingHomClassRingHom.{u1, u1} (FreeCommRing.{u1} α) (FreeCommRing.{u1} (Set.Elem.{u1} α s)) (Semiring.toNonAssocSemiring.{u1} (FreeCommRing.{u1} α) (CommSemiring.toSemiring.{u1} (FreeCommRing.{u1} α) (CommRing.toCommSemiring.{u1} (FreeCommRing.{u1} α) (FreeCommRing.instCommRing.{u1} α)))) (Semiring.toNonAssocSemiring.{u1} (FreeCommRing.{u1} (Set.Elem.{u1} α s)) (CommSemiring.toSemiring.{u1} (FreeCommRing.{u1} (Set.Elem.{u1} α s)) (CommRing.toCommSemiring.{u1} (FreeCommRing.{u1} (Set.Elem.{u1} α s)) (FreeCommRing.instCommRing.{u1} (Set.Elem.{u1} α s))))))))) (FreeCommRing.restriction.{u1} α s (fun (a : α) => _inst_1 a)) x)) (FunLike.coe.{succ u1, succ u1, succ u1} (RingHom.{u1, u1} (FreeCommRing.{u1} (Set.Elem.{u1} α s)) (FreeCommRing.{u1} α) (Semiring.toNonAssocSemiring.{u1} (FreeCommRing.{u1} (Set.Elem.{u1} α s)) (CommSemiring.toSemiring.{u1} (FreeCommRing.{u1} (Set.Elem.{u1} α s)) (CommRing.toCommSemiring.{u1} (FreeCommRing.{u1} (Set.Elem.{u1} α s)) (FreeCommRing.instCommRing.{u1} (Set.Elem.{u1} α s))))) (Semiring.toNonAssocSemiring.{u1} (FreeCommRing.{u1} α) (CommSemiring.toSemiring.{u1} (FreeCommRing.{u1} α) (CommRing.toCommSemiring.{u1} (FreeCommRing.{u1} α) (FreeCommRing.instCommRing.{u1} α))))) (FreeCommRing.{u1} (Set.Elem.{u1} α s)) (fun (_x : FreeCommRing.{u1} (Set.Elem.{u1} α s)) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : FreeCommRing.{u1} (Set.Elem.{u1} α s)) => FreeCommRing.{u1} α) _x) (MulHomClass.toFunLike.{u1, u1, u1} (RingHom.{u1, u1} (FreeCommRing.{u1} (Set.Elem.{u1} α s)) (FreeCommRing.{u1} α) (Semiring.toNonAssocSemiring.{u1} (FreeCommRing.{u1} (Set.Elem.{u1} α s)) (CommSemiring.toSemiring.{u1} (FreeCommRing.{u1} (Set.Elem.{u1} α s)) (CommRing.toCommSemiring.{u1} (FreeCommRing.{u1} (Set.Elem.{u1} α s)) (FreeCommRing.instCommRing.{u1} (Set.Elem.{u1} α s))))) (Semiring.toNonAssocSemiring.{u1} (FreeCommRing.{u1} α) (CommSemiring.toSemiring.{u1} (FreeCommRing.{u1} α) (CommRing.toCommSemiring.{u1} (FreeCommRing.{u1} α) (FreeCommRing.instCommRing.{u1} α))))) (FreeCommRing.{u1} (Set.Elem.{u1} α s)) (FreeCommRing.{u1} α) (NonUnitalNonAssocSemiring.toMul.{u1} (FreeCommRing.{u1} (Set.Elem.{u1} α s)) (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u1} (FreeCommRing.{u1} (Set.Elem.{u1} α s)) (Semiring.toNonAssocSemiring.{u1} (FreeCommRing.{u1} (Set.Elem.{u1} α s)) (CommSemiring.toSemiring.{u1} (FreeCommRing.{u1} (Set.Elem.{u1} α s)) (CommRing.toCommSemiring.{u1} (FreeCommRing.{u1} (Set.Elem.{u1} α s)) (FreeCommRing.instCommRing.{u1} (Set.Elem.{u1} α s))))))) (NonUnitalNonAssocSemiring.toMul.{u1} (FreeCommRing.{u1} α) (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u1} (FreeCommRing.{u1} α) (Semiring.toNonAssocSemiring.{u1} (FreeCommRing.{u1} α) (CommSemiring.toSemiring.{u1} (FreeCommRing.{u1} α) (CommRing.toCommSemiring.{u1} (FreeCommRing.{u1} α) (FreeCommRing.instCommRing.{u1} α)))))) (NonUnitalRingHomClass.toMulHomClass.{u1, u1, u1} (RingHom.{u1, u1} (FreeCommRing.{u1} (Set.Elem.{u1} α s)) (FreeCommRing.{u1} α) (Semiring.toNonAssocSemiring.{u1} (FreeCommRing.{u1} (Set.Elem.{u1} α s)) (CommSemiring.toSemiring.{u1} (FreeCommRing.{u1} (Set.Elem.{u1} α s)) (CommRing.toCommSemiring.{u1} (FreeCommRing.{u1} (Set.Elem.{u1} α s)) (FreeCommRing.instCommRing.{u1} (Set.Elem.{u1} α s))))) (Semiring.toNonAssocSemiring.{u1} (FreeCommRing.{u1} α) (CommSemiring.toSemiring.{u1} (FreeCommRing.{u1} α) (CommRing.toCommSemiring.{u1} (FreeCommRing.{u1} α) (FreeCommRing.instCommRing.{u1} α))))) (FreeCommRing.{u1} (Set.Elem.{u1} α s)) (FreeCommRing.{u1} α) (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u1} (FreeCommRing.{u1} (Set.Elem.{u1} α s)) (Semiring.toNonAssocSemiring.{u1} (FreeCommRing.{u1} (Set.Elem.{u1} α s)) (CommSemiring.toSemiring.{u1} (FreeCommRing.{u1} (Set.Elem.{u1} α s)) (CommRing.toCommSemiring.{u1} (FreeCommRing.{u1} (Set.Elem.{u1} α s)) (FreeCommRing.instCommRing.{u1} (Set.Elem.{u1} α s)))))) (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u1} (FreeCommRing.{u1} α) (Semiring.toNonAssocSemiring.{u1} (FreeCommRing.{u1} α) (CommSemiring.toSemiring.{u1} (FreeCommRing.{u1} α) (CommRing.toCommSemiring.{u1} (FreeCommRing.{u1} α) (FreeCommRing.instCommRing.{u1} α))))) (RingHomClass.toNonUnitalRingHomClass.{u1, u1, u1} (RingHom.{u1, u1} (FreeCommRing.{u1} (Set.Elem.{u1} α s)) (FreeCommRing.{u1} α) (Semiring.toNonAssocSemiring.{u1} (FreeCommRing.{u1} (Set.Elem.{u1} α s)) (CommSemiring.toSemiring.{u1} (FreeCommRing.{u1} (Set.Elem.{u1} α s)) (CommRing.toCommSemiring.{u1} (FreeCommRing.{u1} (Set.Elem.{u1} α s)) (FreeCommRing.instCommRing.{u1} (Set.Elem.{u1} α s))))) (Semiring.toNonAssocSemiring.{u1} (FreeCommRing.{u1} α) (CommSemiring.toSemiring.{u1} (FreeCommRing.{u1} α) (CommRing.toCommSemiring.{u1} (FreeCommRing.{u1} α) (FreeCommRing.instCommRing.{u1} α))))) (FreeCommRing.{u1} (Set.Elem.{u1} α s)) (FreeCommRing.{u1} α) (Semiring.toNonAssocSemiring.{u1} (FreeCommRing.{u1} (Set.Elem.{u1} α s)) (CommSemiring.toSemiring.{u1} (FreeCommRing.{u1} (Set.Elem.{u1} α s)) (CommRing.toCommSemiring.{u1} (FreeCommRing.{u1} (Set.Elem.{u1} α s)) (FreeCommRing.instCommRing.{u1} (Set.Elem.{u1} α s))))) (Semiring.toNonAssocSemiring.{u1} (FreeCommRing.{u1} α) (CommSemiring.toSemiring.{u1} (FreeCommRing.{u1} α) (CommRing.toCommSemiring.{u1} (FreeCommRing.{u1} α) (FreeCommRing.instCommRing.{u1} α)))) (RingHom.instRingHomClassRingHom.{u1, u1} (FreeCommRing.{u1} (Set.Elem.{u1} α s)) (FreeCommRing.{u1} α) (Semiring.toNonAssocSemiring.{u1} (FreeCommRing.{u1} (Set.Elem.{u1} α s)) (CommSemiring.toSemiring.{u1} (FreeCommRing.{u1} (Set.Elem.{u1} α s)) (CommRing.toCommSemiring.{u1} (FreeCommRing.{u1} (Set.Elem.{u1} α s)) (FreeCommRing.instCommRing.{u1} (Set.Elem.{u1} α s))))) (Semiring.toNonAssocSemiring.{u1} (FreeCommRing.{u1} α) (CommSemiring.toSemiring.{u1} (FreeCommRing.{u1} α) (CommRing.toCommSemiring.{u1} (FreeCommRing.{u1} α) (FreeCommRing.instCommRing.{u1} α)))))))) (FreeCommRing.map.{u1, u1} (Set.Elem.{u1} α s) α (Subtype.val.{succ u1} α (fun (x : α) => Membership.mem.{u1, u1} α (Set.{u1} α) (Set.instMembershipSet.{u1} α) x s))) (FunLike.coe.{succ u1, succ u1, succ u1} (RingHom.{u1, u1} (FreeCommRing.{u1} α) (FreeCommRing.{u1} (Set.Elem.{u1} α s)) (Semiring.toNonAssocSemiring.{u1} (FreeCommRing.{u1} α) (CommSemiring.toSemiring.{u1} (FreeCommRing.{u1} α) (CommRing.toCommSemiring.{u1} (FreeCommRing.{u1} α) (FreeCommRing.instCommRing.{u1} α)))) (Semiring.toNonAssocSemiring.{u1} (FreeCommRing.{u1} (Set.Elem.{u1} α s)) (CommSemiring.toSemiring.{u1} (FreeCommRing.{u1} (Set.Elem.{u1} α s)) (CommRing.toCommSemiring.{u1} (FreeCommRing.{u1} (Set.Elem.{u1} α s)) (FreeCommRing.instCommRing.{u1} (Set.Elem.{u1} α s)))))) (FreeCommRing.{u1} α) (fun (_x : FreeCommRing.{u1} α) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : FreeCommRing.{u1} α) => FreeCommRing.{u1} (Set.Elem.{u1} α s)) _x) (MulHomClass.toFunLike.{u1, u1, u1} (RingHom.{u1, u1} (FreeCommRing.{u1} α) (FreeCommRing.{u1} (Set.Elem.{u1} α s)) (Semiring.toNonAssocSemiring.{u1} (FreeCommRing.{u1} α) (CommSemiring.toSemiring.{u1} (FreeCommRing.{u1} α) (CommRing.toCommSemiring.{u1} (FreeCommRing.{u1} α) (FreeCommRing.instCommRing.{u1} α)))) (Semiring.toNonAssocSemiring.{u1} (FreeCommRing.{u1} (Set.Elem.{u1} α s)) (CommSemiring.toSemiring.{u1} (FreeCommRing.{u1} (Set.Elem.{u1} α s)) (CommRing.toCommSemiring.{u1} (FreeCommRing.{u1} (Set.Elem.{u1} α s)) (FreeCommRing.instCommRing.{u1} (Set.Elem.{u1} α s)))))) (FreeCommRing.{u1} α) (FreeCommRing.{u1} (Set.Elem.{u1} α s)) (NonUnitalNonAssocSemiring.toMul.{u1} (FreeCommRing.{u1} α) (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u1} (FreeCommRing.{u1} α) (Semiring.toNonAssocSemiring.{u1} (FreeCommRing.{u1} α) (CommSemiring.toSemiring.{u1} (FreeCommRing.{u1} α) (CommRing.toCommSemiring.{u1} (FreeCommRing.{u1} α) (FreeCommRing.instCommRing.{u1} α)))))) (NonUnitalNonAssocSemiring.toMul.{u1} (FreeCommRing.{u1} (Set.Elem.{u1} α s)) (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u1} (FreeCommRing.{u1} (Set.Elem.{u1} α s)) (Semiring.toNonAssocSemiring.{u1} (FreeCommRing.{u1} (Set.Elem.{u1} α s)) (CommSemiring.toSemiring.{u1} (FreeCommRing.{u1} (Set.Elem.{u1} α s)) (CommRing.toCommSemiring.{u1} (FreeCommRing.{u1} (Set.Elem.{u1} α s)) (FreeCommRing.instCommRing.{u1} (Set.Elem.{u1} α s))))))) (NonUnitalRingHomClass.toMulHomClass.{u1, u1, u1} (RingHom.{u1, u1} (FreeCommRing.{u1} α) (FreeCommRing.{u1} (Set.Elem.{u1} α s)) (Semiring.toNonAssocSemiring.{u1} (FreeCommRing.{u1} α) (CommSemiring.toSemiring.{u1} (FreeCommRing.{u1} α) (CommRing.toCommSemiring.{u1} (FreeCommRing.{u1} α) (FreeCommRing.instCommRing.{u1} α)))) (Semiring.toNonAssocSemiring.{u1} (FreeCommRing.{u1} (Set.Elem.{u1} α s)) (CommSemiring.toSemiring.{u1} (FreeCommRing.{u1} (Set.Elem.{u1} α s)) (CommRing.toCommSemiring.{u1} (FreeCommRing.{u1} (Set.Elem.{u1} α s)) (FreeCommRing.instCommRing.{u1} (Set.Elem.{u1} α s)))))) (FreeCommRing.{u1} α) (FreeCommRing.{u1} (Set.Elem.{u1} α s)) (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u1} (FreeCommRing.{u1} α) (Semiring.toNonAssocSemiring.{u1} (FreeCommRing.{u1} α) (CommSemiring.toSemiring.{u1} (FreeCommRing.{u1} α) (CommRing.toCommSemiring.{u1} (FreeCommRing.{u1} α) (FreeCommRing.instCommRing.{u1} α))))) (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u1} (FreeCommRing.{u1} (Set.Elem.{u1} α s)) (Semiring.toNonAssocSemiring.{u1} (FreeCommRing.{u1} (Set.Elem.{u1} α s)) (CommSemiring.toSemiring.{u1} (FreeCommRing.{u1} (Set.Elem.{u1} α s)) (CommRing.toCommSemiring.{u1} (FreeCommRing.{u1} (Set.Elem.{u1} α s)) (FreeCommRing.instCommRing.{u1} (Set.Elem.{u1} α s)))))) (RingHomClass.toNonUnitalRingHomClass.{u1, u1, u1} (RingHom.{u1, u1} (FreeCommRing.{u1} α) (FreeCommRing.{u1} (Set.Elem.{u1} α s)) (Semiring.toNonAssocSemiring.{u1} (FreeCommRing.{u1} α) (CommSemiring.toSemiring.{u1} (FreeCommRing.{u1} α) (CommRing.toCommSemiring.{u1} (FreeCommRing.{u1} α) (FreeCommRing.instCommRing.{u1} α)))) (Semiring.toNonAssocSemiring.{u1} (FreeCommRing.{u1} (Set.Elem.{u1} α s)) (CommSemiring.toSemiring.{u1} (FreeCommRing.{u1} (Set.Elem.{u1} α s)) (CommRing.toCommSemiring.{u1} (FreeCommRing.{u1} (Set.Elem.{u1} α s)) (FreeCommRing.instCommRing.{u1} (Set.Elem.{u1} α s)))))) (FreeCommRing.{u1} α) (FreeCommRing.{u1} (Set.Elem.{u1} α s)) (Semiring.toNonAssocSemiring.{u1} (FreeCommRing.{u1} α) (CommSemiring.toSemiring.{u1} (FreeCommRing.{u1} α) (CommRing.toCommSemiring.{u1} (FreeCommRing.{u1} α) (FreeCommRing.instCommRing.{u1} α)))) (Semiring.toNonAssocSemiring.{u1} (FreeCommRing.{u1} (Set.Elem.{u1} α s)) (CommSemiring.toSemiring.{u1} (FreeCommRing.{u1} (Set.Elem.{u1} α s)) (CommRing.toCommSemiring.{u1} (FreeCommRing.{u1} (Set.Elem.{u1} α s)) (FreeCommRing.instCommRing.{u1} (Set.Elem.{u1} α s))))) (RingHom.instRingHomClassRingHom.{u1, u1} (FreeCommRing.{u1} α) (FreeCommRing.{u1} (Set.Elem.{u1} α s)) (Semiring.toNonAssocSemiring.{u1} (FreeCommRing.{u1} α) (CommSemiring.toSemiring.{u1} (FreeCommRing.{u1} α) (CommRing.toCommSemiring.{u1} (FreeCommRing.{u1} α) (FreeCommRing.instCommRing.{u1} α)))) (Semiring.toNonAssocSemiring.{u1} (FreeCommRing.{u1} (Set.Elem.{u1} α s)) (CommSemiring.toSemiring.{u1} (FreeCommRing.{u1} (Set.Elem.{u1} α s)) (CommRing.toCommSemiring.{u1} (FreeCommRing.{u1} (Set.Elem.{u1} α s)) (FreeCommRing.instCommRing.{u1} (Set.Elem.{u1} α s))))))))) (FreeCommRing.restriction.{u1} α s (fun (a : α) => _inst_1 a)) x)) x)
+Case conversion may be inaccurate. Consider using '#align free_comm_ring.map_subtype_val_restriction FreeCommRing.map_subtype_val_restrictionₓ'. -/
 theorem map_subtype_val_restriction {x} (s : Set α) [DecidablePred (· ∈ s)]
     (hxs : IsSupported x s) : map (Subtype.val : s → α) (restriction s x) = x :=
   by
@@ -272,6 +370,7 @@ theorem map_subtype_val_restriction {x} (s : Set α) [DecidablePred (· ∈ s)]
     rw [RingHom.map_add, RingHom.map_add, ihx, ihy]
 #align free_comm_ring.map_subtype_val_restriction FreeCommRing.map_subtype_val_restriction
 
+#print FreeCommRing.exists_finite_support /-
 theorem exists_finite_support (x : FreeCommRing α) : ∃ s : Set α, Set.Finite s ∧ IsSupported x s :=
   FreeCommRing.induction_on x ⟨∅, Set.finite_empty, isSupported_neg isSupported_one⟩
     (fun p => ⟨{p}, Set.finite_singleton p, isSupported_of.2 <| Set.mem_singleton _⟩)
@@ -284,11 +383,14 @@ theorem exists_finite_support (x : FreeCommRing α) : ∃ s : Set α, Set.Finite
       isSupported_mul (isSupported_upwards hxs <| Set.subset_union_left s t)
         (isSupported_upwards hxt <| Set.subset_union_right s t)⟩
 #align free_comm_ring.exists_finite_support FreeCommRing.exists_finite_support
+-/
 
+#print FreeCommRing.exists_finset_support /-
 theorem exists_finset_support (x : FreeCommRing α) : ∃ s : Finset α, IsSupported x ↑s :=
   let ⟨s, hfs, hxs⟩ := exists_finite_support x
   ⟨hfs.toFinset, by rwa [Set.Finite.coe_toFinset]⟩
 #align free_comm_ring.exists_finset_support FreeCommRing.exists_finset_support
+-/
 
 end FreeCommRing
 
@@ -298,25 +400,41 @@ open Function
 
 variable (α)
 
+#print FreeRing.toFreeCommRing /-
 /-- The canonical ring homomorphism from the free ring generated by `α` to the free commutative ring
     generated by `α`. -/
 def toFreeCommRing {α} : FreeRing α →+* FreeCommRing α :=
   FreeRing.lift FreeCommRing.of
 #align free_ring.to_free_comm_ring FreeRing.toFreeCommRing
+-/
 
 instance : Coe (FreeRing α) (FreeCommRing α) :=
   ⟨toFreeCommRing⟩
 
+#print FreeRing.coeRingHom /-
 /-- The natural map `free_ring α → free_comm_ring α`, as a `ring_hom`. -/
 def coeRingHom : FreeRing α →+* FreeCommRing α :=
   toFreeCommRing
 #align free_ring.coe_ring_hom FreeRing.coeRingHom
+-/
 
+/- warning: free_ring.coe_zero -> FreeRing.coe_zero is a dubious translation:
+lean 3 declaration is
+  forall (α : Type.{u1}), Eq.{succ u1} (FreeCommRing.{u1} α) ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) (FreeRing.{u1} α) (FreeCommRing.{u1} α) (HasLiftT.mk.{succ u1, succ u1} (FreeRing.{u1} α) (FreeCommRing.{u1} α) (CoeTCₓ.coe.{succ u1, succ u1} (FreeRing.{u1} α) (FreeCommRing.{u1} α) (coeBase.{succ u1, succ u1} (FreeRing.{u1} α) (FreeCommRing.{u1} α) (FreeRing.FreeCommRing.instCoe.{u1} α)))) (OfNat.ofNat.{u1} (FreeRing.{u1} α) 0 (OfNat.mk.{u1} (FreeRing.{u1} α) 0 (Zero.zero.{u1} (FreeRing.{u1} α) (MulZeroClass.toHasZero.{u1} (FreeRing.{u1} α) (NonUnitalNonAssocSemiring.toMulZeroClass.{u1} (FreeRing.{u1} α) (NonUnitalNonAssocRing.toNonUnitalNonAssocSemiring.{u1} (FreeRing.{u1} α) (NonAssocRing.toNonUnitalNonAssocRing.{u1} (FreeRing.{u1} α) (Ring.toNonAssocRing.{u1} (FreeRing.{u1} α) (FreeRing.ring.{u1} α)))))))))) (OfNat.ofNat.{u1} (FreeCommRing.{u1} α) 0 (OfNat.mk.{u1} (FreeCommRing.{u1} α) 0 (Zero.zero.{u1} (FreeCommRing.{u1} α) (MulZeroClass.toHasZero.{u1} (FreeCommRing.{u1} α) (NonUnitalNonAssocSemiring.toMulZeroClass.{u1} (FreeCommRing.{u1} α) (NonUnitalNonAssocRing.toNonUnitalNonAssocSemiring.{u1} (FreeCommRing.{u1} α) (NonAssocRing.toNonUnitalNonAssocRing.{u1} (FreeCommRing.{u1} α) (Ring.toNonAssocRing.{u1} (FreeCommRing.{u1} α) (CommRing.toRing.{u1} (FreeCommRing.{u1} α) (FreeCommRing.instCommRing.{u1} α))))))))))
+but is expected to have type
+  forall (α : Type.{u1}), Eq.{succ u1} (FreeCommRing.{u1} α) (FreeRing.castFreeCommRing.{u1} α (OfNat.ofNat.{u1} (FreeRing.{u1} α) 0 (Zero.toOfNat0.{u1} (FreeRing.{u1} α) (MonoidWithZero.toZero.{u1} (FreeRing.{u1} α) (Semiring.toMonoidWithZero.{u1} (FreeRing.{u1} α) (Ring.toSemiring.{u1} (FreeRing.{u1} α) (instRingFreeRing.{u1} α))))))) (OfNat.ofNat.{u1} (FreeCommRing.{u1} α) 0 (Zero.toOfNat0.{u1} (FreeCommRing.{u1} α) (CommMonoidWithZero.toZero.{u1} (FreeCommRing.{u1} α) (CommSemiring.toCommMonoidWithZero.{u1} (FreeCommRing.{u1} α) (CommRing.toCommSemiring.{u1} (FreeCommRing.{u1} α) (FreeCommRing.instCommRing.{u1} α))))))
+Case conversion may be inaccurate. Consider using '#align free_ring.coe_zero FreeRing.coe_zeroₓ'. -/
 @[simp, norm_cast]
 protected theorem coe_zero : ↑(0 : FreeRing α) = (0 : FreeCommRing α) :=
   rfl
 #align free_ring.coe_zero FreeRing.coe_zero
 
+/- warning: free_ring.coe_one -> FreeRing.coe_one is a dubious translation:
+lean 3 declaration is
+  forall (α : Type.{u1}), Eq.{succ u1} (FreeCommRing.{u1} α) ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) (FreeRing.{u1} α) (FreeCommRing.{u1} α) (HasLiftT.mk.{succ u1, succ u1} (FreeRing.{u1} α) (FreeCommRing.{u1} α) (CoeTCₓ.coe.{succ u1, succ u1} (FreeRing.{u1} α) (FreeCommRing.{u1} α) (coeBase.{succ u1, succ u1} (FreeRing.{u1} α) (FreeCommRing.{u1} α) (FreeRing.FreeCommRing.instCoe.{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} α))))))))) (OfNat.ofNat.{u1} (FreeCommRing.{u1} α) 1 (OfNat.mk.{u1} (FreeCommRing.{u1} α) 1 (One.one.{u1} (FreeCommRing.{u1} α) (AddMonoidWithOne.toOne.{u1} (FreeCommRing.{u1} α) (AddGroupWithOne.toAddMonoidWithOne.{u1} (FreeCommRing.{u1} α) (AddCommGroupWithOne.toAddGroupWithOne.{u1} (FreeCommRing.{u1} α) (Ring.toAddCommGroupWithOne.{u1} (FreeCommRing.{u1} α) (CommRing.toRing.{u1} (FreeCommRing.{u1} α) (FreeCommRing.instCommRing.{u1} α)))))))))
+but is expected to have type
+  forall (α : Type.{u1}), Eq.{succ u1} (FreeCommRing.{u1} α) (FreeRing.castFreeCommRing.{u1} α (OfNat.ofNat.{u1} (FreeRing.{u1} α) 1 (One.toOfNat1.{u1} (FreeRing.{u1} α) (Semiring.toOne.{u1} (FreeRing.{u1} α) (Ring.toSemiring.{u1} (FreeRing.{u1} α) (instRingFreeRing.{u1} α)))))) (OfNat.ofNat.{u1} (FreeCommRing.{u1} α) 1 (One.toOfNat1.{u1} (FreeCommRing.{u1} α) (Semiring.toOne.{u1} (FreeCommRing.{u1} α) (CommSemiring.toSemiring.{u1} (FreeCommRing.{u1} α) (CommRing.toCommSemiring.{u1} (FreeCommRing.{u1} α) (FreeCommRing.instCommRing.{u1} α))))))
+Case conversion may be inaccurate. Consider using '#align free_ring.coe_one FreeRing.coe_oneₓ'. -/
 @[simp, norm_cast]
 protected theorem coe_one : ↑(1 : FreeRing α) = (1 : FreeCommRing α) :=
   rfl
@@ -324,26 +442,52 @@ protected theorem coe_one : ↑(1 : FreeRing α) = (1 : FreeCommRing α) :=
 
 variable {α}
 
+#print FreeRing.coe_of /-
 @[simp]
 protected theorem coe_of (a : α) : ↑(FreeRing.of a) = FreeCommRing.of a :=
   FreeRing.lift_of _ _
 #align free_ring.coe_of FreeRing.coe_of
+-/
 
+/- warning: free_ring.coe_neg -> FreeRing.coe_neg is a dubious translation:
+lean 3 declaration is
+  forall {α : Type.{u1}} (x : FreeRing.{u1} α), Eq.{succ u1} (FreeCommRing.{u1} α) ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) (FreeRing.{u1} α) (FreeCommRing.{u1} α) (HasLiftT.mk.{succ u1, succ u1} (FreeRing.{u1} α) (FreeCommRing.{u1} α) (CoeTCₓ.coe.{succ u1, succ u1} (FreeRing.{u1} α) (FreeCommRing.{u1} α) (coeBase.{succ u1, succ u1} (FreeRing.{u1} α) (FreeCommRing.{u1} α) (FreeRing.FreeCommRing.instCoe.{u1} α)))) (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} α)))))) x)) (Neg.neg.{u1} (FreeCommRing.{u1} α) (SubNegMonoid.toHasNeg.{u1} (FreeCommRing.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeCommRing.{u1} α) (AddGroupWithOne.toAddGroup.{u1} (FreeCommRing.{u1} α) (AddCommGroupWithOne.toAddGroupWithOne.{u1} (FreeCommRing.{u1} α) (Ring.toAddCommGroupWithOne.{u1} (FreeCommRing.{u1} α) (CommRing.toRing.{u1} (FreeCommRing.{u1} α) (FreeCommRing.instCommRing.{u1} α))))))) ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) (FreeRing.{u1} α) (FreeCommRing.{u1} α) (HasLiftT.mk.{succ u1, succ u1} (FreeRing.{u1} α) (FreeCommRing.{u1} α) (CoeTCₓ.coe.{succ u1, succ u1} (FreeRing.{u1} α) (FreeCommRing.{u1} α) (coeBase.{succ u1, succ u1} (FreeRing.{u1} α) (FreeCommRing.{u1} α) (FreeRing.FreeCommRing.instCoe.{u1} α)))) x))
+but is expected to have type
+  forall {α : Type.{u1}} (x : FreeRing.{u1} α), Eq.{succ u1} (FreeCommRing.{u1} α) (FreeRing.castFreeCommRing.{u1} α (Neg.neg.{u1} (FreeRing.{u1} α) (Ring.toNeg.{u1} (FreeRing.{u1} α) (instRingFreeRing.{u1} α)) x)) (Neg.neg.{u1} (FreeCommRing.{u1} α) (Ring.toNeg.{u1} (FreeCommRing.{u1} α) (CommRing.toRing.{u1} (FreeCommRing.{u1} α) (FreeCommRing.instCommRing.{u1} α))) (FreeRing.castFreeCommRing.{u1} α x))
+Case conversion may be inaccurate. Consider using '#align free_ring.coe_neg FreeRing.coe_negₓ'. -/
 @[simp, norm_cast]
 protected theorem coe_neg (x : FreeRing α) : ↑(-x) = -(x : FreeCommRing α) :=
   (FreeRing.lift _).map_neg _
 #align free_ring.coe_neg FreeRing.coe_neg
 
+/- warning: free_ring.coe_add -> FreeRing.coe_add is a dubious translation:
+lean 3 declaration is
+  forall {α : Type.{u1}} (x : FreeRing.{u1} α) (y : FreeRing.{u1} α), Eq.{succ u1} (FreeCommRing.{u1} α) ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) (FreeRing.{u1} α) (FreeCommRing.{u1} α) (HasLiftT.mk.{succ u1, succ u1} (FreeRing.{u1} α) (FreeCommRing.{u1} α) (CoeTCₓ.coe.{succ u1, succ u1} (FreeRing.{u1} α) (FreeCommRing.{u1} α) (coeBase.{succ u1, succ u1} (FreeRing.{u1} α) (FreeCommRing.{u1} α) (FreeRing.FreeCommRing.instCoe.{u1} α)))) (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)) (HAdd.hAdd.{u1, u1, u1} (FreeCommRing.{u1} α) (FreeCommRing.{u1} α) (FreeCommRing.{u1} α) (instHAdd.{u1} (FreeCommRing.{u1} α) (Distrib.toHasAdd.{u1} (FreeCommRing.{u1} α) (Ring.toDistrib.{u1} (FreeCommRing.{u1} α) (CommRing.toRing.{u1} (FreeCommRing.{u1} α) (FreeCommRing.instCommRing.{u1} α))))) ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) (FreeRing.{u1} α) (FreeCommRing.{u1} α) (HasLiftT.mk.{succ u1, succ u1} (FreeRing.{u1} α) (FreeCommRing.{u1} α) (CoeTCₓ.coe.{succ u1, succ u1} (FreeRing.{u1} α) (FreeCommRing.{u1} α) (coeBase.{succ u1, succ u1} (FreeRing.{u1} α) (FreeCommRing.{u1} α) (FreeRing.FreeCommRing.instCoe.{u1} α)))) x) ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) (FreeRing.{u1} α) (FreeCommRing.{u1} α) (HasLiftT.mk.{succ u1, succ u1} (FreeRing.{u1} α) (FreeCommRing.{u1} α) (CoeTCₓ.coe.{succ u1, succ u1} (FreeRing.{u1} α) (FreeCommRing.{u1} α) (coeBase.{succ u1, succ u1} (FreeRing.{u1} α) (FreeCommRing.{u1} α) (FreeRing.FreeCommRing.instCoe.{u1} α)))) y))
+but is expected to have type
+  forall {α : Type.{u1}} (x : FreeRing.{u1} α) (y : FreeRing.{u1} α), Eq.{succ u1} (FreeCommRing.{u1} α) (FreeRing.castFreeCommRing.{u1} α (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)) (HAdd.hAdd.{u1, u1, u1} (FreeCommRing.{u1} α) (FreeCommRing.{u1} α) (FreeCommRing.{u1} α) (instHAdd.{u1} (FreeCommRing.{u1} α) (Distrib.toAdd.{u1} (FreeCommRing.{u1} α) (NonUnitalNonAssocSemiring.toDistrib.{u1} (FreeCommRing.{u1} α) (NonUnitalNonAssocRing.toNonUnitalNonAssocSemiring.{u1} (FreeCommRing.{u1} α) (NonAssocRing.toNonUnitalNonAssocRing.{u1} (FreeCommRing.{u1} α) (Ring.toNonAssocRing.{u1} (FreeCommRing.{u1} α) (CommRing.toRing.{u1} (FreeCommRing.{u1} α) (FreeCommRing.instCommRing.{u1} α)))))))) (FreeRing.castFreeCommRing.{u1} α x) (FreeRing.castFreeCommRing.{u1} α y))
+Case conversion may be inaccurate. Consider using '#align free_ring.coe_add FreeRing.coe_addₓ'. -/
 @[simp, norm_cast]
 protected theorem coe_add (x y : FreeRing α) : ↑(x + y) = (x : FreeCommRing α) + y :=
   (FreeRing.lift _).map_add _ _
 #align free_ring.coe_add FreeRing.coe_add
 
+/- warning: free_ring.coe_sub -> FreeRing.coe_sub is a dubious translation:
+lean 3 declaration is
+  forall {α : Type.{u1}} (x : FreeRing.{u1} α) (y : FreeRing.{u1} α), Eq.{succ u1} (FreeCommRing.{u1} α) ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) (FreeRing.{u1} α) (FreeCommRing.{u1} α) (HasLiftT.mk.{succ u1, succ u1} (FreeRing.{u1} α) (FreeCommRing.{u1} α) (CoeTCₓ.coe.{succ u1, succ u1} (FreeRing.{u1} α) (FreeCommRing.{u1} α) (coeBase.{succ u1, succ u1} (FreeRing.{u1} α) (FreeCommRing.{u1} α) (FreeRing.FreeCommRing.instCoe.{u1} α)))) (HSub.hSub.{u1, u1, u1} (FreeRing.{u1} α) (FreeRing.{u1} α) (FreeRing.{u1} α) (instHSub.{u1} (FreeRing.{u1} α) (SubNegMonoid.toHasSub.{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} α))))))) x y)) (HSub.hSub.{u1, u1, u1} (FreeCommRing.{u1} α) (FreeCommRing.{u1} α) (FreeCommRing.{u1} α) (instHSub.{u1} (FreeCommRing.{u1} α) (SubNegMonoid.toHasSub.{u1} (FreeCommRing.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeCommRing.{u1} α) (AddGroupWithOne.toAddGroup.{u1} (FreeCommRing.{u1} α) (AddCommGroupWithOne.toAddGroupWithOne.{u1} (FreeCommRing.{u1} α) (Ring.toAddCommGroupWithOne.{u1} (FreeCommRing.{u1} α) (CommRing.toRing.{u1} (FreeCommRing.{u1} α) (FreeCommRing.instCommRing.{u1} α)))))))) ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) (FreeRing.{u1} α) (FreeCommRing.{u1} α) (HasLiftT.mk.{succ u1, succ u1} (FreeRing.{u1} α) (FreeCommRing.{u1} α) (CoeTCₓ.coe.{succ u1, succ u1} (FreeRing.{u1} α) (FreeCommRing.{u1} α) (coeBase.{succ u1, succ u1} (FreeRing.{u1} α) (FreeCommRing.{u1} α) (FreeRing.FreeCommRing.instCoe.{u1} α)))) x) ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) (FreeRing.{u1} α) (FreeCommRing.{u1} α) (HasLiftT.mk.{succ u1, succ u1} (FreeRing.{u1} α) (FreeCommRing.{u1} α) (CoeTCₓ.coe.{succ u1, succ u1} (FreeRing.{u1} α) (FreeCommRing.{u1} α) (coeBase.{succ u1, succ u1} (FreeRing.{u1} α) (FreeCommRing.{u1} α) (FreeRing.FreeCommRing.instCoe.{u1} α)))) y))
+but is expected to have type
+  forall {α : Type.{u1}} (x : FreeRing.{u1} α) (y : FreeRing.{u1} α), Eq.{succ u1} (FreeCommRing.{u1} α) (FreeRing.castFreeCommRing.{u1} α (HSub.hSub.{u1, u1, u1} (FreeRing.{u1} α) (FreeRing.{u1} α) (FreeRing.{u1} α) (instHSub.{u1} (FreeRing.{u1} α) (Ring.toSub.{u1} (FreeRing.{u1} α) (instRingFreeRing.{u1} α))) x y)) (HSub.hSub.{u1, u1, u1} (FreeCommRing.{u1} α) (FreeCommRing.{u1} α) (FreeCommRing.{u1} α) (instHSub.{u1} (FreeCommRing.{u1} α) (Ring.toSub.{u1} (FreeCommRing.{u1} α) (CommRing.toRing.{u1} (FreeCommRing.{u1} α) (FreeCommRing.instCommRing.{u1} α)))) (FreeRing.castFreeCommRing.{u1} α x) (FreeRing.castFreeCommRing.{u1} α y))
+Case conversion may be inaccurate. Consider using '#align free_ring.coe_sub FreeRing.coe_subₓ'. -/
 @[simp, norm_cast]
 protected theorem coe_sub (x y : FreeRing α) : ↑(x - y) = (x : FreeCommRing α) - y :=
   (FreeRing.lift _).map_sub _ _
 #align free_ring.coe_sub FreeRing.coe_sub
 
+/- warning: free_ring.coe_mul -> FreeRing.coe_mul is a dubious translation:
+lean 3 declaration is
+  forall {α : Type.{u1}} (x : FreeRing.{u1} α) (y : FreeRing.{u1} α), Eq.{succ u1} (FreeCommRing.{u1} α) ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) (FreeRing.{u1} α) (FreeCommRing.{u1} α) (HasLiftT.mk.{succ u1, succ u1} (FreeRing.{u1} α) (FreeCommRing.{u1} α) (CoeTCₓ.coe.{succ u1, succ u1} (FreeRing.{u1} α) (FreeCommRing.{u1} α) (coeBase.{succ u1, succ u1} (FreeRing.{u1} α) (FreeCommRing.{u1} α) (FreeRing.FreeCommRing.instCoe.{u1} α)))) (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)) (HMul.hMul.{u1, u1, u1} (FreeCommRing.{u1} α) (FreeCommRing.{u1} α) (FreeCommRing.{u1} α) (instHMul.{u1} (FreeCommRing.{u1} α) (Distrib.toHasMul.{u1} (FreeCommRing.{u1} α) (Ring.toDistrib.{u1} (FreeCommRing.{u1} α) (CommRing.toRing.{u1} (FreeCommRing.{u1} α) (FreeCommRing.instCommRing.{u1} α))))) ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) (FreeRing.{u1} α) (FreeCommRing.{u1} α) (HasLiftT.mk.{succ u1, succ u1} (FreeRing.{u1} α) (FreeCommRing.{u1} α) (CoeTCₓ.coe.{succ u1, succ u1} (FreeRing.{u1} α) (FreeCommRing.{u1} α) (coeBase.{succ u1, succ u1} (FreeRing.{u1} α) (FreeCommRing.{u1} α) (FreeRing.FreeCommRing.instCoe.{u1} α)))) x) ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) (FreeRing.{u1} α) (FreeCommRing.{u1} α) (HasLiftT.mk.{succ u1, succ u1} (FreeRing.{u1} α) (FreeCommRing.{u1} α) (CoeTCₓ.coe.{succ u1, succ u1} (FreeRing.{u1} α) (FreeCommRing.{u1} α) (coeBase.{succ u1, succ u1} (FreeRing.{u1} α) (FreeCommRing.{u1} α) (FreeRing.FreeCommRing.instCoe.{u1} α)))) y))
+but is expected to have type
+  forall {α : Type.{u1}} (x : FreeRing.{u1} α) (y : FreeRing.{u1} α), Eq.{succ u1} (FreeCommRing.{u1} α) (FreeRing.castFreeCommRing.{u1} α (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)) (HMul.hMul.{u1, u1, u1} (FreeCommRing.{u1} α) (FreeCommRing.{u1} α) (FreeCommRing.{u1} α) (instHMul.{u1} (FreeCommRing.{u1} α) (NonUnitalNonAssocRing.toMul.{u1} (FreeCommRing.{u1} α) (NonAssocRing.toNonUnitalNonAssocRing.{u1} (FreeCommRing.{u1} α) (Ring.toNonAssocRing.{u1} (FreeCommRing.{u1} α) (CommRing.toRing.{u1} (FreeCommRing.{u1} α) (FreeCommRing.instCommRing.{u1} α)))))) (FreeRing.castFreeCommRing.{u1} α x) (FreeRing.castFreeCommRing.{u1} α y))
+Case conversion may be inaccurate. Consider using '#align free_ring.coe_mul FreeRing.coe_mulₓ'. -/
 @[simp, norm_cast]
 protected theorem coe_mul (x y : FreeRing α) : ↑(x * y) = (x : FreeCommRing α) * y :=
   (FreeRing.lift _).map_mul _ _
@@ -351,6 +495,7 @@ protected theorem coe_mul (x y : FreeRing α) : ↑(x * y) = (x : FreeCommRing 
 
 variable (α)
 
+#print FreeRing.coe_surjective /-
 protected theorem coe_surjective : Surjective (coe : FreeRing α → FreeCommRing α) := fun x =>
   by
   apply FreeCommRing.induction_on x
@@ -366,7 +511,14 @@ protected theorem coe_surjective : Surjective (coe : FreeRing α → FreeCommRin
     use x * y
     exact (FreeRing.lift _).map_mul _ _
 #align free_ring.coe_surjective FreeRing.coe_surjective
+-/
 
+/- warning: free_ring.coe_eq -> FreeRing.coe_eq is a dubious translation:
+lean 3 declaration is
+  forall (α : Type.{u1}), Eq.{succ u1} ((FreeRing.{u1} α) -> (FreeCommRing.{u1} α)) ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) (FreeRing.{u1} α) (FreeCommRing.{u1} α) (HasLiftT.mk.{succ u1, succ u1} (FreeRing.{u1} α) (FreeCommRing.{u1} α) (CoeTCₓ.coe.{succ u1, succ u1} (FreeRing.{u1} α) (FreeCommRing.{u1} α) (coeBase.{succ u1, succ u1} (FreeRing.{u1} α) (FreeCommRing.{u1} α) (FreeRing.FreeCommRing.instCoe.{u1} α))))) (Functor.map.{u1, u1} FreeAbelianGroup.{u1} (Applicative.toFunctor.{u1, u1} FreeAbelianGroup.{u1} (Monad.toApplicative.{u1, u1} FreeAbelianGroup.{u1} FreeAbelianGroup.monad.{u1})) (List.{u1} α) (Multiset.{u1} α) (fun (l : List.{u1} α) => (fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) (List.{u1} α) (Multiset.{u1} α) (HasLiftT.mk.{succ u1, succ u1} (List.{u1} α) (Multiset.{u1} α) (CoeTCₓ.coe.{succ u1, succ u1} (List.{u1} α) (Multiset.{u1} α) (coeBase.{succ u1, succ u1} (List.{u1} α) (Multiset.{u1} α) (Multiset.hasCoe.{u1} α)))) l))
+but is expected to have type
+  forall (α : Type.{u1}), Eq.{succ u1} ((FreeRing.{u1} α) -> (FreeCommRing.{u1} α)) (FreeRing.castFreeCommRing.{u1} α) (Functor.map.{u1, u1} FreeAbelianGroup.{u1} (Applicative.toFunctor.{u1, u1} FreeAbelianGroup.{u1} (Monad.toApplicative.{u1, u1} FreeAbelianGroup.{u1} FreeAbelianGroup.instMonadFreeAbelianGroup.{u1})) (List.{u1} α) (Multiset.{u1} α) (fun (l : List.{u1} α) => Multiset.ofList.{u1} α l))
+Case conversion may be inaccurate. Consider using '#align free_ring.coe_eq FreeRing.coe_eqₓ'. -/
 theorem coe_eq :
     (coe : FreeRing α → FreeCommRing α) =
       @Functor.map FreeAbelianGroup _ _ _ fun l : List α => (l : Multiset α) :=
@@ -381,6 +533,12 @@ theorem coe_eq :
           rfl
 #align free_ring.coe_eq FreeRing.coe_eq
 
+/- warning: free_ring.subsingleton_equiv_free_comm_ring -> FreeRing.subsingletonEquivFreeCommRing is a dubious translation:
+lean 3 declaration is
+  forall (α : Type.{u1}) [_inst_1 : Subsingleton.{succ u1} α], RingEquiv.{u1, u1} (FreeRing.{u1} α) (FreeCommRing.{u1} α) (Distrib.toHasMul.{u1} (FreeRing.{u1} α) (Ring.toDistrib.{u1} (FreeRing.{u1} α) (FreeRing.ring.{u1} α))) (Distrib.toHasAdd.{u1} (FreeRing.{u1} α) (Ring.toDistrib.{u1} (FreeRing.{u1} α) (FreeRing.ring.{u1} α))) (Distrib.toHasMul.{u1} (FreeCommRing.{u1} α) (Ring.toDistrib.{u1} (FreeCommRing.{u1} α) (CommRing.toRing.{u1} (FreeCommRing.{u1} α) (FreeCommRing.instCommRing.{u1} α)))) (Distrib.toHasAdd.{u1} (FreeCommRing.{u1} α) (Ring.toDistrib.{u1} (FreeCommRing.{u1} α) (CommRing.toRing.{u1} (FreeCommRing.{u1} α) (FreeCommRing.instCommRing.{u1} α))))
+but is expected to have type
+  forall (α : Type.{u1}) [_inst_1 : Subsingleton.{succ u1} α], RingEquiv.{u1, u1} (FreeRing.{u1} α) (FreeCommRing.{u1} α) (NonUnitalNonAssocRing.toMul.{u1} (FreeRing.{u1} α) (NonAssocRing.toNonUnitalNonAssocRing.{u1} (FreeRing.{u1} α) (Ring.toNonAssocRing.{u1} (FreeRing.{u1} α) (instRingFreeRing.{u1} α)))) (NonUnitalNonAssocRing.toMul.{u1} (FreeCommRing.{u1} α) (NonAssocRing.toNonUnitalNonAssocRing.{u1} (FreeCommRing.{u1} α) (Ring.toNonAssocRing.{u1} (FreeCommRing.{u1} α) (CommRing.toRing.{u1} (FreeCommRing.{u1} α) (FreeCommRing.instCommRing.{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} α)))))) (Distrib.toAdd.{u1} (FreeCommRing.{u1} α) (NonUnitalNonAssocSemiring.toDistrib.{u1} (FreeCommRing.{u1} α) (NonUnitalNonAssocRing.toNonUnitalNonAssocSemiring.{u1} (FreeCommRing.{u1} α) (NonAssocRing.toNonUnitalNonAssocRing.{u1} (FreeCommRing.{u1} α) (Ring.toNonAssocRing.{u1} (FreeCommRing.{u1} α) (CommRing.toRing.{u1} (FreeCommRing.{u1} α) (FreeCommRing.instCommRing.{u1} α)))))))
+Case conversion may be inaccurate. Consider using '#align free_ring.subsingleton_equiv_free_comm_ring FreeRing.subsingletonEquivFreeCommRingₓ'. -/
 /-- If α has size at most 1 then the natural map from the free ring on `α` to the
     free commutative ring on `α` is an isomorphism of rings. -/
 def subsingletonEquivFreeCommRing [Subsingleton α] : FreeRing α ≃+* FreeCommRing α :=
@@ -404,6 +562,12 @@ instance [Subsingleton α] : CommRing (FreeRing α) :=
 
 end FreeRing
 
+/- warning: free_comm_ring_equiv_mv_polynomial_int -> freeCommRingEquivMvPolynomialInt is a dubious translation:
+lean 3 declaration is
+  forall (α : Type.{u1}), RingEquiv.{u1, u1} (FreeCommRing.{u1} α) (MvPolynomial.{u1, 0} α Int Int.commSemiring) (Distrib.toHasMul.{u1} (FreeCommRing.{u1} α) (Ring.toDistrib.{u1} (FreeCommRing.{u1} α) (CommRing.toRing.{u1} (FreeCommRing.{u1} α) (FreeCommRing.instCommRing.{u1} α)))) (Distrib.toHasAdd.{u1} (FreeCommRing.{u1} α) (Ring.toDistrib.{u1} (FreeCommRing.{u1} α) (CommRing.toRing.{u1} (FreeCommRing.{u1} α) (FreeCommRing.instCommRing.{u1} α)))) (Distrib.toHasMul.{u1} (MvPolynomial.{u1, 0} α Int Int.commSemiring) (Ring.toDistrib.{u1} (MvPolynomial.{u1, 0} α Int Int.commSemiring) (CommRing.toRing.{u1} (MvPolynomial.{u1, 0} α Int Int.commSemiring) (MvPolynomial.commRing.{0, u1} Int α Int.commRing)))) (Distrib.toHasAdd.{u1} (MvPolynomial.{u1, 0} α Int Int.commSemiring) (Ring.toDistrib.{u1} (MvPolynomial.{u1, 0} α Int Int.commSemiring) (CommRing.toRing.{u1} (MvPolynomial.{u1, 0} α Int Int.commSemiring) (MvPolynomial.commRing.{0, u1} Int α Int.commRing))))
+but is expected to have type
+  forall (α : Type.{u1}), RingEquiv.{u1, u1} (FreeCommRing.{u1} α) (MvPolynomial.{u1, 0} α Int Int.instCommSemiringInt) (NonUnitalNonAssocRing.toMul.{u1} (FreeCommRing.{u1} α) (NonAssocRing.toNonUnitalNonAssocRing.{u1} (FreeCommRing.{u1} α) (Ring.toNonAssocRing.{u1} (FreeCommRing.{u1} α) (CommRing.toRing.{u1} (FreeCommRing.{u1} α) (FreeCommRing.instCommRing.{u1} α))))) (NonUnitalNonAssocRing.toMul.{u1} (MvPolynomial.{u1, 0} α Int Int.instCommSemiringInt) (NonAssocRing.toNonUnitalNonAssocRing.{u1} (MvPolynomial.{u1, 0} α Int Int.instCommSemiringInt) (Ring.toNonAssocRing.{u1} (MvPolynomial.{u1, 0} α Int Int.instCommSemiringInt) (CommRing.toRing.{u1} (MvPolynomial.{u1, 0} α Int Int.instCommSemiringInt) (MvPolynomial.instCommRingMvPolynomialToCommSemiring.{0, u1} Int α Int.instCommRingInt))))) (Distrib.toAdd.{u1} (FreeCommRing.{u1} α) (NonUnitalNonAssocSemiring.toDistrib.{u1} (FreeCommRing.{u1} α) (NonUnitalNonAssocRing.toNonUnitalNonAssocSemiring.{u1} (FreeCommRing.{u1} α) (NonAssocRing.toNonUnitalNonAssocRing.{u1} (FreeCommRing.{u1} α) (Ring.toNonAssocRing.{u1} (FreeCommRing.{u1} α) (CommRing.toRing.{u1} (FreeCommRing.{u1} α) (FreeCommRing.instCommRing.{u1} α))))))) (Distrib.toAdd.{u1} (MvPolynomial.{u1, 0} α Int Int.instCommSemiringInt) (NonUnitalNonAssocSemiring.toDistrib.{u1} (MvPolynomial.{u1, 0} α Int Int.instCommSemiringInt) (NonUnitalNonAssocRing.toNonUnitalNonAssocSemiring.{u1} (MvPolynomial.{u1, 0} α Int Int.instCommSemiringInt) (NonAssocRing.toNonUnitalNonAssocRing.{u1} (MvPolynomial.{u1, 0} α Int Int.instCommSemiringInt) (Ring.toNonAssocRing.{u1} (MvPolynomial.{u1, 0} α Int Int.instCommSemiringInt) (CommRing.toRing.{u1} (MvPolynomial.{u1, 0} α Int Int.instCommSemiringInt) (MvPolynomial.instCommRingMvPolynomialToCommSemiring.{0, u1} Int α Int.instCommRingInt)))))))
+Case conversion may be inaccurate. Consider using '#align free_comm_ring_equiv_mv_polynomial_int freeCommRingEquivMvPolynomialIntₓ'. -/
 /-- The free commutative ring on `α` is isomorphic to the polynomial ring over ℤ with
     variables in `α` -/
 def freeCommRingEquivMvPolynomialInt : FreeCommRing α ≃+* MvPolynomial α ℤ :=
@@ -415,11 +579,23 @@ def freeCommRingEquivMvPolynomialInt : FreeCommRing α ≃+* MvPolynomial α ℤ
     (by ext <;> simp)
 #align free_comm_ring_equiv_mv_polynomial_int freeCommRingEquivMvPolynomialInt
 
+/- warning: free_comm_ring_pempty_equiv_int -> freeCommRingPemptyEquivInt is a dubious translation:
+lean 3 declaration is
+  RingEquiv.{u1, 0} (FreeCommRing.{u1} PEmpty.{succ u1}) Int (Distrib.toHasMul.{u1} (FreeCommRing.{u1} PEmpty.{succ u1}) (Ring.toDistrib.{u1} (FreeCommRing.{u1} PEmpty.{succ u1}) (CommRing.toRing.{u1} (FreeCommRing.{u1} PEmpty.{succ u1}) (FreeCommRing.instCommRing.{u1} PEmpty.{succ u1})))) (Distrib.toHasAdd.{u1} (FreeCommRing.{u1} PEmpty.{succ u1}) (Ring.toDistrib.{u1} (FreeCommRing.{u1} PEmpty.{succ u1}) (CommRing.toRing.{u1} (FreeCommRing.{u1} PEmpty.{succ u1}) (FreeCommRing.instCommRing.{u1} PEmpty.{succ u1})))) Int.hasMul Int.hasAdd
+but is expected to have type
+  RingEquiv.{u1, 0} (FreeCommRing.{u1} PEmpty.{succ u1}) Int (NonUnitalNonAssocRing.toMul.{u1} (FreeCommRing.{u1} PEmpty.{succ u1}) (NonAssocRing.toNonUnitalNonAssocRing.{u1} (FreeCommRing.{u1} PEmpty.{succ u1}) (Ring.toNonAssocRing.{u1} (FreeCommRing.{u1} PEmpty.{succ u1}) (CommRing.toRing.{u1} (FreeCommRing.{u1} PEmpty.{succ u1}) (FreeCommRing.instCommRing.{u1} PEmpty.{succ u1}))))) Int.instMulInt (Distrib.toAdd.{u1} (FreeCommRing.{u1} PEmpty.{succ u1}) (NonUnitalNonAssocSemiring.toDistrib.{u1} (FreeCommRing.{u1} PEmpty.{succ u1}) (NonUnitalNonAssocRing.toNonUnitalNonAssocSemiring.{u1} (FreeCommRing.{u1} PEmpty.{succ u1}) (NonAssocRing.toNonUnitalNonAssocRing.{u1} (FreeCommRing.{u1} PEmpty.{succ u1}) (Ring.toNonAssocRing.{u1} (FreeCommRing.{u1} PEmpty.{succ u1}) (CommRing.toRing.{u1} (FreeCommRing.{u1} PEmpty.{succ u1}) (FreeCommRing.instCommRing.{u1} PEmpty.{succ u1}))))))) Int.instAddInt
+Case conversion may be inaccurate. Consider using '#align free_comm_ring_pempty_equiv_int freeCommRingPemptyEquivIntₓ'. -/
 /-- The free commutative ring on the empty type is isomorphic to `ℤ`. -/
 def freeCommRingPemptyEquivInt : FreeCommRing PEmpty.{u + 1} ≃+* ℤ :=
   RingEquiv.trans (freeCommRingEquivMvPolynomialInt _) (MvPolynomial.isEmptyRingEquiv _ PEmpty)
 #align free_comm_ring_pempty_equiv_int freeCommRingPemptyEquivInt
 
+/- warning: free_comm_ring_punit_equiv_polynomial_int -> freeCommRingPunitEquivPolynomialInt is a dubious translation:
+lean 3 declaration is
+  RingEquiv.{u1, 0} (FreeCommRing.{u1} PUnit.{succ u1}) (Polynomial.{0} Int Int.semiring) (Distrib.toHasMul.{u1} (FreeCommRing.{u1} PUnit.{succ u1}) (Ring.toDistrib.{u1} (FreeCommRing.{u1} PUnit.{succ u1}) (CommRing.toRing.{u1} (FreeCommRing.{u1} PUnit.{succ u1}) (FreeCommRing.instCommRing.{u1} PUnit.{succ u1})))) (Distrib.toHasAdd.{u1} (FreeCommRing.{u1} PUnit.{succ u1}) (Ring.toDistrib.{u1} (FreeCommRing.{u1} PUnit.{succ u1}) (CommRing.toRing.{u1} (FreeCommRing.{u1} PUnit.{succ u1}) (FreeCommRing.instCommRing.{u1} PUnit.{succ u1})))) (Polynomial.mul'.{0} Int Int.semiring) (Polynomial.add'.{0} Int Int.semiring)
+but is expected to have type
+  RingEquiv.{u1, 0} (FreeCommRing.{u1} PUnit.{succ u1}) (Polynomial.{0} Int Int.instSemiringInt) (NonUnitalNonAssocRing.toMul.{u1} (FreeCommRing.{u1} PUnit.{succ u1}) (NonAssocRing.toNonUnitalNonAssocRing.{u1} (FreeCommRing.{u1} PUnit.{succ u1}) (Ring.toNonAssocRing.{u1} (FreeCommRing.{u1} PUnit.{succ u1}) (CommRing.toRing.{u1} (FreeCommRing.{u1} PUnit.{succ u1}) (FreeCommRing.instCommRing.{u1} PUnit.{succ u1}))))) (Polynomial.mul'.{0} Int Int.instSemiringInt) (Distrib.toAdd.{u1} (FreeCommRing.{u1} PUnit.{succ u1}) (NonUnitalNonAssocSemiring.toDistrib.{u1} (FreeCommRing.{u1} PUnit.{succ u1}) (NonUnitalNonAssocRing.toNonUnitalNonAssocSemiring.{u1} (FreeCommRing.{u1} PUnit.{succ u1}) (NonAssocRing.toNonUnitalNonAssocRing.{u1} (FreeCommRing.{u1} PUnit.{succ u1}) (Ring.toNonAssocRing.{u1} (FreeCommRing.{u1} PUnit.{succ u1}) (CommRing.toRing.{u1} (FreeCommRing.{u1} PUnit.{succ u1}) (FreeCommRing.instCommRing.{u1} PUnit.{succ u1}))))))) (Polynomial.add'.{0} Int Int.instSemiringInt)
+Case conversion may be inaccurate. Consider using '#align free_comm_ring_punit_equiv_polynomial_int freeCommRingPunitEquivPolynomialIntₓ'. -/
 /-- The free commutative ring on a type with one term is isomorphic to `ℤ[X]`. -/
 def freeCommRingPunitEquivPolynomialInt : FreeCommRing PUnit.{u + 1} ≃+* ℤ[X] :=
   (freeCommRingEquivMvPolynomialInt _).trans (MvPolynomial.pUnitAlgEquiv ℤ).toRingEquiv
@@ -427,11 +603,23 @@ def freeCommRingPunitEquivPolynomialInt : FreeCommRing PUnit.{u + 1} ≃+* ℤ[X
 
 open FreeRing
 
+/- warning: free_ring_pempty_equiv_int -> freeRingPemptyEquivInt is a dubious translation:
+lean 3 declaration is
+  RingEquiv.{u1, 0} (FreeRing.{u1} PEmpty.{succ u1}) Int (Distrib.toHasMul.{u1} (FreeRing.{u1} PEmpty.{succ u1}) (Ring.toDistrib.{u1} (FreeRing.{u1} PEmpty.{succ u1}) (FreeRing.ring.{u1} PEmpty.{succ u1}))) (Distrib.toHasAdd.{u1} (FreeRing.{u1} PEmpty.{succ u1}) (Ring.toDistrib.{u1} (FreeRing.{u1} PEmpty.{succ u1}) (FreeRing.ring.{u1} PEmpty.{succ u1}))) Int.hasMul Int.hasAdd
+but is expected to have type
+  RingEquiv.{u1, 0} (FreeRing.{u1} PEmpty.{succ u1}) Int (NonUnitalNonAssocRing.toMul.{u1} (FreeRing.{u1} PEmpty.{succ u1}) (NonAssocRing.toNonUnitalNonAssocRing.{u1} (FreeRing.{u1} PEmpty.{succ u1}) (Ring.toNonAssocRing.{u1} (FreeRing.{u1} PEmpty.{succ u1}) (instRingFreeRing.{u1} PEmpty.{succ u1})))) Int.instMulInt (Distrib.toAdd.{u1} (FreeRing.{u1} PEmpty.{succ u1}) (NonUnitalNonAssocSemiring.toDistrib.{u1} (FreeRing.{u1} PEmpty.{succ u1}) (NonUnitalNonAssocRing.toNonUnitalNonAssocSemiring.{u1} (FreeRing.{u1} PEmpty.{succ u1}) (NonAssocRing.toNonUnitalNonAssocRing.{u1} (FreeRing.{u1} PEmpty.{succ u1}) (Ring.toNonAssocRing.{u1} (FreeRing.{u1} PEmpty.{succ u1}) (instRingFreeRing.{u1} PEmpty.{succ u1})))))) Int.instAddInt
+Case conversion may be inaccurate. Consider using '#align free_ring_pempty_equiv_int freeRingPemptyEquivIntₓ'. -/
 /-- The free ring on the empty type is isomorphic to `ℤ`. -/
 def freeRingPemptyEquivInt : FreeRing PEmpty.{u + 1} ≃+* ℤ :=
   RingEquiv.trans (subsingletonEquivFreeCommRing _) freeCommRingPemptyEquivInt
 #align free_ring_pempty_equiv_int freeRingPemptyEquivInt
 
+/- warning: free_ring_punit_equiv_polynomial_int -> freeRingPunitEquivPolynomialInt is a dubious translation:
+lean 3 declaration is
+  RingEquiv.{u1, 0} (FreeRing.{u1} PUnit.{succ u1}) (Polynomial.{0} Int Int.semiring) (Distrib.toHasMul.{u1} (FreeRing.{u1} PUnit.{succ u1}) (Ring.toDistrib.{u1} (FreeRing.{u1} PUnit.{succ u1}) (FreeRing.ring.{u1} PUnit.{succ u1}))) (Distrib.toHasAdd.{u1} (FreeRing.{u1} PUnit.{succ u1}) (Ring.toDistrib.{u1} (FreeRing.{u1} PUnit.{succ u1}) (FreeRing.ring.{u1} PUnit.{succ u1}))) (Polynomial.mul'.{0} Int Int.semiring) (Polynomial.add'.{0} Int Int.semiring)
+but is expected to have type
+  RingEquiv.{u1, 0} (FreeRing.{u1} PUnit.{succ u1}) (Polynomial.{0} Int Int.instSemiringInt) (NonUnitalNonAssocRing.toMul.{u1} (FreeRing.{u1} PUnit.{succ u1}) (NonAssocRing.toNonUnitalNonAssocRing.{u1} (FreeRing.{u1} PUnit.{succ u1}) (Ring.toNonAssocRing.{u1} (FreeRing.{u1} PUnit.{succ u1}) (instRingFreeRing.{u1} PUnit.{succ u1})))) (Polynomial.mul'.{0} Int Int.instSemiringInt) (Distrib.toAdd.{u1} (FreeRing.{u1} PUnit.{succ u1}) (NonUnitalNonAssocSemiring.toDistrib.{u1} (FreeRing.{u1} PUnit.{succ u1}) (NonUnitalNonAssocRing.toNonUnitalNonAssocSemiring.{u1} (FreeRing.{u1} PUnit.{succ u1}) (NonAssocRing.toNonUnitalNonAssocRing.{u1} (FreeRing.{u1} PUnit.{succ u1}) (Ring.toNonAssocRing.{u1} (FreeRing.{u1} PUnit.{succ u1}) (instRingFreeRing.{u1} PUnit.{succ u1})))))) (Polynomial.add'.{0} Int Int.instSemiringInt)
+Case conversion may be inaccurate. Consider using '#align free_ring_punit_equiv_polynomial_int freeRingPunitEquivPolynomialIntₓ'. -/
 /-- The free ring on a type with one term is isomorphic to `ℤ[X]`. -/
 def freeRingPunitEquivPolynomialInt : FreeRing PUnit.{u + 1} ≃+* ℤ[X] :=
   RingEquiv.trans (subsingletonEquivFreeCommRing _) freeCommRingPunitEquivPolynomialInt

62c0a4ef

bump to nightly-2023-03-24-18

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

996431d3

Diff

@@ -422,7 +422,7 @@ def freeCommRingPemptyEquivInt : FreeCommRing PEmpty.{u + 1} ≃+* ℤ :=
 
 /-- The free commutative ring on a type with one term is isomorphic to `ℤ[X]`. -/
 def freeCommRingPunitEquivPolynomialInt : FreeCommRing PUnit.{u + 1} ≃+* ℤ[X] :=
-  (freeCommRingEquivMvPolynomialInt _).trans (MvPolynomial.punitAlgEquiv ℤ).toRingEquiv
+  (freeCommRingEquivMvPolynomialInt _).trans (MvPolynomial.pUnitAlgEquiv ℤ).toRingEquiv
 #align free_comm_ring_punit_equiv_polynomial_int freeCommRingPunitEquivPolynomialInt
 
 open FreeRing

62c0a4ef

bump to nightly-2023-03-15-10

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

f73428b0

Diff

@@ -407,7 +407,7 @@ end FreeRing
 /-- The free commutative ring on `α` is isomorphic to the polynomial ring over ℤ with
     variables in `α` -/
 def freeCommRingEquivMvPolynomialInt : FreeCommRing α ≃+* MvPolynomial α ℤ :=
-  RingEquiv.ofHomInv (FreeCommRing.lift <| (fun a => MvPolynomial.x a : α → MvPolynomial α ℤ))
+  RingEquiv.ofHomInv (FreeCommRing.lift <| (fun a => MvPolynomial.X a : α → MvPolynomial α ℤ))
     (MvPolynomial.eval₂Hom (Int.castRingHom (FreeCommRing α)) FreeCommRing.of)
     (by
       ext

62c0a4ef

bump to nightly-2023-03-11-16

mathlib commit https://github.com/leanprover-community/mathlib/commit/3180fab693e2cee3bff62675571264cb8778b212

cd44fb92

Diff

@@ -240,7 +240,7 @@ theorem isSupported_of {p} {s : Set α} : IsSupported (of p) s ↔ p ∈ s :=
       rw [RingHom.map_neg, RingHom.map_one, Int.cast_neg, Int.cast_one]
     · rintro _ ⟨z, hzs, rfl⟩ _ _
       use 0
-      rw [RingHom.map_mul, lift_of, if_pos hzs, zero_mul]
+      rw [RingHom.map_mul, lift_of, if_pos hzs, MulZeroClass.zero_mul]
       norm_cast
     · rintro x y ⟨q, hq⟩ ⟨r, hr⟩
       refine' ⟨q + r, _⟩

62c0a4ef

bump to nightly-2023-03-08-10

mathlib commit https://github.com/leanprover-community/mathlib/commit/38f16f960f5006c6c0c2bac7b0aba5273188f4e5

422cc012

Diff

@@ -229,7 +229,7 @@ theorem isSupported_of {p} {s : Set α} : IsSupported (of p) s ↔ p ∈ s :=
   have :
     ∀ x,
       is_supported x s →
-        ∃ n : ℤ, lift (fun a => if a ∈ s then (0 : ℤ[X]) else Polynomial.x) x = n :=
+        ∃ n : ℤ, lift (fun a => if a ∈ s then (0 : ℤ[X]) else Polynomial.X) x = n :=
     by
     intro x hx
     refine' Subring.InClosure.recOn hx _ _ _ _
@@ -253,9 +253,9 @@ theorem isSupported_of {p} {s : Set α} : IsSupported (of p) s ↔ p ∈ s :=
   exfalso
   apply Ne.symm Int.zero_ne_one
   rcases this with ⟨w, H⟩
-  rw [← Polynomial.c_eq_int_cast] at H
-  have : polynomial.X.coeff 1 = (Polynomial.c ↑w).coeff 1 := by rw [H]
-  rwa [Polynomial.coeff_c, if_neg (one_ne_zero : 1 ≠ 0), Polynomial.coeff_x, if_pos rfl] at this
+  rw [← Polynomial.C_eq_int_cast] at H
+  have : polynomial.X.coeff 1 = (Polynomial.C ↑w).coeff 1 := by rw [H]
+  rwa [Polynomial.coeff_C, if_neg (one_ne_zero : 1 ≠ 0), Polynomial.coeff_X, if_pos rfl] at this
 #align free_comm_ring.is_supported_of FreeCommRing.isSupported_of
 
 theorem map_subtype_val_restriction {x} (s : Set α) [DecidablePred (· ∈ s)]

62c0a4ef

bump to nightly-2023-02-21-16

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

1107b979

Changes in mathlib4

mathlib3

mathlib4

62c0a4ef

chore: Rename nat_cast/int_cast/rat_cast to natCast/intCast/ratCast (#11486)

Now that I am defining NNRat.cast, I want a definitive answer to this naming issue. Plenty of lemmas in mathlib already use natCast/intCast/ratCast over nat_cast/int_cast/rat_cast, and this matches with the general expectation that underscore-separated name parts correspond to a single declaration.

145460b9

Diff

@@ -260,7 +260,7 @@ theorem isSupported_of {p} {s : Set α} : IsSupported (of p) s ↔ p ∈ s :=
   exfalso
   apply Ne.symm Int.zero_ne_one
   rcases this with ⟨w, H⟩
-  rw [← Polynomial.C_eq_int_cast] at H
+  rw [← Polynomial.C_eq_intCast] at H
   have : Polynomial.X.coeff 1 = (Polynomial.C ↑w).coeff 1 := by rw [H]; rfl
   rwa [Polynomial.coeff_C, if_neg (one_ne_zero : 1 ≠ 0), Polynomial.coeff_X, if_pos rfl] at this
 #align free_comm_ring.is_supported_of FreeCommRing.isSupported_of

62c0a4ef

move(Polynomial): Move out of Data (#11751)

Polynomial and MvPolynomial are algebraic objects, hence should be under Algebra (or at least not under Data)

56e439ec

Diff

@@ -3,8 +3,8 @@ 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 Mathlib.Data.MvPolynomial.Equiv
-import Mathlib.Data.MvPolynomial.CommRing
+import Mathlib.Algebra.MvPolynomial.Equiv
+import Mathlib.Algebra.MvPolynomial.CommRing
 import Mathlib.Logic.Equiv.Functor
 import Mathlib.RingTheory.FreeRing

62c0a4ef

chore: scope open Classical (#11199)

We remove all but one open Classicals, instead preferring to use open scoped Classical. The only real side-effect this led to is moving a couple declarations to use Exists.choose instead of Classical.choose.

The first few commits are explicitly labelled regex replaces for ease of review.

c747be0a

Diff

@@ -52,7 +52,8 @@ free commutative ring, free ring
 
 noncomputable section
 
-open Classical Polynomial
+open scoped Classical
+open Polynomial
 
 universe u v

62c0a4ef

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

@@ -63,7 +63,7 @@ def FreeCommRing (α : Type u) : Type u :=
   FreeAbelianGroup <| Multiplicative <| Multiset α
 #align free_comm_ring FreeCommRing
 
---Porting note: two instances below couldn't be derived
+-- Porting note: two instances below couldn't be derived
 instance FreeCommRing.instCommRing : CommRing (FreeCommRing α) := by
   delta FreeCommRing; infer_instance
 #align free_comm_ring.comm_ring FreeCommRing.instCommRing

62c0a4ef

chore: exactly 4 spaces in theorems (#7328)

Co-authored-by: Moritz Firsching <firsching@google.com>

d3263b23

Diff

@@ -374,7 +374,7 @@ protected theorem coe_surjective : Surjective ((↑) : FreeRing α → FreeCommR
 #align free_ring.coe_surjective FreeRing.coe_surjective
 
 theorem coe_eq : ((↑) : FreeRing α → FreeCommRing α) =
-      @Functor.map FreeAbelianGroup _ _ _ fun l : List α => (l : Multiset α) := by
+    @Functor.map FreeAbelianGroup _ _ _ fun l : List α => (l : Multiset α) := by
   funext x
   erw [castFreeCommRing, toFreeCommRing, FreeRing.lift, Equiv.coe_trans, Function.comp,
     FreeAbelianGroup.liftMonoid_coe (FreeMonoid.lift FreeCommRing.of)]

62c0a4ef

chore: only four spaces for subsequent lines (#7286)

Co-authored-by: Moritz Firsching <firsching@google.com>

0c7d6fa5

Diff

@@ -87,9 +87,8 @@ theorem of_injective : Function.Injective (of : α → FreeCommRing α) :=
 #align free_comm_ring.of_injective FreeCommRing.of_injective
 
 -- Porting note: added to ease a proof in `Algebra.DirectLimit`
-lemma of_cons (a : α) (m : Multiset α) :
-  (FreeAbelianGroup.of (Multiplicative.ofAdd (a ::ₘ m))) =
-  @HMul.hMul _ (FreeCommRing α) (FreeCommRing α) _ (of a)
+lemma of_cons (a : α) (m : Multiset α) : (FreeAbelianGroup.of (Multiplicative.ofAdd (a ::ₘ m))) =
+    @HMul.hMul _ (FreeCommRing α) (FreeCommRing α) _ (of a)
     (FreeAbelianGroup.of (Multiplicative.ofAdd m)) := by
   dsimp [FreeCommRing]
   rw [← Multiset.singleton_add, ofAdd_add,

62c0a4ef

chore: drop MulZeroClass. in mul_zero/zero_mul (#6682)

Search&replace MulZeroClass.mul_zero -> mul_zero, MulZeroClass.zero_mul -> zero_mul.

These were introduced by Mathport, as the full name of mul_zero is actually MulZeroClass.mul_zero (it's exported with the short name).

277dea95

Diff

@@ -247,7 +247,7 @@ theorem isSupported_of {p} {s : Set α} : IsSupported (of p) s ↔ p ∈ s :=
       rw [RingHom.map_neg, RingHom.map_one, Int.cast_neg, Int.cast_one]
     · rintro _ ⟨z, hzs, rfl⟩ _ _
       use 0
-      rw [RingHom.map_mul, lift_of, if_pos hzs, MulZeroClass.zero_mul]
+      rw [RingHom.map_mul, lift_of, if_pos hzs, zero_mul]
       norm_cast
     · rintro x y ⟨q, hq⟩ ⟨r, hr⟩
       refine' ⟨q + r, _⟩

62c0a4ef

chore: fix grammar mistakes (#6121)

a16538af

Diff

@@ -63,7 +63,7 @@ def FreeCommRing (α : Type u) : Type u :=
   FreeAbelianGroup <| Multiplicative <| Multiset α
 #align free_comm_ring FreeCommRing
 
---Porting note: two instance below couldn't be derived
+--Porting note: two instances below couldn't be derived
 instance FreeCommRing.instCommRing : CommRing (FreeCommRing α) := by
   delta FreeCommRing; infer_instance
 #align free_comm_ring.comm_ring FreeCommRing.instCommRing

62c0a4ef

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,17 +2,14 @@
 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_comm_ring
-! leanprover-community/mathlib commit 62c0a4ef1441edb463095ea02a06e87f3dfe135c
-! Please do not edit these lines, except to modify the commit id
-! if you have ported upstream changes.
 -/
 import Mathlib.Data.MvPolynomial.Equiv
 import Mathlib.Data.MvPolynomial.CommRing
 import Mathlib.Logic.Equiv.Functor
 import Mathlib.RingTheory.FreeRing
 
+#align_import ring_theory.free_comm_ring from "leanprover-community/mathlib"@"62c0a4ef1441edb463095ea02a06e87f3dfe135c"
+
 /-!
 # Free commutative rings

62c0a4ef

chore: cleanup whitespace (#5988)

Grepping for [^ .:{-] [^ :] and reviewing the results. Once I started I couldn't stop. :-)

Co-authored-by: Scott Morrison <scott.morrison@gmail.com>

12343aa5

Diff

@@ -221,7 +221,7 @@ end IsSupported
 /-- The restriction map from `FreeCommRing α` to `FreeCommRing s` where `s : Set α`, defined
   by sending all variables not in `s` to zero. -/
 def restriction (s : Set α) [DecidablePred (· ∈ s)] : FreeCommRing α →+* FreeCommRing s :=
-  lift (fun a => if H : a ∈ s then of ⟨a, H⟩  else 0)
+  lift (fun a => if H : a ∈ s then of ⟨a, H⟩ else 0)
 #align free_comm_ring.restriction FreeCommRing.restriction
 
 section Restriction

62c0a4ef

chore: clean up spacing around at and goals (#5387)

Changes are of the form

some_tactic at h⊢ -> some_tactic at h ⊢
some_tactic at h -> some_tactic at h

2a870323

Diff

@@ -258,7 +258,7 @@ theorem isSupported_of {p} {s : Set α} : IsSupported (of p) s ↔ p ∈ s :=
       norm_cast
   specialize this (of p) hps
   rw [lift_of] at this
-  split_ifs  at this with h
+  split_ifs at this with h
   · exact h
   exfalso
   apply Ne.symm Int.zero_ne_one

62c0a4ef

chore: fix grammar 3/3 (#5003)

Part 3 of #5001

df58f20b

Diff

@@ -136,7 +136,7 @@ private def liftToMultiset : (α → R) ≃ (Multiplicative (Multiset α) →* R
       erw [← Multiset.map_map (fun x => F' x) (fun x => {x}), ← AddMonoidHom.map_multiset_sum]
       exact F.congr_arg (Multiset.sum_map_singleton x')
 
-/-- Lift a map `α → R` to a additive group homomorphism `FreeCommRing α → R`. -/
+/-- Lift a map `α → R` to an additive group homomorphism `FreeCommRing α → R`. -/
 def lift : (α → R) ≃ (FreeCommRing α →+* R) :=
   Equiv.trans liftToMultiset FreeAbelianGroup.liftMonoid
 #align free_comm_ring.lift FreeCommRing.lift

62c0a4ef

chore: fix upper/lowercase in comments (#4360)

Run a non-interactive version of fix-comments.py on all files.
Go through the diff and manually add/discard/edit chunks.

27d257fc

Diff

@@ -163,7 +163,7 @@ end lift
 
 variable {β : Type v} (f : α → β)
 
-/-- A map `f : α → β` produces a ring homomorphism `free_comm_ring α →+* free_comm_ring β`. -/
+/-- A map `f : α → β` produces a ring homomorphism `FreeCommRing α →+* FreeCommRing β`. -/
 def map : FreeCommRing α →+* FreeCommRing β :=
   lift <| of ∘ f
 #align free_comm_ring.map FreeCommRing.map

62c0a4ef

feat: port Algebra.DirectLimit (#4052)

A few times rw [RingHom.map_neg] worked, rw [(FreeCommRing.lift _).map_neg] failed, and rw [(FreeCommRing.lift <explicit function>).map_neg] succeeded. So there was some "sweet spot" where rw would fail, and if you either gave it strictly less or strictly more information it would succeed. Other than that, not much to say.

Co-authored-by: Scott Morrison <scott.morrison@gmail.com> Co-authored-by: int-y1 <jason_yuen2007@hotmail.com> Co-authored-by: Kevin Buzzard <k.buzzard@imperial.ac.uk> Co-authored-by: Joël Riou <joel.riou@universite-paris-saclay.fr> Co-authored-by: Chris Hughes <chrishughes24@gmail.com>

100392f8

Diff

@@ -89,6 +89,15 @@ theorem of_injective : Function.Injective (of : α → FreeCommRing α) :=
     (Multiset.coe_eq_coe.trans List.singleton_perm_singleton).mp
 #align free_comm_ring.of_injective FreeCommRing.of_injective
 
+-- Porting note: added to ease a proof in `Algebra.DirectLimit`
+lemma of_cons (a : α) (m : Multiset α) :
+  (FreeAbelianGroup.of (Multiplicative.ofAdd (a ::ₘ m))) =
+  @HMul.hMul _ (FreeCommRing α) (FreeCommRing α) _ (of a)
+    (FreeAbelianGroup.of (Multiplicative.ofAdd m)) := by
+  dsimp [FreeCommRing]
+  rw [← Multiset.singleton_add, ofAdd_add,
+    of, FreeAbelianGroup.of_mul_of]
+
 @[elab_as_elim]
 protected theorem induction_on {C : FreeCommRing α → Prop} (z : FreeCommRing α) (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)) :
@@ -98,10 +107,7 @@ protected theorem induction_on {C : FreeCommRing α → Prop} (z : FreeCommRing
   FreeAbelianGroup.induction_on z (add_left_neg (1 : FreeCommRing α) ▸ ha _ _ hn1 h1)
     (fun m => Multiset.induction_on m h1 fun a m ih => by
       convert hm (of a) _ (hb a) ih
-      dsimp [FreeCommRing]
-      show FreeAbelianGroup.of (Multiplicative.ofAdd (a ::ₘ m)) = _
-      rw [← Multiset.singleton_add, ofAdd_add]
-      simp [of]; rfl)
+      apply of_cons)
     (fun m ih => hn _ ih) ha
 #align free_comm_ring.induction_on FreeCommRing.induction_on

62c0a4ef

feat: port RingTheory.FreeCommRing (#3994)

depends on: #3414

original: #3087

Co-authored-by: Komyyy <pol_tta@outlook.jp> Co-authored-by: Matthew Ballard <matt@mrb.email> Co-authored-by: Mauricio Collares <mauricio@collares.org> Co-authored-by: Gabriel Ebner <gebner@gebner.org>

c948d8a7

`ring_theory.free_comm_ring` ⟷ `Mathlib.RingTheory.FreeCommRing`

Changes since the initial port

Changes in mathlib3

Changes in mathlib3port

Changes in mathlib4

Dependencies 8 + 490

ring_theory.free_comm_ring ⟷ Mathlib.RingTheory.FreeCommRing

Changes since the initial port

Changes in mathlib3

Changes in mathlib3port

Changes in mathlib4

Dependencies 8 + 490

`ring_theory.free_comm_ring` ⟷ `Mathlib.RingTheory.FreeCommRing`