Mathlib.Algebra.Ring.FirstIsomorphism.Basic

import Std.Logic.Eq
import Mathlib.Logic.EqReasoning
import Mathlib.Algebra.Ring.Basic
import Mathlib.Algebra.Group.Basic
import Mathlib.Algebra.Group.Image
import Mathlib.Algebra.Group.Kernel.Quotient
import Mathlib.Algebra.Group.Kernel.Quotient.Mul
import Mathlib.Algebra.Group.Kernel.Quotient.Group

def RingHomLawArgs.{u,v} :
  forall (R : Sort u), forall (zeroR : R), forall (oneR : R), forall (addR : forall (a : R), forall (b : R), R), forall (negR : forall (a : R), R), forall (subR : forall (a : R), forall (b : R), R), forall (mulR : forall (a : R), forall (b : R), R), forall (S : Sort v), forall (zeroS : S), forall (oneS : S), forall (addS : forall (a : S), forall (b : S), S), forall (negS : forall (a : S), S), forall (subS : forall (a : S), forall (b : S), S), forall (mulS : forall (a : S), forall (b : S), S), forall (f : forall (x : R), S), Prop :=
  fun R => fun zeroR => fun oneR => fun addR => fun negR => fun subR => fun mulR => fun S => fun zeroS => fun oneS => fun addS => fun negS => fun subS => fun mulS => fun f => forall (P : Prop), forall (mk : forall (hom_zero_law : @Eq.{v} S (f zeroR) zeroS), forall (hom_one_law : @Eq.{v} S (f oneR) oneS), forall (hom_add_law : forall (a : R), forall (b : R), @Eq.{v} S (f (addR a b)) (addS (f a) (f b))), forall (hom_neg_law : forall (a : R), @Eq.{v} S (f (negR a)) (negS (f a))), forall (hom_mul_law : forall (a : R), forall (b : R), @Eq.{v} S (f (mulR a b)) (mulS (f a) (f b))), P), P

theorem ring_hom_zero.{u,v} :
  forall (R : Sort u), forall (zeroR : R), forall (oneR : R), forall (addR : forall (a : R), forall (b : R), R), forall (negR : forall (a : R), R), forall (subR : forall (a : R), forall (b : R), R), forall (mulR : forall (a : R), forall (b : R), R), forall (S : Sort v), forall (zeroS : S), forall (oneS : S), forall (addS : forall (a : S), forall (b : S), S), forall (negS : forall (a : S), S), forall (subS : forall (a : S), forall (b : S), S), forall (mulS : forall (a : S), forall (b : S), S), forall (f : forall (x : R), S), forall (hom_args : @RingHomLawArgs.{u,v} R zeroR oneR addR negR subR mulR S zeroS oneS addS negS subS mulS f), @Eq.{v} S (f zeroR) zeroS :=
  fun R => fun zeroR => fun oneR => fun addR => fun negR => fun subR => fun mulR => fun S => fun zeroS => fun oneS => fun addS => fun negS => fun subS => fun mulS => fun f => fun hom_args => hom_args (@Eq.{v} S (f zeroR) zeroS) (fun (hom_zero_arg : @Eq.{v} S (f zeroR) zeroS) => fun (hom_one_arg : @Eq.{v} S (f oneR) oneS) => fun (hom_add_arg : forall (a : R), forall (b : R), @Eq.{v} S (f (addR a b)) (addS (f a) (f b))) => fun (hom_neg_arg : forall (a : R), @Eq.{v} S (f (negR a)) (negS (f a))) => fun (hom_mul_arg : forall (a : R), forall (b : R), @Eq.{v} S (f (mulR a b)) (mulS (f a) (f b))) => hom_zero_arg)

