:: QUOFIELD semantic presentation

definition
let c1 be non empty ZeroStr ;
func Q. c1 -> Subset of [:the carrier of a1,the carrier of a1:] means :Def1: :: QUOFIELD:def 1
for b1 being set holds
( b1 in a2 iff ex b2, b3 being Element of a1 st
( b1 = [b2,b3] & b3 <> 0. a1 ) );
existence
ex b1 being Subset of [:the carrier of c1,the carrier of c1:] st
for b2 being set holds
( b2 in b1 iff ex b3, b4 being Element of c1 st
( b2 = [b3,b4] & b4 <> 0. c1 ) )
proof end;
uniqueness
for b1, b2 being Subset of [:the carrier of c1,the carrier of c1:] st ( for b3 being set holds
( b3 in b1 iff ex b4, b5 being Element of c1 st
( b3 = [b4,b5] & b5 <> 0. c1 ) ) ) & ( for b3 being set holds
( b3 in b2 iff ex b4, b5 being Element of c1 st
( b3 = [b4,b5] & b5 <> 0. c1 ) ) ) holds
b1 = b2
proof end;
end;

:: deftheorem Def1 defines Q. QUOFIELD:def 1 :
for b1 being non empty ZeroStr
for b2 being Subset of [:the carrier of b1,the carrier of b1:] holds
( b2 = Q. b1 iff for b3 being set holds
( b3 in b2 iff ex b4, b5 being Element of b1 st
( b3 = [b4,b5] & b5 <> 0. b1 ) ) );

theorem Th1: :: QUOFIELD:1
for b1 being non empty non degenerated multLoopStr_0 holds not Q. b1 is empty
proof end;

registration
let c1 be non empty non degenerated multLoopStr_0 ;
cluster Q. a1 -> non empty ;
coherence
not Q. c1 is empty
by Th1;
end;

