:: Coherent Space
:: by Jaros{\l}aw Kotowicz and Konrad Raczkowski
::
:: Copyright (c) 1992-2019 Association of Mizar Users

:: Coherent Space and Web of Coherent Space
definition
let IT be set ;
attr IT is binary_complete means :Def1: :: COH_SP:def 1
for A being set st A c= IT & ( for a, b being set st a in A & b in A holds
a \/ b in IT ) holds
union A in IT;
end;

:: deftheorem Def1 defines binary_complete COH_SP:def 1 :
for IT being set holds
( IT is binary_complete iff for A being set st A c= IT & ( for a, b being set st a in A & b in A holds
a \/ b in IT ) holds
union A in IT );

registration
existence
ex b1 being set st
( b1 is subset-closed & b1 is binary_complete & not b1 is empty )
proof end;
end;

definition end;

theorem :: COH_SP:1
for C being Coherence_Space holds {} in C
proof end;

theorem Th2: :: COH_SP:2
for X being set holds bool X is Coherence_Space
proof end;

theorem :: COH_SP:3

theorem Th4: :: COH_SP:4
for x being set
for C being Coherence_Space st x in union C holds
{x} in C
proof end;

definition
let C be Coherence_Space;
func Web C -> Tolerance of () means :Def2: :: COH_SP:def 2
for x, y being object holds
( [x,y] in it iff ex X being set st
( X in C & x in X & y in X ) );
existence
ex b1 being Tolerance of () st
for x, y being object holds
( [x,y] in b1 iff ex X being set st
( X in C & x in X & y in X ) )
proof end;
uniqueness
for b1, b2 being Tolerance of () st ( for x, y being object holds
( [x,y] in b1 iff ex X being set st
( X in C & x in X & y in X ) ) ) & ( for x, y being object holds
( [x,y] in b2 iff ex X being set st
( X in C & x in X & y in X ) ) ) holds
b1 = b2
by TOLER_1:25;
end;

:: deftheorem Def2 defines Web COH_SP:def 2 :
for C being Coherence_Space
for b2 being Tolerance of () holds
( b2 = Web C iff for x, y being object holds
( [x,y] in b2 iff ex X being set st
( X in C & x in X & y in X ) ) );

theorem Th5: :: COH_SP:5
for C being Coherence_Space
for T being Tolerance of () holds
( T = Web C iff for x, y being object holds
( [x,y] in T iff {x,y} in C ) )
proof end;

theorem Th6: :: COH_SP:6
for a being set
for C being Coherence_Space holds
( a in C iff for x, y being set st x in a & y in a holds
{x,y} in C )
proof end;

theorem Th7: :: COH_SP:7
for a being set
for C being Coherence_Space holds
( a in C iff for x, y being set st x in a & y in a holds
[x,y] in Web C )
proof end;

theorem :: COH_SP:8
for a being set
for C being Coherence_Space st ( for x, y being set st x in a & y in a holds
{x,y} in C ) holds
a c= union C
proof end;

theorem :: COH_SP:9
for C, D being Coherence_Space st Web C = Web D holds
C = D
proof end;

theorem :: COH_SP:10
for C being Coherence_Space st union C in C holds
C = bool ()
proof end;

theorem :: COH_SP:11
for C being Coherence_Space st C = bool () holds
Web C = Total ()
proof end;

definition
let X be set ;
let E be Tolerance of X;
func CohSp E -> Coherence_Space means :Def3: :: COH_SP:def 3
for a being set holds
( a in it iff for x, y being set st x in a & y in a holds
[x,y] in E );
existence
ex b1 being Coherence_Space st
for a being set holds
( a in b1 iff for x, y being set st x in a & y in a holds
[x,y] in E )
proof end;
uniqueness
for b1, b2 being Coherence_Space st ( for a being set holds
( a in b1 iff for x, y being set st x in a & y in a holds
[x,y] in E ) ) & ( for a being set holds
( a in b2 iff for x, y being set st x in a & y in a holds
[x,y] in E ) ) holds
b1 = b2
proof end;
end;