theorem ring_hom_one.{u,v} :
  forall (R : Sort u), forall (zeroR : R), forall (oneR : R), forall (addR : forall (a : R), forall (b : R), R), forall (negR : forall (a : R), R), forall (subR : forall (a : R), forall (b : R), R), forall (mulR : forall (a : R), forall (b : R), R), forall (S : Sort v), forall (zeroS : S), forall (oneS : S), forall (addS : forall (a : S), forall (b : S), S), forall (negS : forall (a : S), S), forall (subS : forall (a : S), forall (b : S), S), forall (mulS : forall (a : S), forall (b : S), S), forall (f : forall (x : R), S), forall (hom_args : @RingHomLawArgs.{u,v} R zeroR oneR addR negR subR mulR S zeroS oneS addS negS subS mulS f), @Eq.{v} S (f oneR) oneS :=
  fun R => fun zeroR => fun oneR => fun addR => fun negR => fun subR => fun mulR => fun S => fun zeroS => fun oneS => fun addS => fun negS => fun subS => fun mulS => fun f => fun hom_args => hom_args (@Eq.{v} S (f oneR) oneS) (fun (hom_zero_arg : @Eq.{v} S (f zeroR) zeroS) => fun (hom_one_arg : @Eq.{v} S (f oneR) oneS) => fun (hom_add_arg : forall (a : R), forall (b : R), @Eq.{v} S (f (addR a b)) (addS (f a) (f b))) => fun (hom_neg_arg : forall (a : R), @Eq.{v} S (f (negR a)) (negS (f a))) => fun (hom_mul_arg : forall (a : R), forall (b : R), @Eq.{v} S (f (mulR a b)) (mulS (f a) (f b))) => hom_one_arg)

theorem ring_hom_add.{u,v} :
  forall (R : Sort u), forall (zeroR : R), forall (oneR : R), forall (addR : forall (a : R), forall (b : R), R), forall (negR : forall (a : R), R), forall (subR : forall (a : R), forall (b : R), R), forall (mulR : forall (a : R), forall (b : R), R), forall (S : Sort v), forall (zeroS : S), forall (oneS : S), forall (addS : forall (a : S), forall (b : S), S), forall (negS : forall (a : S), S), forall (subS : forall (a : S), forall (b : S), S), forall (mulS : forall (a : S), forall (b : S), S), forall (f : forall (x : R), S), forall (hom_args : @RingHomLawArgs.{u,v} R zeroR oneR addR negR subR mulR S zeroS oneS addS negS subS mulS f), forall (a : R), forall (b : R), @Eq.{v} S (f (addR a b)) (addS (f a) (f b)) :=
  fun R => fun zeroR => fun oneR => fun addR => fun negR => fun subR => fun mulR => fun S => fun zeroS => fun oneS => fun addS => fun negS => fun subS => fun mulS => fun f => fun hom_args => fun a => fun b => hom_args (@Eq.{v} S (f (addR a b)) (addS (f a) (f b))) (fun (hom_zero_arg : @Eq.{v} S (f zeroR) zeroS) => fun (hom_one_arg : @Eq.{v} S (f oneR) oneS) => fun (hom_add_arg : forall (a : R), forall (b : R), @Eq.{v} S (f (addR a b)) (addS (f a) (f b))) => fun (hom_neg_arg : forall (a : R), @Eq.{v} S (f (negR a)) (negS (f a))) => fun (hom_mul_arg : forall (a : R), forall (b : R), @Eq.{v} S (f (mulR a b)) (mulS (f a) (f b))) => hom_add_arg a b)

theorem ring_hom_neg.{u,v} :
  forall (R : Sort u), forall (zeroR : R), forall (oneR : R), forall (addR : forall (a : R), forall (b : R), R), forall (negR : forall (a : R), R), forall (subR : forall (a : R), forall (b : R), R), forall (mulR : forall (a : R), forall (b : R), R), forall (S : Sort v), forall (zeroS : S), forall (oneS : S), forall (addS : forall (a : S), forall (b : S), S), forall (negS : forall (a : S), S), forall (subS : forall (a : S), forall (b : S), S), forall (mulS : forall (a : S), forall (b : S), S), forall (f : forall (x : R), S), forall (hom_args : @RingHomLawArgs.{u,v} R zeroR oneR addR negR subR mulR S zeroS oneS addS negS subS mulS f), forall (a : R), @Eq.{v} S (f (negR a)) (negS (f a)) :=
  fun R => fun zeroR => fun oneR => fun addR => fun negR => fun subR => fun mulR => fun S => fun zeroS => fun oneS => fun addS => fun negS => fun subS => fun mulS => fun f => fun hom_args => fun a => hom_args (@Eq.{v} S (f (negR a)) (negS (f a))) (fun (hom_zero_arg : @Eq.{v} S (f zeroR) zeroS) => fun (hom_one_arg : @Eq.{v} S (f oneR) oneS) => fun (hom_add_arg : forall (a : R), forall (b : R), @Eq.{v} S (f (addR a b)) (addS (f a) (f b))) => fun (hom_neg_arg : forall (a : R), @Eq.{v} S (f (negR a)) (negS (f a))) => fun (hom_mul_arg : forall (a : R), forall (b : R), @Eq.{v} S (f (mulR a b)) (mulS (f a) (f b))) => hom_neg_arg a)