theorem Th2: :: QUOFIELD:2
for b1 being non empty non degenerated multLoopStr_0
for b2 being Element of Q. b1 holds b2 `2 <> 0. b1
proof end;

Lemma4: for b1 being non empty non degenerated multLoopStr_0
for b2 being Element of Q. b1 holds
( b2 `1 is Element of b1 & b2 `2 is Element of b1 )
;

definition
let c1 be non empty non degenerated multLoopStr_0 ;
let c2 be Element of Q. c1;
redefine func `1 as c2 `1 -> Element of a1;
coherence
c2 `1 is Element of c1
by Lemma4;
redefine func `2 as c2 `2 -> Element of a1;
coherence
c2 `2 is Element of c1
by Lemma4;
end;

definition
let c1 be non empty non degenerated domRing-like doubleLoopStr ;
let c2, c3 be Element of Q. c1;
func padd c2,c3 -> Element of Q. a1 equals :: QUOFIELD:def 2
[(((a2 `1 ) * (a3 `2 )) + ((a3 `1 ) * (a2 `2 ))),((a2 `2 ) * (a3 `2 ))];
coherence
[(((c2 `1 ) * (c3 `2 )) + ((c3 `1 ) * (c2 `2 ))),((c2 `2 ) * (c3 `2 ))] is Element of Q. c1
proof end;
end;

:: deftheorem Def2 defines padd QUOFIELD:def 2 :
for b1 being non empty non degenerated domRing-like doubleLoopStr
for b2, b3 being Element of Q. b1 holds padd b2,b3 = [(((b2 `1 ) * (b3 `2 )) + ((b3 `1 ) * (b2 `2 ))),((b2 `2 ) * (b3 `2 ))];

definition
let c1 be non empty non degenerated domRing-like doubleLoopStr ;
let c2, c3 be Element of Q. c1;
func pmult c2,c3 -> Element of Q. a1 equals :: QUOFIELD:def 3
[((a2 `1 ) * (a3 `1 )),((a2 `2 ) * (a3 `2 ))];
coherence
[((c2 `1 ) * (c3 `1 )),((c2 `2 ) * (c3 `2 ))] is Element of Q. c1
proof end;
end;

:: deftheorem Def3 defines pmult QUOFIELD:def 3 :
for b1 being non empty non degenerated domRing-like doubleLoopStr
for b2, b3 being Element of Q. b1 holds pmult b2,b3 = [((b2 `1 ) * (b3 `1 )),((b2 `2 ) * (b3 `2 ))];

theorem Th3: :: QUOFIELD:3
canceled;

theorem Th4: :: QUOFIELD:4
for b1 being non empty Abelian add-associative associative commutative distributive non degenerated domRing-like doubleLoopStr
for b2, b3, b4 being Element of Q. b1 holds
( padd b2,(padd b3,b4) = padd (padd b2,b3),b4 & padd b2,b3 = padd b3,b2 )
proof end;

theorem Th5: :: QUOFIELD:5
for b1 being non empty Abelian associative commutative non degenerated domRing-like doubleLoopStr
for b2, b3, b4 being Element of Q. b1 holds
( pmult b2,(pmult b3,b4) = pmult (pmult b2,b3),b4 & pmult b2,b3 = pmult b3,b2 )
proof end;

definition
let c1 be non empty Abelian add-associative associative commutative distributive non degenerated domRing-like doubleLoopStr ;
let c2, c3 be Element of Q. c1;
redefine func padd as padd c2,c3 -> Element of Q. a1;
commutativity
for b1, b2 being Element of Q. c1 holds padd b1,b2 = padd b2,b1
by Th4;
end;

definition
let c1 be non empty Abelian associative commutative non degenerated domRing-like doubleLoopStr ;
let c2, c3 be Element of Q. c1;
redefine func pmult as pmult c2,c3 -> Element of Q. a1;
commutativity
for b1, b2 being Element of Q. c1 holds pmult b1,b2 = pmult b2,b1
by Th5;
end;

definition
let c1 be non empty non degenerated multLoopStr_0 ;
let c2 be Element of Q. c1;
func QClass. c2 -> Subset of (Q. a1) means :Def4: :: QUOFIELD:def 4
for b1 being Element of Q. a1 holds
( b1 in a3 iff (b1 `1 ) * (a2 `2 ) = (b1 `2 ) * (a2 `1 ) );
existence
ex b1 being Subset of (Q. c1) st
for b2 being Element of Q. c1 holds
( b2 in b1 iff (b2 `1 ) * (c2 `2 ) = (b2 `2 ) * (c2 `1 ) )
proof end;
uniqueness
for b1, b2 being Subset of (Q. c1) st ( for b3 being Element of Q. c1 holds
( b3 in b1 iff (b3 `1 ) * (c2 `2 ) = (b3 `2 ) * (c2 `1 ) ) ) & ( for b3 being Element of Q. c1 holds
( b3 in b2 iff (b3 `1 ) * (c2 `2 ) = (b3 `2 ) * (c2 `1 ) ) ) holds
b1 = b2
proof end;
end;

:: deftheorem Def4 defines QClass. QUOFIELD:def 4 :
for b1 being non empty non degenerated multLoopStr_0
for b2 being Element of Q. b1
for b3 being Subset of (Q. b1) holds
( b3 = QClass. b2 iff for b4 being Element of Q. b1 holds
( b4 in b3 iff (b4 `1 ) * (b2 `2 ) = (b4 `2 ) * (b2 `1 ) ) );

theorem Th6: :: QUOFIELD:6
for b1 being non empty commutative non degenerated multLoopStr_0
for b2 being Element of Q. b1 holds b2 in QClass. b2
proof end;

registration
let c1 be non empty commutative non degenerated multLoopStr_0 ;
let c2 be Element of Q. c1;
cluster QClass. a2 -> non empty ;
coherence
not QClass. c2 is empty
by Th6;
end;

definition
let c1 be non empty non degenerated multLoopStr_0 ;
func Quot. c1 -> Subset-Family of (Q. a1) means :Def5: :: QUOFIELD:def 5
for b1 being Subset of (Q. a1) holds
( b1 in a2 iff ex b2 being Element of Q. a1 st b1 = QClass. b2 );
existence
ex b1 being Subset-Family of (Q. c1) st
for b2 being Subset of (Q. c1) holds
( b2 in b1 iff ex b3 being Element of Q. c1 st b2 = QClass. b3 )
proof end;
uniqueness
for b1, b2 being Subset-Family of (Q. c1) st ( for b3 being Subset of (Q. c1) holds
( b3 in b1 iff ex b4 being Element of Q. c1 st b3 = QClass. b4 ) ) & ( for b3 being Subset of (Q. c1) holds
( b3 in b2 iff ex b4 being Element of Q. c1 st b3 = QClass. b4 ) ) holds
b1 = b2
proof end;
end;

:: deftheorem Def5 defines Quot. QUOFIELD:def 5 :
for b1 being non empty non degenerated multLoopStr_0
for b2 being Subset-Family of (Q. b1) holds
( b2 = Quot. b1 iff for b3 being Subset of (Q. b1) holds
( b3 in b2 iff ex b4 being Element of Q. b1 st b3 = QClass. b4 ) );

theorem Th7: :: QUOFIELD:7
for b1 being non empty non degenerated multLoopStr_0 holds not Quot. b1 is empty
proof end;

registration
let c1 be non empty non degenerated multLoopStr_0 ;
cluster Quot. a1 -> non empty ;
coherence
not Quot. c1 is empty
by Th7;
end;

theorem Th8: :: QUOFIELD:8
for b1 being commutative non degenerated domRing-like Ring
for b2, b3 being Element of Q. b1 st ex b4 being Element of Quot. b1 st
( b2 in b4 & b3 in b4 ) holds
(b2 `1 ) * (b3 `2 ) = (b3 `1 ) * (b2 `2 )
proof end;

theorem Th9: :: QUOFIELD:9
for b1 being commutative non degenerated domRing-like Ring
for b2, b3 being Element of Quot. b1 st b2 meets b3 holds
b2 = b3
proof end;

definition
let c1 be commutative non degenerated domRing-like Ring;
let c2, c3 be Element of Quot. c1;
func qadd c2,c3 -> Element of Quot. a1 means :Def6: :: QUOFIELD:def 6
for b1 being Element of Q. a1 holds
( b1 in a4 iff ex b2, b3 being Element of Q. a1 st
( b2 in a2 & b3 in a3 & (b1 `1 ) * ((b2 `2 ) * (b3 `2 )) = (b1 `2 ) * (((b2 `1 ) * (b3 `2 )) + ((b3 `1 ) * (b2 `2 ))) ) );
existence
ex b1 being Element of Quot. c1 st
for b2 being Element of Q. c1 holds
( b2 in b1 iff ex b3, b4 being Element of Q. c1 st
( b3 in c2 & b4 in c3 & (b2 `1 ) * ((b3 `2 ) * (b4 `2 )) = (b2 `2 ) * (((b3 `1 ) * (b4 `2 )) + ((b4 `1 ) * (b3 `2 ))) ) )
proof end;
uniqueness
for b1, b2 being Element of Quot. c1 st ( for b3 being Element of Q. c1 holds
( b3 in b1 iff ex b4, b5 being Element of Q. c1 st
( b4 in c2 & b5 in c3 & (b3 `1 ) * ((b4 `2 ) * (b5 `2 )) = (b3 `2 ) * (((b4 `1 ) * (b5 `2 )) + ((b5 `1 ) * (b4 `2 ))) ) ) ) & ( for b3 being Element of Q. c1 holds
( b3 in b2 iff ex b4, b5 being Element of Q. c1 st
( b4 in c2 & b5 in c3 & (b3 `1 ) * ((b4 `2 ) * (b5 `2 )) = (b3 `2 ) * (((b4 `1 ) * (b5 `2 )) + ((b5 `1 ) * (b4 `2 ))) ) ) ) holds
b1 = b2
proof end;
end;

:: deftheorem Def6 defines qadd QUOFIELD:def 6 :
for b1 being commutative non degenerated domRing-like Ring
for b2, b3, b4 being Element of Quot. b1 holds
( b4 = qadd b2,b3 iff for b5 being Element of Q. b1 holds
( b5 in b4 iff ex b6, b7 being Element of Q. b1 st
( b6 in b2 & b7 in b3 & (b5 `1 ) * ((b6 `2 ) * (b7 `2 )) = (b5 `2 ) * (((b6 `1 ) * (b7 `2 )) + ((b7 `1 ) * (b6 `2 ))) ) ) );

definition
let c1 be commutative non degenerated domRing-like Ring;
let c2, c3 be Element of Quot. c1;
func qmult c2,c3 -> Element of Quot. a1 means :Def7: :: QUOFIELD:def 7
for b1 being Element of Q. a1 holds
( b1 in a4 iff ex b2, b3 being Element of Q. a1 st
( b2 in a2 & b3 in a3 & (b1 `1 ) * ((b2 `2 ) * (b3 `2 )) = (b1 `2 ) * ((b2 `1 ) * (b3 `1 )) ) );
existence
ex b1 being Element of Quot. c1 st
for b2 being Element of Q. c1 holds
( b2 in b1 iff ex b3, b4 being Element of Q. c1 st
( b3 in c2 & b4 in c3 & (b2 `1 ) * ((b3 `2 ) * (b4 `2 )) = (b2 `2 ) * ((b3 `1 ) * (b4 `1 )) ) )
proof end;
uniqueness
for b1, b2 being Element of Quot. c1 st ( for b3 being Element of Q. c1 holds
( b3 in b1 iff ex b4, b5 being Element of Q. c1 st
( b4 in c2 & b5 in c3 & (b3 `1 ) * ((b4 `2 ) * (b5 `2 )) = (b3 `2 ) * ((b4 `1 ) * (b5 `1 )) ) ) ) & ( for b3 being Element of Q. c1 holds
( b3 in b2 iff ex b4, b5 being Element of Q. c1 st
( b4 in c2 & b5 in c3 & (b3 `1 ) * ((b4 `2 ) * (b5 `2 )) = (b3 `2 ) * ((b4 `1 ) * (b5 `1 )) ) ) ) holds
b1 = b2
proof end;
end;

:: deftheorem Def7 defines qmult QUOFIELD:def 7 :
for b1 being commutative non degenerated domRing-like Ring
for b2, b3, b4 being Element of Quot. b1 holds
( b4 = qmult b2,b3 iff for b5 being Element of Q. b1 holds
( b5 in b4 iff ex b6, b7 being Element of Q. b1 st
( b6 in b2 & b7 in b3 & (b5 `1 ) * ((b6 `2 ) * (b7 `2 )) = (b5 `2 ) * ((b6 `1 ) * (b7 `1 )) ) ) );

definition
let c1 be non empty non degenerated multLoopStr_0 ;
let c2 be Element of Q. c1;
redefine func QClass. as QClass. c2 -> Element of Quot. a1;
coherence
QClass. c2 is Element of Quot. c1
by Def5;
end;

theorem Th10: :: QUOFIELD:10
canceled;

theorem Th11: :: QUOFIELD:11
for b1 being commutative non degenerated domRing-like Ring
for b2, b3 being Element of Q. b1 holds qadd (QClass. b2),(QClass. b3) = QClass. (padd b2,b3)
proof end;

theorem Th12: :: QUOFIELD:12
for b1 being commutative non degenerated domRing-like Ring
for b2, b3 being Element of Q. b1 holds qmult (QClass. b2),(QClass. b3) = QClass. (pmult b2,b3)
proof end;

definition
let c1 be commutative non degenerated domRing-like Ring;
func q0. c1 -> Element of Quot. a1 means :Def8: :: QUOFIELD:def 8
for b1 being Element of Q. a1 holds
( b1 in a2 iff b1 `1 = 0. a1 );
existence
ex b1 being Element of Quot. c1 st
for b2 being Element of Q. c1 holds
( b2 in b1 iff b2 `1 = 0. c1 )
proof end;
uniqueness
for b1, b2 being Element of Quot. c1 st ( for b3 being Element of Q. c1 holds
( b3 in b1 iff b3 `1 = 0. c1 ) ) & ( for b3 being Element of Q. c1 holds
( b3 in b2 iff b3 `1 = 0. c1 ) ) holds
b1 = b2
proof end;
end;

:: deftheorem Def8 defines q0. QUOFIELD:def 8 :
for b1 being commutative non degenerated domRing-like Ring
for b2 being Element of Quot. b1 holds
( b2 = q0. b1 iff for b3 being Element of Q. b1 holds
( b3 in b2 iff b3 `1 = 0. b1 ) );