:: deftheorem Def3 defines CohSp COH_SP:def 3 :
for X being set
for E being Tolerance of X
for b3 being Coherence_Space holds
( b3 = CohSp E iff for a being set holds
( a in b3 iff for x, y being set st x in a & y in a holds
[x,y] in E ) );

theorem :: COH_SP:12
for X being set
for E being Tolerance of X holds Web () = E
proof end;

theorem :: COH_SP:13
for C being Coherence_Space holds CohSp (Web C) = C
proof end;

theorem Th14: :: COH_SP:14
for a, X being set
for E being Tolerance of X holds
( a in CohSp E iff a is TolSet of E )
proof end;

theorem :: COH_SP:15
for X being set
for E being Tolerance of X holds CohSp E = TolSets E
proof end;

definition
let X be set ;
func CSp X -> set equals :: COH_SP:def 4
{ x where x is Subset-Family of X : x is Coherence_Space } ;
coherence
{ x where x is Subset-Family of X : x is Coherence_Space } is set
;
end;

:: deftheorem defines CSp COH_SP:def 4 :
for X being set holds CSp X = { x where x is Subset-Family of X : x is Coherence_Space } ;

registration
let X be set ;
cluster CSp X -> non empty ;
coherence
not CSp X is empty
proof end;
end;

registration
let X be set ;
coherence
for b1 being Element of CSp X holds
( b1 is subset-closed & b1 is binary_complete & not b1 is empty )
proof end;
end;

theorem Th16: :: COH_SP:16
for x, y, X being set
for C being Element of CSp X st {x,y} in C holds
( x in union C & y in union C )
proof end;

definition
let X be set ;
func FuncsC X -> set equals :: COH_SP:def 5
union { (Funcs ((),())) where x, y is Element of CSp X : verum } ;
coherence
union { (Funcs ((),())) where x, y is Element of CSp X : verum } is set
;
end;

:: deftheorem defines FuncsC COH_SP:def 5 :
for X being set holds FuncsC X = union { (Funcs ((),())) where x, y is Element of CSp X : verum } ;

registration
let X be set ;
cluster FuncsC X -> functional non empty ;
coherence
( not FuncsC X is empty & FuncsC X is functional )
proof end;
end;

theorem Th17: :: COH_SP:17
for x, X being set holds
( x in FuncsC X iff ex C1, C2 being Element of CSp X st
( ( union C2 = {} implies union C1 = {} ) & x is Function of (union C1),(union C2) ) )
proof end;

definition
let X be set ;
func MapsC X -> set equals :: COH_SP:def 6
{ [[C,CC],f] where C, CC is Element of CSp X, f is Element of FuncsC X : ( ( union CC = {} implies union C = {} ) & f is Function of (),(union CC) & ( for x, y being set st {x,y} in C holds
{(f . x),(f . y)} in CC ) )
}
;
coherence
{ [[C,CC],f] where C, CC is Element of CSp X, f is Element of FuncsC X : ( ( union CC = {} implies union C = {} ) & f is Function of (),(union CC) & ( for x, y being set st {x,y} in C holds
{(f . x),(f . y)} in CC ) )
}
is set
;
end;

:: deftheorem defines MapsC COH_SP:def 6 :
for X being set holds MapsC X = { [[C,CC],f] where C, CC is Element of CSp X, f is Element of FuncsC X : ( ( union CC = {} implies union C = {} ) & f is Function of (),(union CC) & ( for x, y being set st {x,y} in C holds
{(f . x),(f . y)} in CC ) )
}
;

registration
let X be set ;
cluster MapsC X -> non empty ;
coherence
not MapsC X is empty
proof end;
end;