theorem ring_hom_mul.{u,v} :
  forall (R : Sort u), forall (zeroR : R), forall (oneR : R), forall (addR : forall (a : R), forall (b : R), R), forall (negR : forall (a : R), R), forall (subR : forall (a : R), forall (b : R), R), forall (mulR : forall (a : R), forall (b : R), R), forall (S : Sort v), forall (zeroS : S), forall (oneS : S), forall (addS : forall (a : S), forall (b : S), S), forall (negS : forall (a : S), S), forall (subS : forall (a : S), forall (b : S), S), forall (mulS : forall (a : S), forall (b : S), S), forall (f : forall (x : R), S), forall (hom_args : @RingHomLawArgs.{u,v} R zeroR oneR addR negR subR mulR S zeroS oneS addS negS subS mulS f), forall (a : R), forall (b : R), @Eq.{v} S (f (mulR a b)) (mulS (f a) (f b)) :=
  fun R => fun zeroR => fun oneR => fun addR => fun negR => fun subR => fun mulR => fun S => fun zeroS => fun oneS => fun addS => fun negS => fun subS => fun mulS => fun f => fun hom_args => fun a => fun b => hom_args (@Eq.{v} S (f (mulR a b)) (mulS (f a) (f b))) (fun (hom_zero_arg : @Eq.{v} S (f zeroR) zeroS) => fun (hom_one_arg : @Eq.{v} S (f oneR) oneS) => fun (hom_add_arg : forall (a : R), forall (b : R), @Eq.{v} S (f (addR a b)) (addS (f a) (f b))) => fun (hom_neg_arg : forall (a : R), @Eq.{v} S (f (negR a)) (negS (f a))) => fun (hom_mul_arg : forall (a : R), forall (b : R), @Eq.{v} S (f (mulR a b)) (mulS (f a) (f b))) => hom_mul_arg a b)