definition
let c1 be commutative non degenerated domRing-like Ring;
func q1. c1 -> Element of Quot. a1 means :Def9: :: QUOFIELD:def 9
for b1 being Element of Q. a1 holds
( b1 in a2 iff b1 `1 = b1 `2 );
existence
ex b1 being Element of Quot. c1 st
for b2 being Element of Q. c1 holds
( b2 in b1 iff b2 `1 = b2 `2 )
proof end;
uniqueness
for b1, b2 being Element of Quot. c1 st ( for b3 being Element of Q. c1 holds
( b3 in b1 iff b3 `1 = b3 `2 ) ) & ( for b3 being Element of Q. c1 holds
( b3 in b2 iff b3 `1 = b3 `2 ) ) holds
b1 = b2
proof end;
end;

:: deftheorem Def9 defines q1. QUOFIELD:def 9 :
for b1 being commutative non degenerated domRing-like Ring
for b2 being Element of Quot. b1 holds
( b2 = q1. b1 iff for b3 being Element of Q. b1 holds
( b3 in b2 iff b3 `1 = b3 `2 ) );

definition
let c1 be commutative non degenerated domRing-like Ring;
let c2 be Element of Quot. c1;
func qaddinv c2 -> Element of Quot. a1 means :Def10: :: QUOFIELD:def 10
for b1 being Element of Q. a1 holds
( b1 in a3 iff ex b2 being Element of Q. a1 st
( b2 in a2 & (b1 `1 ) * (b2 `2 ) = (b1 `2 ) * (- (b2 `1 )) ) );
existence
ex b1 being Element of Quot. c1 st
for b2 being Element of Q. c1 holds
( b2 in b1 iff ex b3 being Element of Q. c1 st
( b3 in c2 & (b2 `1 ) * (b3 `2 ) = (b2 `2 ) * (- (b3 `1 )) ) )
proof end;
uniqueness
for b1, b2 being Element of Quot. c1 st ( for b3 being Element of Q. c1 holds
( b3 in b1 iff ex b4 being Element of Q. c1 st
( b4 in c2 & (b3 `1 ) * (b4 `2 ) = (b3 `2 ) * (- (b4 `1 )) ) ) ) & ( for b3 being Element of Q. c1 holds
( b3 in b2 iff ex b4 being Element of Q. c1 st
( b4 in c2 & (b3 `1 ) * (b4 `2 ) = (b3 `2 ) * (- (b4 `1 )) ) ) ) holds
b1 = b2
proof end;
end;

:: deftheorem Def10 defines qaddinv QUOFIELD:def 10 :
for b1 being commutative non degenerated domRing-like Ring
for b2, b3 being Element of Quot. b1 holds
( b3 = qaddinv b2 iff for b4 being Element of Q. b1 holds
( b4 in b3 iff ex b5 being Element of Q. b1 st
( b5 in b2 & (b4 `1 ) * (b5 `2 ) = (b4 `2 ) * (- (b5 `1 )) ) ) );

definition
let c1 be commutative non degenerated domRing-like Ring;
let c2 be Element of Quot. c1;
assume E20: c2 <> q0. c1 ;
func qmultinv c2 -> Element of Quot. a1 means :Def11: :: QUOFIELD:def 11
for b1 being Element of Q. a1 holds
( b1 in a3 iff ex b2 being Element of Q. a1 st
( b2 in a2 & (b1 `1 ) * (b2 `1 ) = (b1 `2 ) * (b2 `2 ) ) );
existence
ex b1 being Element of Quot. c1 st
for b2 being Element of Q. c1 holds
( b2 in b1 iff ex b3 being Element of Q. c1 st
( b3 in c2 & (b2 `1 ) * (b3 `1 ) = (b2 `2 ) * (b3 `2 ) ) )
proof end;
uniqueness
for b1, b2 being Element of Quot. c1 st ( for b3 being Element of Q. c1 holds
( b3 in b1 iff ex b4 being Element of Q. c1 st
( b4 in c2 & (b3 `1 ) * (b4 `1 ) = (b3 `2 ) * (b4 `2 ) ) ) ) & ( for b3 being Element of Q. c1 holds
( b3 in b2 iff ex b4 being Element of Q. c1 st
( b4 in c2 & (b3 `1 ) * (b4 `1 ) = (b3 `2 ) * (b4 `2 ) ) ) ) holds
b1 = b2
proof end;
end;

