:: 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:] holds
( ( 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 ) ) ) implies 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) holds
( ( 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 ) ) ) implies 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) holds
( ( 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 ) ) implies 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 holds
( ex b4 being Element of Quot. b1 st
( b2 in b4 & b3 in b4 ) implies (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 holds
( b2 meets b3 implies 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 holds
( ( 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 ))) ) ) ) implies 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 holds
( ( 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 )) ) ) ) implies 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 holds
( ( 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 ) ) implies 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 holds
( ( 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 ) ) implies 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 holds
( ( 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 )) ) ) ) implies 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 holds
( ( 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 ) ) ) ) implies 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 holds
( b2 <> q0. b1 implies 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 holds
( b2 <> q0. b1 implies ( 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 holds
( ( 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 ) implies 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 holds
( ( 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 ) implies 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 holds
( ( for b3 being Element of Quot. c1 holds b1 . b3 = qaddinv b3 ) & ( for b3 being Element of Quot. c1 holds b2 . b3 = qaddinv b3 ) implies 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 holds
( ( for b3 being Element of Quot. c1 holds b1 . b3 = qmultinv b3 ) & ( for b3 being Element of Quot. c1 holds b2 . b3 = qmultinv b3 ) implies 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 holds
( b2 <> q0. b1 implies ( (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) holds
( b3 = q1. b1 implies ( 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) holds
not ( b2 <> 0. (the_Field_of_Quotients b1) & ( for b3 being Element of (the_Field_of_Quotients b1) holds
not 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) holds
( b2 <> 0. (the_Field_of_Quotients b1) implies for b3 being Element of b1 holds
( b3 <> 0. b1 implies for b4 being Element of Q. b1 holds
( b2 = QClass. b4 & b4 = [b3,(1. b1)] implies for b5 being Element of Q. b1 holds
( b5 = [(1. b1),b3] implies b2 " = QClass. b5 ) ) ) )
proof end;

registration
cluster non empty add-associative right_zeroed right_complementable associative commutative distributive left_unital Field-like -> non empty add-associative right_zeroed right_complementable associative commutative right_unital distributive left_unital Field-like domRing-like doubleLoopStr ;
coherence
for b1 being non empty add-associative right_zeroed right_complementable associative commutative distributive left_unital Field-like 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 holds
( b3 <> 0. b1 & b5 <> 0. b1 implies (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 holds
( b3 <> 0. b1 & b5 <> 0. b1 implies (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 multiplicative unity-preserving Relation of the carrier of a1,the carrier of a2;
coherence
for b1 being Function of c1,c2 holds
( b1 is RingHomomorphism implies ( b1 is additive & b1 is multiplicative & b1 is unity-preserving ) )
by Def21;
cluster additive multiplicative unity-preserving -> RingHomomorphism Relation of the carrier of a1,the carrier of a2;
coherence
for b1 being Function of c1,c2 holds
( b1 is additive & b1 is multiplicative & b1 is unity-preserving implies 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 Relation of the carrier of a1,the carrier of a2;
coherence
for b1 being Function of c1,c2 holds
( b1 is RingIsomorphism implies ( b1 is RingMonomorphism & b1 is RingEpimorphism ) )
by Def24;
cluster RingEpimorphism RingMonomorphism -> RingIsomorphism Relation of the carrier of a1,the carrier of a2;
coherence
for b1 being Function of c1,c2 holds
( b1 is RingMonomorphism & b1 is RingEpimorphism implies b1 is RingIsomorphism )
by Def24;
end;

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

theorem Th54: :: QUOFIELD:54
for b1, b2 being Ring
for b3 being Function of b1,b2 holds
( b3 is RingMonomorphism implies 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 holds
( b3 is RingHomomorphism implies for b4 being Element of b1 holds
( b4 <> 0. b1 implies 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 holds
( b3 is RingHomomorphism implies for b4, b5 being Element of b1 holds
( b5 <> 0. b1 implies 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 holds
( b4 is RingHomomorphism implies for b5 being Function of b2,b3 holds
( b5 is RingHomomorphism implies 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 multiplicative unity-preserving 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 holds
not ( ex b3 being Function of b1,b2 st b3 is RingIsomorphism & ( for b3 being Function of b2,b1 holds
not 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 holds
( b3 <> 0. b1 implies 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) holds
( ( 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)) ) implies 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 holds
not ( b2 is RingMonomorphism & ( for b3 being Function of a2,b1 holds
not ( b3 is RingHomomorphism & b3 * a3 = b2 & ( for b4 being Function of a2,b1 holds
( b4 is RingHomomorphism & b4 * a3 = b2 implies 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 holds
not ( b5 is RingMonomorphism & ( for b6 being Function of b2,b4 holds
not ( b6 is RingHomomorphism & b6 * b3 = b5 & ( for b7 being Function of b2,b4 holds
( b7 is RingHomomorphism & b7 * b3 = b5 implies b7 = b6 ) ) ) ) ) ) ) );

theorem Th64: :: QUOFIELD:64
for b1 being commutative non degenerated domRing-like Ring holds
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 holds
( b1 has_Field_of_Quotients_Pair b2,b4 & b1 has_Field_of_Quotients_Pair b3,b5 implies b2 is_ringisomorph_to b3 )
proof end;