theorem ring_as_additive_group_laws.{u} :
  forall (R : Sort u), forall (zero : R), forall (one : R), forall (add : forall (a : R), forall (b : R), R), forall (neg : forall (a : R), R), forall (sub : forall (a : R), forall (b : R), R), forall (mul : forall (a : R), forall (b : R), R), forall (ring_args : @RingLawArgs.{u} R zero one add neg sub mul), @GroupLawArgs.{u} R zero add neg :=
  fun R => fun zero => fun one => fun add => fun neg => fun sub => fun mul => fun ring_args => fun (P : Prop) => fun (mk : forall (mul_assoc_law : forall (a : R), forall (b : R), forall (c : R), @Eq.{u} R (add (add a b) c) (add a (add b c))), forall (one_mul_law : forall (a : R), @Eq.{u} R (add zero a) a), forall (mul_one_law : forall (a : R), @Eq.{u} R (add a zero) a), forall (inv_mul_law : forall (a : R), @Eq.{u} R (add (neg a) a) zero), forall (mul_inv_law : forall (a : R), @Eq.{u} R (add a (neg a)) zero), P) => ring_args P (fun (sub_eq_add_neg_arg : forall (a : R), forall (b : R), @Eq.{u} R (sub a b) (add a (neg b))) => fun (add_assoc_arg : forall (a : R), forall (b : R), forall (c : R), @Eq.{u} R (add (add a b) c) (add a (add b c))) => fun (add_comm_arg : forall (a : R), forall (b : R), @Eq.{u} R (add a b) (add b a)) => fun (add_zero_arg : forall (a : R), @Eq.{u} R (add a zero) a) => fun (zero_add_arg : forall (a : R), @Eq.{u} R (add zero a) a) => fun (neg_add_cancel_arg : forall (a : R), @Eq.{u} R (add (neg a) a) zero) => fun (add_neg_cancel_arg : forall (a : R), @Eq.{u} R (add a (neg a)) zero) => fun (sub_self_arg : forall (a : R), @Eq.{u} R (sub a a) zero) => fun (mul_assoc_arg : forall (a : R), forall (b : R), forall (c : R), @Eq.{u} R (mul (mul a b) c) (mul a (mul b c))) => fun (mul_comm_arg : forall (a : R), forall (b : R), @Eq.{u} R (mul a b) (mul b a)) => fun (mul_one_arg : forall (a : R), @Eq.{u} R (mul a one) a) => fun (one_mul_arg : forall (a : R), @Eq.{u} R (mul one a) a) => fun (left_distrib_arg : forall (a : R), forall (b : R), forall (c : R), @Eq.{u} R (mul a (add b c)) (add (mul a b) (mul a c))) => fun (right_distrib_arg : forall (a : R), forall (b : R), forall (c : R), @Eq.{u} R (mul (add a b) c) (add (mul a c) (mul b c))) => fun (mul_zero_arg : forall (a : R), @Eq.{u} R (mul a zero) zero) => fun (zero_mul_arg : forall (a : R), @Eq.{u} R (mul zero a) zero) => fun (add_left_cancel_arg : forall (a : R), forall (b : R), forall (c : R), forall (h : @Eq.{u} R (add a b) (add a c)), @Eq.{u} R b c) => fun (ring_normalize_add_mul3_arg : forall (a : R), forall (b : R), forall (c : R), @Eq.{u} R (add (add (mul a b) (mul b c)) (mul a c)) (add (add (mul a b) (mul a c)) (mul b c))) => fun (add_right_cancel_arg : forall (a : R), forall (b : R), forall (c : R), forall (h : @Eq.{u} R (add b a) (add c a)), @Eq.{u} R b c) => fun (neg_neg_arg : forall (a : R), @Eq.{u} R (neg (neg a)) a) => fun (sub_zero_arg : forall (a : R), @Eq.{u} R (sub a zero) a) => fun (zero_sub_arg : forall (a : R), @Eq.{u} R (sub zero a) (neg a)) => fun (sub_add_cancel_arg : forall (a : R), forall (b : R), @Eq.{u} R (add (sub a b) b) a) => fun (add_sub_cancel_arg : forall (a : R), forall (b : R), @Eq.{u} R (sub (add a b) b) a) => fun (sub_add_sub_cancel_arg : forall (a : R), forall (b : R), forall (c : R), @Eq.{u} R (sub (sub a c) (sub b c)) (sub a b)) => mk add_assoc_arg zero_add_arg add_zero_arg neg_add_cancel_arg add_neg_cancel_arg)

theorem ring_hom_as_additive_group_hom.{u,v} :
  forall (R : Sort u), forall (zeroR : R), forall (oneR : R), forall (addR : forall (a : R), forall (b : R), R), forall (negR : forall (a : R), R), forall (subR : forall (a : R), forall (b : R), R), forall (mulR : forall (a : R), forall (b : R), R), forall (S : Sort v), forall (zeroS : S), forall (oneS : S), forall (addS : forall (a : S), forall (b : S), S), forall (negS : forall (a : S), S), forall (subS : forall (a : S), forall (b : S), S), forall (mulS : forall (a : S), forall (b : S), S), forall (f : forall (x : R), S), forall (hom_args : @RingHomLawArgs.{u,v} R zeroR oneR addR negR subR mulR S zeroS oneS addS negS subS mulS f), @GroupHomLawArgs.{u,v} R zeroR addR negR S zeroS addS negS f :=
  fun R => fun zeroR => fun oneR => fun addR => fun negR => fun subR => fun mulR => fun S => fun zeroS => fun oneS => fun addS => fun negS => fun subS => fun mulS => fun f => fun hom_args => fun (P : Prop) => fun (mk : forall (hom_mul_law : forall (a : R), forall (b : R), @Eq.{v} S (f (addR a b)) (addS (f a) (f b))), forall (hom_one_law : @Eq.{v} S (f zeroR) zeroS), forall (hom_inv_law : forall (a : R), @Eq.{v} S (f (negR a)) (negS (f a))), P) => hom_args P (fun (hom_zero_arg : @Eq.{v} S (f zeroR) zeroS) => fun (hom_one_arg : @Eq.{v} S (f oneR) oneS) => fun (hom_add_arg : forall (a : R), forall (b : R), @Eq.{v} S (f (addR a b)) (addS (f a) (f b))) => fun (hom_neg_arg : forall (a : R), @Eq.{v} S (f (negR a)) (negS (f a))) => fun (hom_mul_arg : forall (a : R), forall (b : R), @Eq.{v} S (f (mulR a b)) (mulS (f a) (f b))) => mk hom_add_arg hom_zero_arg hom_neg_arg)