theorem Th18: :: COH_SP:18
for X being set
for l being Element of MapsC X ex g being Element of FuncsC X ex C1, C2 being Element of CSp X st
( l = [[C1,C2],g] & ( union C2 = {} implies union C1 = {} ) & g is Function of (union C1),(union C2) & ( for x, y being set st {x,y} in C1 holds
{(g . x),(g . y)} in C2 ) )
proof end;

theorem Th19: :: COH_SP:19
for X being set
for C1, C2 being Element of CSp X
for f being Function of (union C1),(union C2) st ( union C2 = {} implies union C1 = {} ) & ( for x, y being set st {x,y} in C1 holds
{(f . x),(f . y)} in C2 ) holds
[[C1,C2],f] in MapsC X
proof end;

registration
let X be set ;
let l be Element of MapsC X;
coherence
for b1 being set st b1 = l 2 holds
( b1 is Function-like & b1 is Relation-like )
proof end;
end;

definition
let X be set ;
let l be Element of MapsC X;
func dom l -> Element of CSp X equals :: COH_SP:def 7
(l 1) 1 ;
coherence
(l 1) 1 is Element of CSp X
proof end;
func cod l -> Element of CSp X equals :: COH_SP:def 8
(l 1) 2 ;
coherence
(l 1) 2 is Element of CSp X
proof end;
end;

:: deftheorem defines dom COH_SP:def 7 :
for X being set
for l being Element of MapsC X holds dom l = (l 1) 1 ;

:: deftheorem defines cod COH_SP:def 8 :
for X being set
for l being Element of MapsC X holds cod l = (l 1) 2 ;

theorem Th20: :: COH_SP:20
for X being set
for l being Element of MapsC X holds l = [[(dom l),(cod l)],(l 2)]
proof end;

Lm1: for X being set
for l, l1 being Element of MapsC X st l 2 = l1 2 & dom l = dom l1 & cod l = cod l1 holds
l = l1

proof end;

definition
let X be set ;
let C be Element of CSp X;
func id$C -> Element of MapsC X equals :: COH_SP:def 9 [[C,C],(id ())]; coherence [[C,C],(id ())] is Element of MapsC X proof end; end; :: deftheorem defines id$ COH_SP:def 9 :
for X being set
for C being Element of CSp X holds id$C = [[C,C],(id ())]; Lm2: for x1, y1, x2, y2, x3, y3 being set st [[x1,x2],x3] = [[y1,y2],y3] holds ( x1 = y1 & x2 = y2 ) proof end; theorem Th21: :: COH_SP:21 for X being set for l being Element of MapsC X holds ( ( union (cod l) <> {} or union (dom l) = {} ) & l 2 is Function of (union (dom l)),(union (cod l)) & ( for x, y being set st {x,y} in dom l holds {((l 2) . x),((l 2) . y)} in cod l ) ) proof end; definition let X be set ; let l1, l2 be Element of MapsC X; assume A1: cod l1 = dom l2 ; func l2 * l1 -> Element of MapsC X equals :Def10: :: COH_SP:def 10 [[(dom l1),(cod l2)],((l2 2) * (l1 2))]; coherence [[(dom l1),(cod l2)],((l2 2) * (l1 2))] is Element of MapsC X proof end; end; :: deftheorem Def10 defines * COH_SP:def 10 : for X being set for l1, l2 being Element of MapsC X st cod l1 = dom l2 holds l2 * l1 = [[(dom l1),(cod l2)],((l2 2) * (l1 2))]; theorem Th22: :: COH_SP:22 for X being set for l1, l2 being Element of MapsC X st dom l2 = cod l1 holds ( (l2 * l1) 2 = (l2 2) * (l1 2) & dom (l2 * l1) = dom l1 & cod (l2 * l1) = cod l2 ) proof end; theorem Th23: :: COH_SP:23 for X being set for l1, l2, l3 being Element of MapsC X st dom l2 = cod l1 & dom l3 = cod l2 holds l3 * (l2 * l1) = (l3 * l2) * l1 proof end; theorem :: COH_SP:24 for X being set for C being Element of CSp X holds ( (id$ C) 2 = id () & dom (id$C) = C & cod (id$ C) = C ) ;

