/-- `R^n/I^n` is isomorphic to `(R/I)^n` as an `R/I`-module. -/
noncomputable def piQuotEquiv : ((ι → R) ⧸ I.pi ι) ≃ₗ[R ⧸ I] ι → (R ⧸ I) where
  toFun := fun x ↦
      Quotient.liftOn' x (fun f i => Ideal.Quotient.mk I (f i)) fun a b hab =>
        funext fun i => (Submodule.Quotient.eq' _).2 (QuotientAddGroup.leftRel_apply.mp hab i)
  map_add' := by rintro ⟨_⟩ ⟨_⟩; rfl
  map_smul' := by rintro ⟨_⟩ ⟨_⟩; rfl
  invFun := fun x ↦ Ideal.Quotient.mk (I.pi ι) fun i ↦ Quotient.out' (x i)
  left_inv := by
    rintro ⟨x⟩
    exact Ideal.Quotient.eq.2 fun i => Ideal.Quotient.eq.1 (Quotient.out_eq' _)
  right_inv := by
    intro x
    ext i
    obtain ⟨_, _⟩ := @Quot.exists_rep _ _ (x i)
    

Proof state:
case h.intro
R : Type u
inst✝ : CommRing R
I : Ideal R
a b : R
S ι : Type v
x : ι → R ⧸ I
i : ι
w✝ : R
h✝ : Quot.mk Setoid.r w✝ = x i
⊢ AddHom.toFun
      {
          toAddHom :=
            {
              toFun := fun x =>
                Quotient.liftOn' x (fun f i => (Quotient.mk I) (f i))
                  (_ :
                    ∀ (a b : ι → R),
                      Setoid.r a b → (fun f i => (Quotient.mk I) (f i)) a = (fun f i => (Quotient.mk I) (f i)) b),
              map_add' :=
                (_ :
                  ∀ (x y : (ι → R) ⧸ pi I ι),
                    (fun x =>
                          Quotient.liftOn' x (fun f i => (Quotient.mk I) (f i))
                            (_ :
                              ∀ (a b : ι → R),
                                Setoid.r a b →
                                  (fun f i => (Quotient.mk I) (f i)) a = (fun f i => (Quotient.mk I) (f i)) b))
                        (x + y) =
                      (fun x =>
                            Quotient.liftOn' x (fun f i => (Quotient.mk I) (f i))
                              (_ :
                                ∀ (a b : ι → R),
                                  Setoid.r a b →
                                    (fun f i => (Quotient.mk I) (f i)) a = (fun f i => (Quotient.mk I) (f i)) b))
                          x +
                        (fun x =>
                            Quotient.liftOn' x (fun f i => (Quotient.mk I) (f i))
                              (_ :
                                ∀ (a b : ι → R),
                                  Setoid.r a b →
                                    (fun f i => (Quotient.mk I) (f i)) a = (fun f i => (Quotient.mk I) (f i)) b))
                          y) },
          map_smul' :=
            (_ :
              ∀ (r : R ⧸ I) (x : (ι → R) ⧸ pi I ι),
                AddHom.toFun
                    {
                      toFun := fun x =>
                        Quotient.liftOn' x (fun f i => (Quotient.mk I) (f i))
                          (_ :
                            ∀ (a b : ι → R),
                              Setoid.r a b →
                                (fun f i => (Quotient.mk I) (f i)) a = (fun f i => (Quotient.mk I) (f i)) b),
                      map_add' :=
                        (_ :
                          ∀ (x y : (ι → R) ⧸ pi I ι),
                            (fun x =>
                                  Quotient.liftOn' x (fun f i => (Quotient.mk I) (f i))
                                    (_ :
                                      ∀ (a b : ι → R),
                                        Setoid.r a b →
                                          (fun f i => (Quotient.mk I) (f i)) a = (fun f i => (Quotient.mk I) (f i)) b))
                                (x + y) =
                              (fun x =>
                                    Quotient.liftOn' x (fun f i => (Quotient.mk I) (f i))
                                      (_ :
                                        ∀ (a b : ι → R),
                                          Setoid.r a b →
                                            (fun f i => (Quotient.mk I) (f i)) a =
                                              (fun f i => (Quotient.mk I) (f i)) b))
                                  x +
                                (fun x =>
                                    Quotient.liftOn' x (fun f i => (Quotient.mk I) (f i))
                                      (_ :
                                        ∀ (a b : ι → R),
                                          Setoid.r a b →
                                            (fun f i => (Quotient.mk I) (f i)) a =
                                              (fun f i => (Quotient.mk I) (f i)) b))
                                  y) }
                    (r • x) =
                  (RingHom.id (R ⧸ I)) r •
                    AddHom.toFun
                      {
                        toFun := fun x =>
                          Quotient.liftOn' x (fun f i => (Quotient.mk I) (f i))
                            (_ :
                              ∀ (a b : ι → R),
                                Setoid.r a b →
                                  (fun f i => (Quotient.mk I) (f i)) a = (fun f i => (Quotient.mk I) (f i)) b),
                        map_add' :=
                          (_ :
                            ∀ (x y : (ι → R) ⧸ pi I ι),
                              (fun x =>
                                    Quotient.liftOn' x (fun f i => (Quotient.mk I) (f i))
                                      (_ :
                                        ∀ (a b : ι → R),
                                          Setoid.r a b →
                                            (fun f i => (Quotient.mk I) (f i)) a =
                                              (fun f i => (Quotient.mk I) (f i)) b))
                                  (x + y) =
                                (fun x =>
                                      Quotient.liftOn' x (fun f i => (Quotient.mk I) (f i))
                                        (_ :
                                          ∀ (a b : ι → R),
                                            Setoid.r a b →
                                              (fun f i => (Quotient.mk I) (f i)) a =
                                                (fun f i => (Quotient.mk I) (f i)) b))
                                    x +
                                  (fun x =>
                                      Quotient.liftOn' x (fun f i => (Quotient.mk I) (f i))
                                        (_ :
                                          ∀ (a b : ι → R),
                                            Setoid.r a b →
                                              (fun f i => (Quotient.mk I) (f i)) a =
                                                (fun f i => (Quotient.mk I) (f i)) b))
                                    y) }
                      x) }.toAddHom
      ((fun x => (Quotient.mk (pi I ι)) fun i => Quotient.out' (x i)) x) i =
    x i

Next tactic:
convert Quotient.out_eq' (x i)