def RingImagePred.{u,v} :
  forall (R : Sort u), forall (S : Sort v), forall (f : forall (x : R), S), forall (y : S), Prop :=
  fun R => fun S => fun f => fun y => @ImagePred.{u,v} R S f y

def RingKerQuot.{u,v} :
  forall (R : Sort succ u), forall (S : Sort succ v), forall (f : forall (x : R), S), Sort succ u :=
  fun R => fun S => fun f => @KerQuot.{u,v} R S f

def RingKerQuotMk.{u,v} :
  forall (R : Sort succ u), forall (S : Sort succ v), forall (f : forall (x : R), S), forall (a : R), @RingKerQuot.{u,v} R S f :=
  fun R => fun S => fun f => fun a => @KerQuotMk.{u,v} R S f a

def RingKerQuotToS.{u,v} :
  forall (R : Sort succ u), forall (S : Sort succ v), forall (f : forall (x : R), S), forall (q : @RingKerQuot.{u,v} R S f), S :=
  fun R => fun S => fun f => @KerQuotToH.{u,v} R S f

def RingKerQuotAdd.{u,v} :
  forall (R : Sort succ u), forall (zeroR : R), forall (oneR : R), forall (addR : forall (a : R), forall (b : R), R), forall (negR : forall (a : R), R), forall (subR : forall (a : R), forall (b : R), R), forall (mulR : forall (a : R), forall (b : R), R), forall (S : Sort succ v), forall (zeroS : S), forall (oneS : S), forall (addS : forall (a : S), forall (b : S), S), forall (negS : forall (a : S), S), forall (subS : forall (a : S), forall (b : S), S), forall (mulS : forall (a : S), forall (b : S), S), forall (f : forall (x : R), S), forall (hom_args : @RingHomLawArgs.{succ u,succ v} R zeroR oneR addR negR subR mulR S zeroS oneS addS negS subS mulS f), forall (q1 : @RingKerQuot.{u,v} R S f), forall (q2 : @RingKerQuot.{u,v} R S f), @RingKerQuot.{u,v} R S f :=
  fun R => fun zeroR => fun oneR => fun addR => fun negR => fun subR => fun mulR => fun S => fun zeroS => fun oneS => fun addS => fun negS => fun subS => fun mulS => fun f => fun hom_args => @KerQuotMul.{u,v} R zeroR addR negR S zeroS addS negS f (@ring_hom_as_additive_group_hom.{succ u,succ v} R zeroR oneR addR negR subR mulR S zeroS oneS addS negS subS mulS f hom_args)

def RingKerQuotZero.{u,v} :
  forall (R : Sort succ u), forall (zeroR : R), forall (S : Sort succ v), forall (f : forall (x : R), S), @RingKerQuot.{u,v} R S f :=
  fun R => fun zeroR => fun S => fun f => @KerQuotOne.{u,v} R zeroR S f