:: deftheorem Def11 defines qmultinv QUOFIELD:def 11 :
for b1 being commutative non degenerated domRing-like Ring
for b2 being Element of Quot. b1 st b2 <> q0. b1 holds
for b3 being Element of Quot. b1 holds
( b3 = qmultinv b2 iff for b4 being Element of Q. b1 holds
( b4 in b3 iff ex b5 being Element of Q. b1 st
( b5 in b2 & (b4 `1 ) * (b5 `1 ) = (b4 `2 ) * (b5 `2 ) ) ) );

theorem Th13: :: QUOFIELD:13
for b1 being commutative non degenerated domRing-like Ring
for b2, b3, b4 being Element of Quot. b1 holds
( qadd b2,(qadd b3,b4) = qadd (qadd b2,b3),b4 & qadd b2,b3 = qadd b3,b2 )
proof end;

theorem Th14: :: QUOFIELD:14
for b1 being commutative non degenerated domRing-like Ring
for b2 being Element of Quot. b1 holds
( qadd b2,(q0. b1) = b2 & qadd (q0. b1),b2 = b2 )
proof end;

theorem Th15: :: QUOFIELD:15
for b1 being commutative non degenerated domRing-like Ring
for b2, b3, b4 being Element of Quot. b1 holds
( qmult b2,(qmult b3,b4) = qmult (qmult b2,b3),b4 & qmult b2,b3 = qmult b3,b2 )
proof end;

theorem Th16: :: QUOFIELD:16
for b1 being commutative non degenerated domRing-like Ring
for b2 being Element of Quot. b1 holds
( qmult b2,(q1. b1) = b2 & qmult (q1. b1),b2 = b2 )
proof end;

theorem Th17: :: QUOFIELD:17
for b1 being commutative non degenerated domRing-like Ring
for b2, b3, b4 being Element of Quot. b1 holds qmult (qadd b2,b3),b4 = qadd (qmult b2,b4),(qmult b3,b4)
proof end;

theorem Th18: :: QUOFIELD:18
for b1 being commutative non degenerated domRing-like Ring
for b2, b3, b4 being Element of Quot. b1 holds qmult b2,(qadd b3,b4) = qadd (qmult b2,b3),(qmult b2,b4)
proof end;

theorem Th19: :: QUOFIELD:19
for b1 being commutative non degenerated domRing-like Ring
for b2 being Element of Quot. b1 holds
( qadd b2,(qaddinv b2) = q0. b1 & qadd (qaddinv b2),b2 = q0. b1 )
proof end;

theorem Th20: :: QUOFIELD:20
for b1 being commutative non degenerated domRing-like Ring
for b2 being Element of Quot. b1 st b2 <> q0. b1 holds
( qmult b2,(qmultinv b2) = q1. b1 & qmult (qmultinv b2),b2 = q1. b1 )
proof end;

theorem Th21: :: QUOFIELD:21
for b1 being commutative non degenerated domRing-like Ring holds q1. b1 <> q0. b1
proof end;

definition
let c1 be commutative non degenerated domRing-like Ring;
func quotadd c1 -> BinOp of Quot. a1 means :Def12: :: QUOFIELD:def 12
for b1, b2 being Element of Quot. a1 holds a2 . b1,b2 = qadd b1,b2;
existence
ex b1 being BinOp of Quot. c1 st
for b2, b3 being Element of Quot. c1 holds b1 . b2,b3 = qadd b2,b3
proof end;
uniqueness
for b1, b2 being BinOp of Quot. c1 st ( for b3, b4 being Element of Quot. c1 holds b1 . b3,b4 = qadd b3,b4 ) & ( for b3, b4 being Element of Quot. c1 holds b2 . b3,b4 = qadd b3,b4 ) holds
b1 = b2
proof end;
end;

:: deftheorem Def12 defines quotadd QUOFIELD:def 12 :
for b1 being commutative non degenerated domRing-like Ring
for b2 being BinOp of Quot. b1 holds
( b2 = quotadd b1 iff for b3, b4 being Element of Quot. b1 holds b2 . b3,b4 = qadd b3,b4 );

definition
let c1 be commutative non degenerated domRing-like Ring;
func quotmult c1 -> BinOp of Quot. a1 means :Def13: :: QUOFIELD:def 13
for b1, b2 being Element of Quot. a1 holds a2 . b1,b2 = qmult b1,b2;
existence
ex b1 being BinOp of Quot. c1 st
for b2, b3 being Element of Quot. c1 holds b1 . b2,b3 = qmult b2,b3
proof end;
uniqueness
for b1, b2 being BinOp of Quot. c1 st ( for b3, b4 being Element of Quot. c1 holds b1 . b3,b4 = qmult b3,b4 ) & ( for b3, b4 being Element of Quot. c1 holds b2 . b3,b4 = qmult b3,b4 ) holds
b1 = b2
proof end;
end;

:: deftheorem Def13 defines quotmult QUOFIELD:def 13 :
for b1 being commutative non degenerated domRing-like Ring
for b2 being BinOp of Quot. b1 holds
( b2 = quotmult b1 iff for b3, b4 being Element of Quot. b1 holds b2 . b3,b4 = qmult b3,b4 );

definition
let c1 be commutative non degenerated domRing-like Ring;
func quotaddinv c1 -> UnOp of Quot. a1 means :Def14: :: QUOFIELD:def 14
for b1 being Element of Quot. a1 holds a2 . b1 = qaddinv b1;
existence
ex b1 being UnOp of Quot. c1 st
for b2 being Element of Quot. c1 holds b1 . b2 = qaddinv b2
proof end;
uniqueness
for b1, b2 being UnOp of Quot. c1 st ( for b3 being Element of Quot. c1 holds b1 . b3 = qaddinv b3 ) & ( for b3 being Element of Quot. c1 holds b2 . b3 = qaddinv b3 ) holds
b1 = b2
proof end;
end;

:: deftheorem Def14 defines quotaddinv QUOFIELD:def 14 :
for b1 being commutative non degenerated domRing-like Ring
for b2 being UnOp of Quot. b1 holds
( b2 = quotaddinv b1 iff for b3 being Element of Quot. b1 holds b2 . b3 = qaddinv b3 );

definition
let c1 be commutative non degenerated domRing-like Ring;
func quotmultinv c1 -> UnOp of Quot. a1 means :Def15: :: QUOFIELD:def 15
for b1 being Element of Quot. a1 holds a2 . b1 = qmultinv b1;
existence
ex b1 being UnOp of Quot. c1 st
for b2 being Element of Quot. c1 holds b1 . b2 = qmultinv b2
proof end;
uniqueness
for b1, b2 being UnOp of Quot. c1 st ( for b3 being Element of Quot. c1 holds b1 . b3 = qmultinv b3 ) & ( for b3 being Element of Quot. c1 holds b2 . b3 = qmultinv b3 ) holds
b1 = b2
proof end;
end;