theorem Th25: :: COH_SP:25
for X being set
for l being Element of MapsC X holds
( l * (id$(dom l)) = l & (id$ (cod l)) * l = l )
proof end;

definition
let X be set ;
func CDom X -> Function of (),(CSp X) means :Def11: :: COH_SP:def 11
for l being Element of MapsC X holds it . l = dom l;
existence
ex b1 being Function of (),(CSp X) st
for l being Element of MapsC X holds b1 . l = dom l
proof end;
uniqueness
for b1, b2 being Function of (),(CSp X) st ( for l being Element of MapsC X holds b1 . l = dom l ) & ( for l being Element of MapsC X holds b2 . l = dom l ) holds
b1 = b2
proof end;
func CCod X -> Function of (),(CSp X) means :Def12: :: COH_SP:def 12
for l being Element of MapsC X holds it . l = cod l;
existence
ex b1 being Function of (),(CSp X) st
for l being Element of MapsC X holds b1 . l = cod l
proof end;
uniqueness
for b1, b2 being Function of (),(CSp X) st ( for l being Element of MapsC X holds b1 . l = cod l ) & ( for l being Element of MapsC X holds b2 . l = cod l ) holds
b1 = b2
proof end;
func CComp X -> PartFunc of [:(),():],() means :Def13: :: COH_SP:def 13
( ( for l2, l1 being Element of MapsC X holds
( [l2,l1] in dom it iff dom l2 = cod l1 ) ) & ( for l2, l1 being Element of MapsC X st dom l2 = cod l1 holds
it . [l2,l1] = l2 * l1 ) );
existence
ex b1 being PartFunc of [:(),():],() st
( ( for l2, l1 being Element of MapsC X holds
( [l2,l1] in dom b1 iff dom l2 = cod l1 ) ) & ( for l2, l1 being Element of MapsC X st dom l2 = cod l1 holds
b1 . [l2,l1] = l2 * l1 ) )
proof end;
uniqueness
for b1, b2 being PartFunc of [:(),():],() st ( for l2, l1 being Element of MapsC X holds
( [l2,l1] in dom b1 iff dom l2 = cod l1 ) ) & ( for l2, l1 being Element of MapsC X st dom l2 = cod l1 holds
b1 . [l2,l1] = l2 * l1 ) & ( for l2, l1 being Element of MapsC X holds
( [l2,l1] in dom b2 iff dom l2 = cod l1 ) ) & ( for l2, l1 being Element of MapsC X st dom l2 = cod l1 holds
b2 . [l2,l1] = l2 * l1 ) holds
b1 = b2
proof end;
end;

:: deftheorem Def11 defines CDom COH_SP:def 11 :
for X being set
for b2 being Function of (),(CSp X) holds
( b2 = CDom X iff for l being Element of MapsC X holds b2 . l = dom l );

:: deftheorem Def12 defines CCod COH_SP:def 12 :
for X being set
for b2 being Function of (),(CSp X) holds
( b2 = CCod X iff for l being Element of MapsC X holds b2 . l = cod l );

:: deftheorem Def13 defines CComp COH_SP:def 13 :
for X being set
for b2 being PartFunc of [:(),():],() holds
( b2 = CComp X iff ( ( for l2, l1 being Element of MapsC X holds
( [l2,l1] in dom b2 iff dom l2 = cod l1 ) ) & ( for l2, l1 being Element of MapsC X st dom l2 = cod l1 holds
b2 . [l2,l1] = l2 * l1 ) ) );

theorem :: COH_SP:26
canceled;