def RingKerQuotNeg.{u,v} :
  forall (R : Sort succ u), forall (zeroR : R), forall (oneR : R), forall (addR : forall (a : R), forall (b : R), R), forall (negR : forall (a : R), R), forall (subR : forall (a : R), forall (b : R), R), forall (mulR : forall (a : R), forall (b : R), R), forall (S : Sort succ v), forall (zeroS : S), forall (oneS : S), forall (addS : forall (a : S), forall (b : S), S), forall (negS : forall (a : S), S), forall (subS : forall (a : S), forall (b : S), S), forall (mulS : forall (a : S), forall (b : S), S), forall (f : forall (x : R), S), forall (hom_args : @RingHomLawArgs.{succ u,succ v} R zeroR oneR addR negR subR mulR S zeroS oneS addS negS subS mulS f), forall (q : @RingKerQuot.{u,v} R S f), @RingKerQuot.{u,v} R S f :=
  fun R => fun zeroR => fun oneR => fun addR => fun negR => fun subR => fun mulR => fun S => fun zeroS => fun oneS => fun addS => fun negS => fun subS => fun mulS => fun f => fun hom_args => @KerQuotInv.{u,v} R zeroR addR negR S zeroS addS negS f (@ring_hom_as_additive_group_hom.{succ u,succ v} R zeroR oneR addR negR subR mulR S zeroS oneS addS negS subS mulS f hom_args)

def RingKerQuotMulRep.{u,v} :
  forall (R : Sort succ u), forall (mulR : forall (a : R), forall (b : R), R), forall (S : Sort succ v), forall (f : forall (x : R), S), forall (a : R), forall (b : R), @RingKerQuot.{u,v} R S f :=
  fun R => fun mulR => fun S => fun f => fun a => fun b => @RingKerQuotMk.{u,v} R S f (mulR a b)

theorem ring_ker_quot_mul_rep_compat.{u,v} :
  forall (R : Sort succ u), forall (zeroR : R), forall (oneR : R), forall (addR : forall (a : R), forall (b : R), R), forall (negR : forall (a : R), R), forall (subR : forall (a : R), forall (b : R), R), forall (mulR : forall (a : R), forall (b : R), R), forall (S : Sort succ v), forall (zeroS : S), forall (oneS : S), forall (addS : forall (a : S), forall (b : S), S), forall (negS : forall (a : S), S), forall (subS : forall (a : S), forall (b : S), S), forall (mulS : forall (a : S), forall (b : S), S), forall (f : forall (x : R), S), forall (hom_args : @RingHomLawArgs.{succ u,succ v} R zeroR oneR addR negR subR mulR S zeroS oneS addS negS subS mulS f), forall (a : R), forall (a2 : R), forall (b : R), forall (b2 : R), forall (ha : @KerRel.{succ u,succ v} R S f a a2), forall (hb : @KerRel.{succ u,succ v} R S f b b2), @Eq.{succ u} (@RingKerQuot.{u,v} R S f) (@RingKerQuotMulRep.{u,v} R mulR S f a b) (@RingKerQuotMulRep.{u,v} R mulR S f a2 b2) :=
  fun R => fun zeroR => fun oneR => fun addR => fun negR => fun subR => fun mulR => fun S => fun zeroS => fun oneS => fun addS => fun negS => fun subS => fun mulS => fun f => fun hom_args => fun a => fun a2 => fun b => fun b2 => fun ha => fun hb => @ker_quot_sound.{u,v} R S f (mulR a b) (mulR a2 b2) (@eq_trans.{succ v} S (f (mulR a b)) (mulS (f a) (f b)) (f (mulR a2 b2)) (@ring_hom_mul.{succ u,succ v} R zeroR oneR addR negR subR mulR S zeroS oneS addS negS subS mulS f hom_args a b) (@eq_trans.{succ v} S (mulS (f a) (f b)) (mulS (f a2) (f b2)) (f (mulR a2 b2)) (@eq_congr2.{succ v,succ v,succ v} S S S mulS (f a) (f a2) (f b) (f b2) ha hb) (@eq_symm.{succ v} S (f (mulR a2 b2)) (mulS (f a2) (f b2)) (@ring_hom_mul.{succ u,succ v} R zeroR oneR addR negR subR mulR S zeroS oneS addS negS subS mulS f hom_args a2 b2))))

theorem ring_image_intro.{u,v} :
  forall (R : Sort u), forall (S : Sort v), forall (f : forall (x : R), S), forall (a : R), @RingImagePred.{u,v} R S f (f a) :=
  fun R => fun S => fun f => fun a => @image_intro.{u,v} R S f a