:: deftheorem Def15 defines quotmultinv QUOFIELD:def 15 :
for b1 being commutative non degenerated domRing-like Ring
for b2 being UnOp of Quot. b1 holds
( b2 = quotmultinv b1 iff for b3 being Element of Quot. b1 holds b2 . b3 = qmultinv b3 );

theorem Th22: :: QUOFIELD:22
for b1 being commutative non degenerated domRing-like Ring
for b2, b3, b4 being Element of Quot. b1 holds (quotadd b1) . ((quotadd b1) . b2,b3),b4 = (quotadd b1) . b2,((quotadd b1) . b3,b4)
proof end;

theorem Th23: :: QUOFIELD:23
for b1 being commutative non degenerated domRing-like Ring
for b2, b3 being Element of Quot. b1 holds (quotadd b1) . b2,b3 = (quotadd b1) . b3,b2
proof end;

theorem Th24: :: QUOFIELD:24
for b1 being commutative non degenerated domRing-like Ring
for b2 being Element of Quot. b1 holds
( (quotadd b1) . b2,(q0. b1) = b2 & (quotadd b1) . (q0. b1),b2 = b2 )
proof end;

theorem Th25: :: QUOFIELD:25
for b1 being commutative non degenerated domRing-like Ring
for b2, b3, b4 being Element of Quot. b1 holds (quotmult b1) . ((quotmult b1) . b2,b3),b4 = (quotmult b1) . b2,((quotmult b1) . b3,b4)
proof end;

theorem Th26: :: QUOFIELD:26
for b1 being commutative non degenerated domRing-like Ring
for b2, b3 being Element of Quot. b1 holds (quotmult b1) . b2,b3 = (quotmult b1) . b3,b2
proof end;

theorem Th27: :: QUOFIELD:27
for b1 being commutative non degenerated domRing-like Ring
for b2 being Element of Quot. b1 holds
( (quotmult b1) . b2,(q1. b1) = b2 & (quotmult b1) . (q1. b1),b2 = b2 )
proof end;

theorem Th28: :: QUOFIELD:28
for b1 being commutative non degenerated domRing-like Ring
for b2, b3, b4 being Element of Quot. b1 holds (quotmult b1) . ((quotadd b1) . b2,b3),b4 = (quotadd b1) . ((quotmult b1) . b2,b4),((quotmult b1) . b3,b4)
proof end;

theorem Th29: :: QUOFIELD:29
for b1 being commutative non degenerated domRing-like Ring
for b2, b3, b4 being Element of Quot. b1 holds (quotmult b1) . b2,((quotadd b1) . b3,b4) = (quotadd b1) . ((quotmult b1) . b2,b3),((quotmult b1) . b2,b4)
proof end;

theorem Th30: :: QUOFIELD:30
for b1 being commutative non degenerated domRing-like Ring
for b2 being Element of Quot. b1 holds
( (quotadd b1) . b2,((quotaddinv b1) . b2) = q0. b1 & (quotadd b1) . ((quotaddinv b1) . b2),b2 = q0. b1 )
proof end;

theorem Th31: :: QUOFIELD:31
for b1 being commutative non degenerated domRing-like Ring
for b2 being Element of Quot. b1 st b2 <> q0. b1 holds
( (quotmult b1) . b2,((quotmultinv b1) . b2) = q1. b1 & (quotmult b1) . ((quotmultinv b1) . b2),b2 = q1. b1 )
proof end;