::$CT definition let X be set ; func CohCat X -> non empty non void strict CatStr equals :: COH_SP:def 15 CatStr(# (CSp X),(),(CDom X),(CCod X),() #); coherence CatStr(# (CSp X),(),(CDom X),(CCod X),() #) is non empty non void strict CatStr ; end; :: deftheorem COH_SP:def 14 : canceled; :: deftheorem defines CohCat COH_SP:def 15 : for X being set holds CohCat X = CatStr(# (CSp X),(),(CDom X),(CCod X),() #); registration let X be set ; coherence ( CohCat X is Category-like & CohCat X is transitive & CohCat X is associative & CohCat X is reflexive ) proof end; end; Lm3: for X being set for a being Element of () for aa being Element of CSp X st a = aa holds for i being Morphism of a,a st i = id$ aa holds
for b being Element of () holds
( ( Hom (a,b) <> {} implies for g being Morphism of a,b holds g (*) i = g ) & ( Hom (b,a) <> {} implies for f being Morphism of b,a holds i (*) f = f ) )

proof end;

registration
let X be set ;
coherence
proof end;
end;

definition
let X be set ;
func Toler X -> set means :Def15: :: COH_SP:def 16
for x being set holds
( x in it iff x is Tolerance of X );
existence
ex b1 being set st
for x being set holds
( x in b1 iff x is Tolerance of X )
proof end;
uniqueness
for b1, b2 being set st ( for x being set holds
( x in b1 iff x is Tolerance of X ) ) & ( for x being set holds
( x in b2 iff x is Tolerance of X ) ) holds
b1 = b2
proof end;
end;

:: deftheorem Def15 defines Toler COH_SP:def 16 :
for X, b2 being set holds
( b2 = Toler X iff for x being set holds
( x in b2 iff x is Tolerance of X ) );

registration
let X be set ;
cluster Toler X -> non empty ;
coherence
not Toler X is empty
proof end;
end;

definition
let X be set ;
func Toler_on_subsets X -> set equals :: COH_SP:def 17
union { () where Y is Subset of X : verum } ;
coherence
union { () where Y is Subset of X : verum } is set
;
end;

:: deftheorem defines Toler_on_subsets COH_SP:def 17 :
for X being set holds Toler_on_subsets X = union { () where Y is Subset of X : verum } ;

registration
let X be set ;
cluster Toler_on_subsets X -> non empty ;
coherence
not Toler_on_subsets X is empty
proof end;
end;

theorem :: COH_SP:27
for x, X being set holds
( x in Toler_on_subsets X iff ex A being set st
( A c= X & x is Tolerance of A ) )
proof end;

theorem :: COH_SP:28
for a being set holds Total a in Toler a by Def15;

theorem Th28: :: COH_SP:29
for X being set holds {} in Toler_on_subsets X
proof end;

theorem Th29: :: COH_SP:30
for a, X being set st a c= X holds
Total a in Toler_on_subsets X
proof end;

theorem Th30: :: COH_SP:31
for a, X being set st a c= X holds
id a in Toler_on_subsets X
proof end;

theorem :: COH_SP:32
for X being set holds Total X in Toler_on_subsets X by Th29;

theorem :: COH_SP:33
for X being set holds id X in Toler_on_subsets X by Th30;

definition
let X be set ;
func TOL X -> set equals :: COH_SP:def 18
{ [t,Y] where t is Element of Toler_on_subsets X, Y is Subset of X : t is Tolerance of Y } ;
coherence
{ [t,Y] where t is Element of Toler_on_subsets X, Y is Subset of X : t is Tolerance of Y } is set
;
end;

:: deftheorem defines TOL COH_SP:def 18 :
for X being set holds TOL X = { [t,Y] where t is Element of Toler_on_subsets X, Y is Subset of X : t is Tolerance of Y } ;

registration
let X be set ;
cluster TOL X -> non empty ;
coherence
not TOL X is empty
proof end;
end;

theorem :: COH_SP:34
for X being set holds in TOL X
proof end;

theorem Th34: :: COH_SP:35
for a, X being set st a c= X holds
[(id a),a] in TOL X
proof end;

theorem Th35: :: COH_SP:36
for a, X being set st a c= X holds
[(),a] in TOL X
proof end;

theorem :: COH_SP:37
for X being set holds [(id X),X] in TOL X by Th34;

theorem :: COH_SP:38
for X being set holds [(),X] in TOL X by Th35;

definition
let X be set ;
let T be Element of TOL X;
:: original: 2
redefine func T 2 -> Subset of X;
coherence
T 2 is Subset of X
proof end;
:: original: 1
redefine func T 1 -> Tolerance of (T 2);
coherence
T 1 is Tolerance of (T 2)
proof end;
end;

definition
let X be set ;
func FuncsT X -> set equals :: COH_SP:def 19
union { (Funcs ((T 2),(TT 2))) where T, TT is Element of TOL X : verum } ;
coherence
union { (Funcs ((T 2),(TT 2))) where T, TT is Element of TOL X : verum } is set
;
end;

:: deftheorem defines FuncsT COH_SP:def 19 :
for X being set holds FuncsT X = union { (Funcs ((T 2),(TT 2))) where T, TT is Element of TOL X : verum } ;

registration
let X be set ;
cluster FuncsT X -> functional non empty ;
coherence
( not FuncsT X is empty & FuncsT X is functional )
proof end;
end;

theorem Th38: :: COH_SP:39
for x, X being set holds
( x in FuncsT X iff ex T1, T2 being Element of TOL X st
( ( T2 2 = {} implies T1 2 = {} ) & x is Function of (T1 2),(T2 2) ) )
proof end;

definition
let X be set ;
func MapsT X -> set equals :: COH_SP:def 20
{ [[T,TT],f] where T, TT is Element of TOL X, f is Element of FuncsT X : ( ( TT 2 = {} implies T 2 = {} ) & f is Function of (T 2),(TT 2) & ( for x, y being set st [x,y] in T 1 holds
[(f . x),(f . y)] in TT 1 ) )
}
;
coherence
{ [[T,TT],f] where T, TT is Element of TOL X, f is Element of FuncsT X : ( ( TT 2 = {} implies T 2 = {} ) & f is Function of (T 2),(TT 2) & ( for x, y being set st [x,y] in T 1 holds
[(f . x),(f . y)] in TT 1 ) )
}
is set
;
end;

:: deftheorem defines MapsT COH_SP:def 20 :
for X being set holds MapsT X = { [[T,TT],f] where T, TT is Element of TOL X, f is Element of FuncsT X : ( ( TT 2 = {} implies T 2 = {} ) & f is Function of (T 2),(TT 2) & ( for x, y being set st [x,y] in T 1 holds
[(f . x),(f . y)] in TT 1 ) )
}
;

registration
let X be set ;
cluster MapsT X -> non empty ;
coherence
not MapsT X is empty
proof end;
end;

theorem Th39: :: COH_SP:40
for X being set
for m being Element of MapsT X ex f being Element of FuncsT X ex T1, T2 being Element of TOL X st
( m = [[T1,T2],f] & ( T2 2 = {} implies T1 2 = {} ) & f is Function of (T1 2),(T2 2) & ( for x, y being set st [x,y] in T1 1 holds
[(f . x),(f . y)] in T2 1 ) )
proof end;

theorem Th40: :: COH_SP:41
for X being set
for T1, T2 being Element of TOL X
for f being Function of (T1 2),(T2 2) st ( T2 2 = {} implies T1 2 = {} ) & ( for x, y being set st [x,y] in T1 1 holds
[(f . x),(f . y)] in T2 1 ) holds
[[T1,T2],f] in MapsT X
proof end;

registration
let X be set ;
let m be Element of MapsT X;
coherence
for b1 being set st b1 = m 2 holds
( b1 is Function-like & b1 is Relation-like )
proof end;
end;

definition
let X be set ;
let m be Element of MapsT X;
func dom m -> Element of TOL X equals :: COH_SP:def 21
(m 1) 1 ;
coherence
(m 1) 1 is Element of TOL X
proof end;
func cod m -> Element of TOL X equals :: COH_SP:def 22
(m 1) 2 ;
coherence
(m 1) 2 is Element of TOL X
proof end;
end;

:: deftheorem defines dom COH_SP:def 21 :
for X being set
for m being Element of MapsT X holds dom m = (m 1) 1 ;

:: deftheorem defines cod COH_SP:def 22 :
for X being set
for m being Element of MapsT X holds cod m = (m 1) 2 ;

theorem Th41: :: COH_SP:42
for X being set
for m being Element of MapsT X holds m = [[(dom m),(cod m)],(m 2)]
proof end;

Lm4: for X being set
for m, m1 being Element of MapsT X st m 2 = m1 2 & dom m = dom m1 & cod m = cod m1 holds
m = m1

proof end;

definition
let X be set ;
let T be Element of TOL X;
func id$T -> Element of MapsT X equals :: COH_SP:def 23 [[T,T],(id (T 2))]; coherence [[T,T],(id (T 2))] is Element of MapsT X proof end; end; :: deftheorem defines id$ COH_SP:def 23 :
for X being set
for T being Element of TOL X holds id$T = [[T,T],(id (T 2))]; theorem Th42: :: COH_SP:43 for X being set for m being Element of MapsT X holds ( ( (cod m) 2 <> {} or (dom m) 2 = {} ) & m 2 is Function of ((dom m) 2),((cod m) 2) & ( for x, y being set st [x,y] in (dom m) 1 holds [((m 2) . x),((m 2) . y)] in (cod m) 1 ) ) proof end; definition let X be set ; let m1, m2 be Element of MapsT X; assume A1: cod m1 = dom m2 ; func m2 * m1 -> Element of MapsT X equals :Def23: :: COH_SP:def 24 [[(dom m1),(cod m2)],((m2 2) * (m1 2))]; coherence [[(dom m1),(cod m2)],((m2 2) * (m1 2))] is Element of MapsT X proof end; end; :: deftheorem Def23 defines * COH_SP:def 24 : for X being set for m1, m2 being Element of MapsT X st cod m1 = dom m2 holds m2 * m1 = [[(dom m1),(cod m2)],((m2 2) * (m1 2))]; theorem Th43: :: COH_SP:44 for X being set for m1, m2 being Element of MapsT X st dom m2 = cod m1 holds ( (m2 * m1) 2 = (m2 2) * (m1 2) & dom (m2 * m1) = dom m1 & cod (m2 * m1) = cod m2 ) proof end; theorem Th44: :: COH_SP:45 for X being set for m1, m2, m3 being Element of MapsT X st dom m2 = cod m1 & dom m3 = cod m2 holds m3 * (m2 * m1) = (m3 * m2) * m1 proof end; theorem :: COH_SP:46 for X being set for T being Element of TOL X holds ( (id$ T) 2 = id (T 2) & dom (id$T) = T & cod (id$ T) = T ) ;

theorem Th46: :: COH_SP:47
for X being set
for m being Element of MapsT X holds
( m * (id$(dom m)) = m & (id$ (cod m)) * m = m )
proof end;

definition
let X be set ;
func fDom X -> Function of (),(TOL X) means :Def24: :: COH_SP:def 25
for m being Element of MapsT X holds it . m = dom m;
existence
ex b1 being Function of (),(TOL X) st
for m being Element of MapsT X holds b1 . m = dom m
proof end;
uniqueness
for b1, b2 being Function of (),(TOL X) st ( for m being Element of MapsT X holds b1 . m = dom m ) & ( for m being Element of MapsT X holds b2 . m = dom m ) holds
b1 = b2
proof end;
func fCod X -> Function of (),(TOL X) means :Def25: :: COH_SP:def 26
for m being Element of MapsT X holds it . m = cod m;
existence
ex b1 being Function of (),(TOL X) st
for m being Element of MapsT X holds b1 . m = cod m
proof end;
uniqueness
for b1, b2 being Function of (),(TOL X) st ( for m being Element of MapsT X holds b1 . m = cod m ) & ( for m being Element of MapsT X holds b2 . m = cod m ) holds
b1 = b2
proof end;
func fComp X -> PartFunc of [:(),():],() means :Def26: :: COH_SP:def 27
( ( for m2, m1 being Element of MapsT X holds
( [m2,m1] in dom it iff dom m2 = cod m1 ) ) & ( for m2, m1 being Element of MapsT X st dom m2 = cod m1 holds
it . [m2,m1] = m2 * m1 ) );
existence
ex b1 being PartFunc of [:(),():],() st
( ( for m2, m1 being Element of MapsT X holds
( [m2,m1] in dom b1 iff dom m2 = cod m1 ) ) & ( for m2, m1 being Element of MapsT X st dom m2 = cod m1 holds
b1 . [m2,m1] = m2 * m1 ) )
proof end;
uniqueness
for b1, b2 being PartFunc of [:(),():],() st ( for m2, m1 being Element of MapsT X holds
( [m2,m1] in dom b1 iff dom m2 = cod m1 ) ) & ( for m2, m1 being Element of MapsT X st dom m2 = cod m1 holds
b1 . [m2,m1] = m2 * m1 ) & ( for m2, m1 being Element of MapsT X holds
( [m2,m1] in dom b2 iff dom m2 = cod m1 ) ) & ( for m2, m1 being Element of MapsT X st dom m2 = cod m1 holds
b2 . [m2,m1] = m2 * m1 ) holds
b1 = b2
proof end;
end;

:: deftheorem Def24 defines fDom COH_SP:def 25 :
for X being set
for b2 being Function of (),(TOL X) holds
( b2 = fDom X iff for m being Element of MapsT X holds b2 . m = dom m );

:: deftheorem Def25 defines fCod COH_SP:def 26 :
for X being set
for b2 being Function of (),(TOL X) holds
( b2 = fCod X iff for m being Element of MapsT X holds b2 . m = cod m );

:: deftheorem Def26 defines fComp COH_SP:def 27 :
for X being set
for b2 being PartFunc of [:(),():],() holds
( b2 = fComp X iff ( ( for m2, m1 being Element of MapsT X holds
( [m2,m1] in dom b2 iff dom m2 = cod m1 ) ) & ( for m2, m1 being Element of MapsT X st dom m2 = cod m1 holds
b2 . [m2,m1] = m2 * m1 ) ) );

definition
let X be set ;
func TolCat X -> non empty non void strict CatStr equals :: COH_SP:def 29
CatStr(# (TOL X),(),(fDom X),(fCod X),() #);
coherence
CatStr(# (TOL X),(),(fDom X),(fCod X),() #) is non empty non void strict CatStr
;
end;

:: deftheorem COH_SP:def 28 :
canceled;

:: deftheorem defines TolCat COH_SP:def 29 :
for X being set holds TolCat X = CatStr(# (TOL X),(),(fDom X),(fCod X),() #);

registration
let X be set ;
coherence
( TolCat X is Category-like & TolCat X is transitive & TolCat X is associative & TolCat X is reflexive )
proof end;
end;

Lm5: for X being set
for a being Element of ()
for aa being Element of TOL X st a = aa holds
for i being Morphism of a,a st i = id\$ aa holds
for b being Element of () holds
( ( Hom (a,b) <> {} implies for g being Morphism of a,b holds g (*) i = g ) & ( Hom (b,a) <> {} implies for f being Morphism of b,a holds i (*) f = f ) )

proof end;

registration
let X be set ;
coherence
proof end;
end;