theorem ring_image_zero.{u,v} :
  forall (R : Sort u), forall (zeroR : R), forall (oneR : R), forall (addR : forall (a : R), forall (b : R), R), forall (negR : forall (a : R), R), forall (subR : forall (a : R), forall (b : R), R), forall (mulR : forall (a : R), forall (b : R), R), forall (S : Sort v), forall (zeroS : S), forall (oneS : S), forall (addS : forall (a : S), forall (b : S), S), forall (negS : forall (a : S), S), forall (subS : forall (a : S), forall (b : S), S), forall (mulS : forall (a : S), forall (b : S), S), forall (f : forall (x : R), S), forall (hom_args : @RingHomLawArgs.{u,v} R zeroR oneR addR negR subR mulR S zeroS oneS addS negS subS mulS f), @RingImagePred.{u,v} R S f zeroS :=
  fun R => fun zeroR => fun oneR => fun addR => fun negR => fun subR => fun mulR => fun S => fun zeroS => fun oneS => fun addS => fun negS => fun subS => fun mulS => fun f => fun hom_args => fun (P : Prop) => fun (mk : forall (a : R), forall (h : @Eq.{v} S (f a) zeroS), P) => mk zeroR (@ring_hom_zero.{u,v} R zeroR oneR addR negR subR mulR S zeroS oneS addS negS subS mulS f hom_args)

theorem ring_image_one.{u,v} :
  forall (R : Sort u), forall (zeroR : R), forall (oneR : R), forall (addR : forall (a : R), forall (b : R), R), forall (negR : forall (a : R), R), forall (subR : forall (a : R), forall (b : R), R), forall (mulR : forall (a : R), forall (b : R), R), forall (S : Sort v), forall (zeroS : S), forall (oneS : S), forall (addS : forall (a : S), forall (b : S), S), forall (negS : forall (a : S), S), forall (subS : forall (a : S), forall (b : S), S), forall (mulS : forall (a : S), forall (b : S), S), forall (f : forall (x : R), S), forall (hom_args : @RingHomLawArgs.{u,v} R zeroR oneR addR negR subR mulR S zeroS oneS addS negS subS mulS f), @RingImagePred.{u,v} R S f oneS :=
  fun R => fun zeroR => fun oneR => fun addR => fun negR => fun subR => fun mulR => fun S => fun zeroS => fun oneS => fun addS => fun negS => fun subS => fun mulS => fun f => fun hom_args => fun (P : Prop) => fun (mk : forall (a : R), forall (h : @Eq.{v} S (f a) oneS), P) => mk oneR (@ring_hom_one.{u,v} R zeroR oneR addR negR subR mulR S zeroS oneS addS negS subS mulS f hom_args)

theorem ring_image_add_closed.{u,v} :
  forall (R : Sort u), forall (zeroR : R), forall (oneR : R), forall (addR : forall (a : R), forall (b : R), R), forall (negR : forall (a : R), R), forall (subR : forall (a : R), forall (b : R), R), forall (mulR : forall (a : R), forall (b : R), R), forall (S : Sort v), forall (zeroS : S), forall (oneS : S), forall (addS : forall (a : S), forall (b : S), S), forall (negS : forall (a : S), S), forall (subS : forall (a : S), forall (b : S), S), forall (mulS : forall (a : S), forall (b : S), S), forall (f : forall (x : R), S), forall (hom_args : @RingHomLawArgs.{u,v} R zeroR oneR addR negR subR mulR S zeroS oneS addS negS subS mulS f), forall (x : S), forall (y : S), forall (hx : @RingImagePred.{u,v} R S f x), forall (hy : @RingImagePred.{u,v} R S f y), @RingImagePred.{u,v} R S f (addS x y) :=
  fun R => fun zeroR => fun oneR => fun addR => fun negR => fun subR => fun mulR => fun S => fun zeroS => fun oneS => fun addS => fun negS => fun subS => fun mulS => fun f => fun hom_args => fun x => fun y => fun hx => fun hy => hx (@RingImagePred.{u,v} R S f (addS x y)) (fun (a : R) => fun (hax : @Eq.{v} S (f a) x) => hy (@RingImagePred.{u,v} R S f (addS x y)) (fun (b : R) => fun (hby : @Eq.{v} S (f b) y) => fun (P : Prop) => fun (mk : forall (c : R), forall (h : @Eq.{v} S (f c) (addS x y)), P) => mk (addR a b) (@eq_trans.{v} S (f (addR a b)) (addS (f a) (f b)) (addS x y) (@ring_hom_add.{u,v} R zeroR oneR addR negR subR mulR S zeroS oneS addS negS subS mulS f hom_args a b) (@eq_congr2.{v,v,v} S S S addS (f a) x (f b) y hax hby))))