definition
let c1 be commutative non degenerated domRing-like Ring;
func the_Field_of_Quotients c1 -> strict doubleLoopStr equals :: QUOFIELD:def 16
doubleLoopStr(# (Quot. a1),(quotadd a1),(quotmult a1),(q1. a1),(q0. a1) #);
correctness
coherence
doubleLoopStr(# (Quot. c1),(quotadd c1),(quotmult c1),(q1. c1),(q0. c1) #) is strict doubleLoopStr
;
;
end;

:: deftheorem Def16 defines the_Field_of_Quotients QUOFIELD:def 16 :
for b1 being commutative non degenerated domRing-like Ring holds the_Field_of_Quotients b1 = doubleLoopStr(# (Quot. b1),(quotadd b1),(quotmult b1),(q1. b1),(q0. b1) #);

registration
let c1 be commutative non degenerated domRing-like Ring;
cluster the_Field_of_Quotients a1 -> non empty strict ;
coherence
not the_Field_of_Quotients c1 is empty
proof end;
end;

theorem Th32: :: QUOFIELD:32
for b1 being commutative non degenerated domRing-like Ring holds
( the carrier of (the_Field_of_Quotients b1) = Quot. b1 & the add of (the_Field_of_Quotients b1) = quotadd b1 & the mult of (the_Field_of_Quotients b1) = quotmult b1 & the Zero of (the_Field_of_Quotients b1) = q0. b1 & the unity of (the_Field_of_Quotients b1) = q1. b1 ) ;

theorem Th33: :: QUOFIELD:33
for b1 being commutative non degenerated domRing-like Ring
for b2, b3 being Element of (the_Field_of_Quotients b1) holds (quotadd b1) . b2,b3 is Element of (the_Field_of_Quotients b1)
proof end;

theorem Th34: :: QUOFIELD:34
for b1 being commutative non degenerated domRing-like Ring
for b2 being Element of (the_Field_of_Quotients b1) holds (quotaddinv b1) . b2 is Element of (the_Field_of_Quotients b1)
proof end;

theorem Th35: :: QUOFIELD:35
for b1 being commutative non degenerated domRing-like Ring
for b2, b3 being Element of (the_Field_of_Quotients b1) holds (quotmult b1) . b2,b3 is Element of (the_Field_of_Quotients b1)
proof end;

theorem Th36: :: QUOFIELD:36
for b1 being commutative non degenerated domRing-like Ring
for b2 being Element of (the_Field_of_Quotients b1) holds (quotmultinv b1) . b2 is Element of (the_Field_of_Quotients b1)
proof end;

theorem Th37: :: QUOFIELD:37
for b1 being commutative non degenerated domRing-like Ring
for b2, b3 being Element of (the_Field_of_Quotients b1) holds b2 + b3 = (quotadd b1) . b2,b3 ;

Lemma47: for b1 being commutative non degenerated domRing-like Ring
for b2, b3, b4 being Element of (the_Field_of_Quotients b1) holds (b2 + b3) + b4 = b2 + (b3 + b4)
proof end;

Lemma48: for b1 being commutative non degenerated domRing-like Ring
for b2, b3 being Element of (the_Field_of_Quotients b1) holds b2 + b3 = b3 + b2
proof end;

Lemma49: for b1 being commutative non degenerated domRing-like Ring
for b2 being Element of (the_Field_of_Quotients b1) holds b2 + (0. (the_Field_of_Quotients b1)) = b2
proof end;

Lemma50: for b1 being commutative non degenerated domRing-like Ring holds
( the_Field_of_Quotients b1 is add-associative & the_Field_of_Quotients b1 is right_zeroed & the_Field_of_Quotients b1 is right_complementable )
proof end;

registration
let c1 be commutative non degenerated domRing-like Ring;
cluster the_Field_of_Quotients a1 -> non empty add-associative right_zeroed right_complementable strict ;
coherence
( the_Field_of_Quotients c1 is add-associative & the_Field_of_Quotients c1 is right_zeroed & the_Field_of_Quotients c1 is right_complementable )
by Lemma50;
end;

theorem Th38: :: QUOFIELD:38
for b1 being commutative non degenerated domRing-like Ring
for b2 being Element of (the_Field_of_Quotients b1) holds - b2 = (quotaddinv b1) . b2
proof end;

theorem Th39: :: QUOFIELD:39
for b1 being commutative non degenerated domRing-like Ring
for b2, b3 being Element of (the_Field_of_Quotients b1) holds b2 * b3 = (quotmult b1) . b2,b3 ;

Lemma51: for b1 being commutative non degenerated domRing-like Ring
for b2, b3 being Element of (the_Field_of_Quotients b1) holds b2 * b3 = b3 * b2
by Th26;

Lemma52: for b1 being commutative non degenerated domRing-like Ring holds the_Field_of_Quotients b1 is non empty commutative doubleLoopStr
proof end;

registration
let c1 be commutative non degenerated domRing-like Ring;
cluster the_Field_of_Quotients a1 -> non empty add-associative right_zeroed right_complementable commutative strict ;
coherence
the_Field_of_Quotients c1 is commutative
by Lemma52;
end;

Lemma53: for b1 being commutative non degenerated domRing-like Ring
for b2, b3 being Element of (the_Field_of_Quotients b1) st b3 = q1. b1 holds
( b3 * b2 = b2 & b2 * b3 = b2 )
by Th27;

Lemma54: for b1 being commutative non degenerated domRing-like Ring holds the_Field_of_Quotients b1 is unital
proof end;

Lemma55: for b1 being commutative non degenerated domRing-like Ring holds 1. (the_Field_of_Quotients b1) = q1. b1
proof end;

Lemma56: for b1 being commutative non degenerated domRing-like Ring
for b2 being Element of (the_Field_of_Quotients b1) holds (1. (the_Field_of_Quotients b1)) * b2 = b2
proof end;

registration
let c1 be commutative non degenerated domRing-like Ring;
cluster the_Field_of_Quotients a1 -> non empty add-associative right_zeroed right_complementable unital commutative strict ;
coherence
the_Field_of_Quotients c1 is unital
by Lemma54;
end;

theorem Th40: :: QUOFIELD:40
for b1 being commutative non degenerated domRing-like Ring holds
( 1. (the_Field_of_Quotients b1) = q1. b1 & 0. (the_Field_of_Quotients b1) = q0. b1 ) by Lemma55;

theorem Th41: :: QUOFIELD:41
for b1 being commutative non degenerated domRing-like Ring
for b2, b3, b4 being Element of (the_Field_of_Quotients b1) holds (b2 + b3) + b4 = b2 + (b3 + b4) by Lemma47;

theorem Th42: :: QUOFIELD:42
for b1 being commutative non degenerated domRing-like Ring
for b2, b3 being Element of (the_Field_of_Quotients b1) holds b2 + b3 = b3 + b2 by Lemma48;

theorem Th43: :: QUOFIELD:43
for b1 being commutative non degenerated domRing-like Ring
for b2 being Element of (the_Field_of_Quotients b1) holds b2 + (0. (the_Field_of_Quotients b1)) = b2 by Lemma49;

theorem Th44: :: QUOFIELD:44
canceled;

theorem Th45: :: QUOFIELD:45
for b1 being commutative non degenerated domRing-like Ring
for b2 being Element of (the_Field_of_Quotients b1) holds (1. (the_Field_of_Quotients b1)) * b2 = b2 by Lemma56;

theorem Th46: :: QUOFIELD:46
for b1 being commutative non degenerated domRing-like Ring
for b2, b3 being Element of (the_Field_of_Quotients b1) holds b2 * b3 = b3 * b2 ;

theorem Th47: :: QUOFIELD:47
for b1 being commutative non degenerated domRing-like Ring
for b2, b3, b4 being Element of (the_Field_of_Quotients b1) holds (b2 * b3) * b4 = b2 * (b3 * b4) by Th25;

theorem Th48: :: QUOFIELD:48
for b1 being commutative non degenerated domRing-like Ring
for b2 being Element of (the_Field_of_Quotients b1) st b2 <> 0. (the_Field_of_Quotients b1) holds
ex b3 being Element of (the_Field_of_Quotients b1) st b2 * b3 = 1. (the_Field_of_Quotients b1)
proof end;

Lemma59: for b1 being commutative non degenerated domRing-like Ring
for b2, b3, b4 being Element of (the_Field_of_Quotients b1) holds
( b2 * (b3 + b4) = (b2 * b3) + (b2 * b4) & (b2 + b3) * b4 = (b2 * b4) + (b3 * b4) )
proof end;

theorem Th49: :: QUOFIELD:49
for b1 being commutative non degenerated domRing-like Ring holds the_Field_of_Quotients b1 is non empty Abelian add-associative right_zeroed right_complementable unital associative distributive Field-like non degenerated doubleLoopStr
proof end;

registration
let c1 be commutative non degenerated domRing-like Ring;
cluster the_Field_of_Quotients a1 -> non empty Abelian add-associative right_zeroed right_complementable unital associative commutative strict distributive Field-like non degenerated ;
coherence
( the_Field_of_Quotients c1 is Abelian & the_Field_of_Quotients c1 is associative & the_Field_of_Quotients c1 is distributive & the_Field_of_Quotients c1 is Field-like & not the_Field_of_Quotients c1 is degenerated )
by Th49;
end;

theorem Th50: :: QUOFIELD:50
for b1 being commutative non degenerated domRing-like Ring
for b2 being Element of (the_Field_of_Quotients b1) st b2 <> 0. (the_Field_of_Quotients b1) holds
for b3 being Element of b1 st b3 <> 0. b1 holds
for b4 being Element of Q. b1 st b2 = QClass. b4 & b4 = [b3,(1. b1)] holds
for b5 being Element of Q. b1 st b5 = [(1. b1),b3] holds
b2 " = QClass. b5
proof end;

registration
cluster non empty add-associative right_zeroed right_complementable associative commutative distributive left_unital Field-like non degenerated -> non empty add-associative right_zeroed right_complementable associative commutative right_unital distributive left_unital Field-like non degenerated domRing-like doubleLoopStr ;
coherence
for b1 being non empty add-associative right_zeroed right_complementable associative commutative distributive left_unital Field-like non degenerated doubleLoopStr holds
( b1 is domRing-like & b1 is right_unital )
proof end;
end;

registration
cluster non empty Abelian add-associative right_zeroed right_complementable associative commutative right_unital distributive left_unital Field-like non degenerated domRing-like doubleLoopStr ;
existence
ex b1 being non empty doubleLoopStr st
( b1 is add-associative & b1 is right_zeroed & b1 is right_complementable & b1 is Abelian & b1 is commutative & b1 is associative & b1 is left_unital & b1 is distributive & b1 is Field-like & not b1 is degenerated )
proof end;
end;

definition
let c1 be non empty associative commutative distributive left_unital Field-like doubleLoopStr ;
let c2, c3 be Element of c1;
func c2 / c3 -> Element of a1 equals :: QUOFIELD:def 17
a2 * (a3 " );
correctness
coherence
c2 * (c3 " ) is Element of c1
;
;
end;

:: deftheorem Def17 defines / QUOFIELD:def 17 :
for b1 being non empty associative commutative distributive left_unital Field-like doubleLoopStr
for b2, b3 being Element of b1 holds b2 / b3 = b2 * (b3 " );

theorem Th51: :: QUOFIELD:51
for b1 being commutative Field-like non degenerated Ring
for b2, b3, b4, b5 being Element of b1 st b3 <> 0. b1 & b5 <> 0. b1 holds
(b2 / b3) * (b4 / b5) = (b2 * b4) / (b3 * b5)
proof end;

theorem Th52: :: QUOFIELD:52
for b1 being commutative Field-like non degenerated Ring
for b2, b3, b4, b5 being Element of b1 st b3 <> 0. b1 & b5 <> 0. b1 holds
(b2 / b3) + (b4 / b5) = ((b2 * b5) + (b4 * b3)) / (b3 * b5)
proof end;

definition
let c1, c2 be non empty doubleLoopStr ;
let c3 be Function of c1,c2;
canceled;
canceled;
canceled;
attr a3 is RingHomomorphism means :Def21: :: QUOFIELD:def 21
( a3 is additive & a3 is multiplicative & a3 is unity-preserving );
end;

:: deftheorem Def18 QUOFIELD:def 18 :
canceled;

:: deftheorem Def19 QUOFIELD:def 19 :
canceled;

:: deftheorem Def20 QUOFIELD:def 20 :
canceled;

:: deftheorem Def21 defines RingHomomorphism QUOFIELD:def 21 :
for b1, b2 being non empty doubleLoopStr
for b3 being Function of b1,b2 holds
( b3 is RingHomomorphism iff ( b3 is additive & b3 is multiplicative & b3 is unity-preserving ) );

registration
let c1, c2 be non empty doubleLoopStr ;
cluster RingHomomorphism -> additive unity-preserving multiplicative M4(the carrier of a1,the carrier of a2);
coherence
for b1 being Function of c1,c2 st b1 is RingHomomorphism holds
( b1 is additive & b1 is multiplicative & b1 is unity-preserving )
by Def21;
cluster additive unity-preserving multiplicative -> RingHomomorphism M4(the carrier of a1,the carrier of a2);
coherence
for b1 being Function of c1,c2 st b1 is additive & b1 is multiplicative & b1 is unity-preserving holds
b1 is RingHomomorphism
by Def21;
end;

definition
let c1, c2 be non empty doubleLoopStr ;
let c3 be Function of c1,c2;
attr a3 is RingEpimorphism means :Def22: :: QUOFIELD:def 22
( a3 is RingHomomorphism & rng a3 = the carrier of a2 );
attr a3 is RingMonomorphism means :Def23: :: QUOFIELD:def 23
( a3 is RingHomomorphism & a3 is one-to-one );
end;

:: deftheorem Def22 defines RingEpimorphism QUOFIELD:def 22 :
for b1, b2 being non empty doubleLoopStr
for b3 being Function of b1,b2 holds
( b3 is RingEpimorphism iff ( b3 is RingHomomorphism & rng b3 = the carrier of b2 ) );

:: deftheorem Def23 defines RingMonomorphism QUOFIELD:def 23 :
for b1, b2 being non empty doubleLoopStr
for b3 being Function of b1,b2 holds
( b3 is RingMonomorphism iff ( b3 is RingHomomorphism & b3 is one-to-one ) );

notation
let c1, c2 be non empty doubleLoopStr ;
let c3 be Function of c1,c2;
synonym embedding c3 for RingMonomorphism c3;
end;

definition
let c1, c2 be non empty doubleLoopStr ;
let c3 be Function of c1,c2;
attr a3 is RingIsomorphism means :Def24: :: QUOFIELD:def 24
( a3 is RingMonomorphism & a3 is RingEpimorphism );
end;

:: deftheorem Def24 defines RingIsomorphism QUOFIELD:def 24 :
for b1, b2 being non empty doubleLoopStr
for b3 being Function of b1,b2 holds
( b3 is RingIsomorphism iff ( b3 is RingMonomorphism & b3 is RingEpimorphism ) );

registration
let c1, c2 be non empty doubleLoopStr ;
cluster RingIsomorphism -> RingEpimorphism RingMonomorphism M4(the carrier of a1,the carrier of a2);
coherence
for b1 being Function of c1,c2 st b1 is RingIsomorphism holds
( b1 is RingMonomorphism & b1 is RingEpimorphism )
by Def24;
cluster RingEpimorphism RingMonomorphism -> RingIsomorphism M4(the carrier of a1,the carrier of a2);
coherence
for b1 being Function of c1,c2 st b1 is RingMonomorphism & b1 is RingEpimorphism holds
b1 is RingIsomorphism
by Def24;
end;

theorem Th53: :: QUOFIELD:53
for b1, b2 being Ring
for b3 being Function of b1,b2 st b3 is RingHomomorphism holds
b3 . (0. b1) = 0. b2
proof end;

theorem Th54: :: QUOFIELD:54
for b1, b2 being Ring
for b3 being Function of b1,b2 st b3 is RingMonomorphism holds
for b4 being Element of b1 holds
( b3 . b4 = 0. b2 iff b4 = 0. b1 )
proof end;

theorem Th55: :: QUOFIELD:55
for b1, b2 being commutative Field-like non degenerated Ring
for b3 being Function of b1,b2 st b3 is RingHomomorphism holds
for b4 being Element of b1 st b4 <> 0. b1 holds
b3 . (b4 " ) = (b3 . b4) "
proof end;

theorem Th56: :: QUOFIELD:56
for b1, b2 being commutative Field-like non degenerated Ring
for b3 being Function of b1,b2 st b3 is RingHomomorphism holds
for b4, b5 being Element of b1 st b5 <> 0. b1 holds
b3 . (b4 * (b5 " )) = (b3 . b4) * ((b3 . b5) " )
proof end;

theorem Th57: :: QUOFIELD:57
for b1, b2, b3 being Ring
for b4 being Function of b1,b2 st b4 is RingHomomorphism holds
for b5 being Function of b2,b3 st b5 is RingHomomorphism holds
b5 * b4 is RingHomomorphism
proof end;

theorem Th58: :: QUOFIELD:58
for b1 being non empty doubleLoopStr holds id b1 is RingHomomorphism
proof end;

registration
let c1 be non empty doubleLoopStr ;
cluster id a1 -> additive unity-preserving multiplicative RingHomomorphism ;
coherence
id c1 is RingHomomorphism
by Th58;
end;

definition
let c1, c2 be non empty doubleLoopStr ;
pred c1 is_embedded_in c2 means :Def25: :: QUOFIELD:def 25
ex b1 being Function of a1,a2 st b1 is RingMonomorphism;
end;

:: deftheorem Def25 defines is_embedded_in QUOFIELD:def 25 :
for b1, b2 being non empty doubleLoopStr holds
( b1 is_embedded_in b2 iff ex b3 being Function of b1,b2 st b3 is RingMonomorphism );

definition
let c1, c2 be non empty doubleLoopStr ;
pred c1 is_ringisomorph_to c2 means :Def26: :: QUOFIELD:def 26
ex b1 being Function of a1,a2 st b1 is RingIsomorphism;
symmetry
for b1, b2 being non empty doubleLoopStr st ex b3 being Function of b1,b2 st b3 is RingIsomorphism holds
ex b3 being Function of b2,b1 st b3 is RingIsomorphism
proof end;
end;

:: deftheorem Def26 defines is_ringisomorph_to QUOFIELD:def 26 :
for b1, b2 being non empty doubleLoopStr holds
( b1 is_ringisomorph_to b2 iff ex b3 being Function of b1,b2 st b3 is RingIsomorphism );

definition
let c1 be non empty ZeroStr ;
let c2, c3 be Element of c1;
assume E76: c3 <> 0. c1 ;
func quotient c2,c3 -> Element of Q. a1 equals :Def27: :: QUOFIELD:def 27
[a2,a3];
coherence
[c2,c3] is Element of Q. c1
by E76, Def1;
end;

:: deftheorem Def27 defines quotient QUOFIELD:def 27 :
for b1 being non empty ZeroStr
for b2, b3 being Element of b1 st b3 <> 0. b1 holds
quotient b2,b3 = [b2,b3];

definition
let c1 be commutative non degenerated domRing-like Ring;
func canHom c1 -> Function of a1,(the_Field_of_Quotients a1) means :Def28: :: QUOFIELD:def 28
for b1 being Element of a1 holds a2 . b1 = QClass. (quotient b1,(1. a1));
existence
ex b1 being Function of c1,(the_Field_of_Quotients c1) st
for b2 being Element of c1 holds b1 . b2 = QClass. (quotient b2,(1. c1))
proof end;
uniqueness
for b1, b2 being Function of c1,(the_Field_of_Quotients c1) st ( for b3 being Element of c1 holds b1 . b3 = QClass. (quotient b3,(1. c1)) ) & ( for b3 being Element of c1 holds b2 . b3 = QClass. (quotient b3,(1. c1)) ) holds
b1 = b2
proof end;
end;

:: deftheorem Def28 defines canHom QUOFIELD:def 28 :
for b1 being commutative non degenerated domRing-like Ring
for b2 being Function of b1,(the_Field_of_Quotients b1) holds
( b2 = canHom b1 iff for b3 being Element of b1 holds b2 . b3 = QClass. (quotient b3,(1. b1)) );

theorem Th59: :: QUOFIELD:59
for b1 being commutative non degenerated domRing-like Ring holds canHom b1 is RingHomomorphism
proof end;

theorem Th60: :: QUOFIELD:60
for b1 being commutative non degenerated domRing-like Ring holds canHom b1 is RingMonomorphism
proof end;

theorem Th61: :: QUOFIELD:61
for b1 being commutative non degenerated domRing-like Ring holds b1 is_embedded_in the_Field_of_Quotients b1
proof end;

theorem Th62: :: QUOFIELD:62
for b1 being commutative Field-like non degenerated domRing-like Ring holds b1 is_ringisomorph_to the_Field_of_Quotients b1
proof end;

registration
let c1 be commutative non degenerated domRing-like Ring;
cluster the_Field_of_Quotients a1 -> non empty Abelian add-associative right_zeroed right_complementable unital associative commutative strict right-distributive right_unital distributive Field-like non degenerated domRing-like ;
coherence
( the_Field_of_Quotients c1 is domRing-like & the_Field_of_Quotients c1 is right_unital & the_Field_of_Quotients c1 is right-distributive )
;
end;

theorem Th63: :: QUOFIELD:63
for b1 being commutative non degenerated domRing-like Ring holds the_Field_of_Quotients (the_Field_of_Quotients b1) is_ringisomorph_to the_Field_of_Quotients b1 by Th62;

definition
let c1, c2 be non empty doubleLoopStr ;
let c3 be Function of c1,c2;
pred c1 has_Field_of_Quotients_Pair c2,c3 means :Def29: :: QUOFIELD:def 29
( a3 is RingMonomorphism & ( for b1 being non empty Abelian add-associative right_zeroed right_complementable associative commutative distributive left_unital Field-like non degenerated doubleLoopStr
for b2 being Function of a1,b1 st b2 is RingMonomorphism holds
ex b3 being Function of a2,b1 st
( b3 is RingHomomorphism & b3 * a3 = b2 & ( for b4 being Function of a2,b1 st b4 is RingHomomorphism & b4 * a3 = b2 holds
b4 = b3 ) ) ) );
end;

:: deftheorem Def29 defines has_Field_of_Quotients_Pair QUOFIELD:def 29 :
for b1, b2 being non empty doubleLoopStr
for b3 being Function of b1,b2 holds
( b1 has_Field_of_Quotients_Pair b2,b3 iff ( b3 is RingMonomorphism & ( for b4 being non empty Abelian add-associative right_zeroed right_complementable associative commutative distributive left_unital Field-like non degenerated doubleLoopStr
for b5 being Function of b1,b4 st b5 is RingMonomorphism holds
ex b6 being Function of b2,b4 st
( b6 is RingHomomorphism & b6 * b3 = b5 & ( for b7 being Function of b2,b4 st b7 is RingHomomorphism & b7 * b3 = b5 holds
b7 = b6 ) ) ) ) );

theorem Th64: :: QUOFIELD:64
for b1 being commutative non degenerated domRing-like Ring ex b2 being non empty Abelian add-associative right_zeroed right_complementable associative commutative distributive left_unital Field-like non degenerated doubleLoopStr ex b3 being Function of b1,b2 st b1 has_Field_of_Quotients_Pair b2,b3
proof end;

theorem Th65: :: QUOFIELD:65
for b1 being commutative domRing-like Ring
for b2, b3 being non empty Abelian add-associative right_zeroed right_complementable associative commutative distributive left_unital Field-like non degenerated doubleLoopStr
for b4 being Function of b1,b2
for b5 being Function of b1,b3 st b1 has_Field_of_Quotients_Pair b2,b4 & b1 has_Field_of_Quotients_Pair b3,b5 holds
b2 is_ringisomorph_to b3
proof end;