theorem ring_image_neg_closed.{u,v} :
  forall (R : Sort u), forall (zeroR : R), forall (oneR : R), forall (addR : forall (a : R), forall (b : R), R), forall (negR : forall (a : R), R), forall (subR : forall (a : R), forall (b : R), R), forall (mulR : forall (a : R), forall (b : R), R), forall (S : Sort v), forall (zeroS : S), forall (oneS : S), forall (addS : forall (a : S), forall (b : S), S), forall (negS : forall (a : S), S), forall (subS : forall (a : S), forall (b : S), S), forall (mulS : forall (a : S), forall (b : S), S), forall (f : forall (x : R), S), forall (hom_args : @RingHomLawArgs.{u,v} R zeroR oneR addR negR subR mulR S zeroS oneS addS negS subS mulS f), forall (y : S), forall (hy : @RingImagePred.{u,v} R S f y), @RingImagePred.{u,v} R S f (negS y) :=
  fun R => fun zeroR => fun oneR => fun addR => fun negR => fun subR => fun mulR => fun S => fun zeroS => fun oneS => fun addS => fun negS => fun subS => fun mulS => fun f => fun hom_args => fun y => fun hy => hy (@RingImagePred.{u,v} R S f (negS y)) (fun (a : R) => fun (hay : @Eq.{v} S (f a) y) => fun (P : Prop) => fun (mk : forall (c : R), forall (h : @Eq.{v} S (f c) (negS y)), P) => mk (negR a) (@eq_trans.{v} S (f (negR a)) (negS (f a)) (negS y) (@ring_hom_neg.{u,v} R zeroR oneR addR negR subR mulR S zeroS oneS addS negS subS mulS f hom_args a) (@eq_congr_arg.{v,v} S S negS (f a) y hay)))

theorem ring_image_mul_closed.{u,v} :
  forall (R : Sort u), forall (zeroR : R), forall (oneR : R), forall (addR : forall (a : R), forall (b : R), R), forall (negR : forall (a : R), R), forall (subR : forall (a : R), forall (b : R), R), forall (mulR : forall (a : R), forall (b : R), R), forall (S : Sort v), forall (zeroS : S), forall (oneS : S), forall (addS : forall (a : S), forall (b : S), S), forall (negS : forall (a : S), S), forall (subS : forall (a : S), forall (b : S), S), forall (mulS : forall (a : S), forall (b : S), S), forall (f : forall (x : R), S), forall (hom_args : @RingHomLawArgs.{u,v} R zeroR oneR addR negR subR mulR S zeroS oneS addS negS subS mulS f), forall (x : S), forall (y : S), forall (hx : @RingImagePred.{u,v} R S f x), forall (hy : @RingImagePred.{u,v} R S f y), @RingImagePred.{u,v} R S f (mulS x y) :=
  fun R => fun zeroR => fun oneR => fun addR => fun negR => fun subR => fun mulR => fun S => fun zeroS => fun oneS => fun addS => fun negS => fun subS => fun mulS => fun f => fun hom_args => fun x => fun y => fun hx => fun hy => hx (@RingImagePred.{u,v} R S f (mulS x y)) (fun (a : R) => fun (hax : @Eq.{v} S (f a) x) => hy (@RingImagePred.{u,v} R S f (mulS x y)) (fun (b : R) => fun (hby : @Eq.{v} S (f b) y) => fun (P : Prop) => fun (mk : forall (c : R), forall (h : @Eq.{v} S (f c) (mulS x y)), P) => mk (mulR a b) (@eq_trans.{v} S (f (mulR a b)) (mulS (f a) (f b)) (mulS x y) (@ring_hom_mul.{u,v} R zeroR oneR addR negR subR mulR S zeroS oneS addS negS subS mulS f hom_args a b) (@eq_congr2.{v,v,v} S S S mulS (f a) x (f b) y hax hby))))