Article COH_SP, MML version 4.99.1005

:: COH_SP:attrnot 1 => COH_SP:attr 1
definition
  let a1 be set;
  attr a1 is binary_complete means
    for b1 being set
          st b1 c= a1 &
             (for b2, b3 being set
                   st b2 in b1 & b3 in b1
                holds b2 \/ b3 in a1)
       holds union b1 in a1;
end;

:: COH_SP:dfs 1
definiens
  let a1 be set;
To prove
     a1 is binary_complete
it is sufficient to prove
  thus for b1 being set
          st b1 c= a1 &
             (for b2, b3 being set
                   st b2 in b1 & b3 in b1
                holds b2 \/ b3 in a1)
       holds union b1 in a1;

:: COH_SP:def 2
theorem
for b1 being set holds
      b1 is binary_complete
   iff
      for b2 being set
            st b2 c= b1 &
               (for b3, b4 being set
                     st b3 in b2 & b4 in b2
                  holds b3 \/ b4 in b1)
         holds union b2 in b1;

:: COH_SP:exreg 1
registration
  cluster non empty subset-closed binary_complete set;
end;

:: COH_SP:modenot 1
definition
  mode Coherence_Space is non empty subset-closed binary_complete set;
end;

:: COH_SP:th 1
theorem
for b1 being non empty subset-closed binary_complete set holds
   {} in b1;

:: COH_SP:th 2
theorem
for b1 being set holds
   bool b1 is non empty subset-closed binary_complete set;

:: COH_SP:th 3
theorem
{{}} is non empty subset-closed binary_complete set;

:: COH_SP:th 4
theorem
for b1 being set
for b2 being non empty subset-closed binary_complete set
      st b1 in union b2
   holds {b1} in b2;

:: COH_SP:funcnot 1 => COH_SP:func 1
definition
  let a1 be non empty subset-closed binary_complete set;
  func Web A1 -> reflexive symmetric total Relation of union a1,union a1 means
    for b1, b2 being set holds
       [b1,b2] in it
    iff
       ex b3 being set st
          b3 in a1 & b1 in b3 & b2 in b3;
end;

:: COH_SP:def 3
theorem
for b1 being non empty subset-closed binary_complete set
for b2 being reflexive symmetric total Relation of union b1,union b1 holds
      b2 = Web b1
   iff
      for b3, b4 being set holds
         [b3,b4] in b2
      iff
         ex b5 being set st
            b5 in b1 & b3 in b5 & b4 in b5;

:: COH_SP:th 5
theorem
for b1 being non empty subset-closed binary_complete set
for b2 being reflexive symmetric total Relation of union b1,union b1 holds
      b2 = Web b1
   iff
      for b3, b4 being set holds
         [b3,b4] in b2
      iff
         {b3,b4} in b1;

:: COH_SP:th 6
theorem
for b1 being set
for b2 being non empty subset-closed binary_complete set holds
      b1 in b2
   iff
      for b3, b4 being set
            st b3 in b1 & b4 in b1
         holds {b3,b4} in b2;

:: COH_SP:th 7
theorem
for b1 being set
for b2 being non empty subset-closed binary_complete set holds
      b1 in b2
   iff
      for b3, b4 being set
            st b3 in b1 & b4 in b1
         holds [b3,b4] in Web b2;

:: COH_SP:th 8
theorem
for b1 being set
for b2 being non empty subset-closed binary_complete set
      st for b3, b4 being set
              st b3 in b1 & b4 in b1
           holds {b3,b4} in b2
   holds b1 c= union b2;

:: COH_SP:th 9
theorem
for b1, b2 being non empty subset-closed binary_complete set
      st Web b1 = Web b2
   holds b1 = b2;

:: COH_SP:th 10
theorem
for b1 being non empty subset-closed binary_complete set
      st union b1 in b1
   holds b1 = bool union b1;

:: COH_SP:th 11
theorem
for b1 being non empty subset-closed binary_complete set
      st b1 = bool union b1
   holds Web b1 = nabla union b1;

:: COH_SP:funcnot 2 => COH_SP:func 2
definition
  let a1 be set;
  let a2 be reflexive symmetric total Relation of a1,a1;
  func CohSp A2 -> non empty subset-closed binary_complete set means
    for b1 being set holds
          b1 in it
       iff
          for b2, b3 being set
                st b2 in b1 & b3 in b1
             holds [b2,b3] in a2;
end;

:: COH_SP:def 4
theorem
for b1 being set
for b2 being reflexive symmetric total Relation of b1,b1
for b3 being non empty subset-closed binary_complete set holds
      b3 = CohSp b2
   iff
      for b4 being set holds
            b4 in b3
         iff
            for b5, b6 being set
                  st b5 in b4 & b6 in b4
               holds [b5,b6] in b2;

:: COH_SP:th 12
theorem
for b1 being set
for b2 being reflexive symmetric total Relation of b1,b1 holds
   Web CohSp b2 = b2;

:: COH_SP:th 13
theorem
for b1 being non empty subset-closed binary_complete set holds
   CohSp Web b1 = b1;

:: COH_SP:th 14
theorem
for b1, b2 being set
for b3 being reflexive symmetric total Relation of b1,b1 holds
      b2 in CohSp b3
   iff
      b2 is TolSet of b3;

:: COH_SP:th 15
theorem
for b1 being set
for b2 being reflexive symmetric total Relation of b1,b1 holds
   CohSp b2 = TolSets b2;

:: COH_SP:funcnot 3 => COH_SP:func 3
definition
  let a1 be set;
  func CSp A1 -> set equals
    {b1 where b1 is Element of bool bool a1: b1 is non empty subset-closed binary_complete set};
end;

:: COH_SP:def 5
theorem
for b1 being set holds
   CSp b1 = {b2 where b2 is Element of bool bool b1: b2 is non empty subset-closed binary_complete set};

:: COH_SP:funcreg 1
registration
  let a1 be set;
  cluster CSp a1 -> non empty;
end;

:: COH_SP:condreg 1
registration
  let a1 be set;
  cluster -> non empty subset-closed binary_complete (Element of CSp a1);
end;

:: COH_SP:th 16
theorem
for b1, b2, b3 being set
for b4 being Element of CSp b1
      st {b2,b3} in b4
   holds b2 in union b4 & b3 in union b4;

:: COH_SP:funcnot 4 => COH_SP:func 4
definition
  let a1 be set;
  func FuncsC A1 -> set equals
    union {Funcs(union b1,union b2) where b1 is Element of CSp a1, b2 is Element of CSp a1: TRUE};
end;

:: COH_SP:def 7
theorem
for b1 being set holds
   FuncsC b1 = union {Funcs(union b2,union b3) where b2 is Element of CSp b1, b3 is Element of CSp b1: TRUE};

:: COH_SP:funcreg 2
registration
  let a1 be set;
  cluster FuncsC a1 -> non empty functional;
end;

:: COH_SP:th 17
theorem
for b1, b2 being set holds
   b1 in FuncsC b2
iff
   ex b3, b4 being Element of CSp b2 st
      (union b4 = {} implies union b3 = {}) &
       b1 is Function-like quasi_total Relation of union b3,union b4;

:: COH_SP:funcnot 5 => COH_SP:func 5
definition
  let a1 be set;
  func MapsC A1 -> set equals
    {[[b1,b2],b3] where b1 is Element of CSp a1, b2 is Element of CSp a1, b3 is Element of FuncsC a1: (union b2 = {} implies union b1 = {}) &
     b3 is Function-like quasi_total Relation of union b1,union b2 &
     (for b4, b5 being set
           st {b4,b5} in b1
        holds {b3 . b4,b3 . b5} in b2)};
end;

:: COH_SP:def 8
theorem
for b1 being set holds
   MapsC b1 = {[[b2,b3],b4] where b2 is Element of CSp b1, b3 is Element of CSp b1, b4 is Element of FuncsC b1: (union b3 = {} implies union b2 = {}) &
    b4 is Function-like quasi_total Relation of union b2,union b3 &
    (for b5, b6 being set
          st {b5,b6} in b2
       holds {b4 . b5,b4 . b6} in b3)};

:: COH_SP:funcreg 3
registration
  let a1 be set;
  cluster MapsC a1 -> non empty;
end;

:: COH_SP:th 18
theorem
for b1 being set
for b2 being Element of MapsC b1 holds
   ex b3 being Element of FuncsC b1 st
      ex b4, b5 being Element of CSp b1 st
         b2 = [[b4,b5],b3] &
          (union b5 = {} implies union b4 = {}) &
          b3 is Function-like quasi_total Relation of union b4,union b5 &
          (for b6, b7 being set
                st {b6,b7} in b4
             holds {b3 . b6,b3 . b7} in b5);

:: COH_SP:th 19
theorem
for b1 being set
for b2, b3 being Element of CSp b1
for b4 being Function-like quasi_total Relation of union b2,union b3
      st (union b3 = {} implies union b2 = {}) &
         (for b5, b6 being set
               st {b5,b6} in b2
            holds {b4 . b5,b4 . b6} in b3)
   holds [[b2,b3],b4] in MapsC b1;

:: COH_SP:funcreg 4
registration
  let a1 be set;
  let a2 be Element of MapsC a1;
  cluster a2 `2 -> Relation-like Function-like;
end;

:: COH_SP:funcnot 6 => COH_SP:func 6
definition
  let a1 be set;
  let a2 be Element of MapsC a1;
  func dom A2 -> Element of CSp a1 equals
    a2 `1 `1;
end;

:: COH_SP:def 10
theorem
for b1 being set
for b2 being Element of MapsC b1 holds
   dom b2 = b2 `1 `1;

:: COH_SP:funcnot 7 => COH_SP:func 7
definition
  let a1 be set;
  let a2 be Element of MapsC a1;
  func cod A2 -> Element of CSp a1 equals
    a2 `1 `2;
end;

:: COH_SP:def 11
theorem
for b1 being set
for b2 being Element of MapsC b1 holds
   cod b2 = b2 `1 `2;

:: COH_SP:th 20
theorem
for b1 being set
for b2 being Element of MapsC b1 holds
   b2 = [[dom b2,cod b2],b2 `2];

:: COH_SP:funcnot 8 => COH_SP:func 8
definition
  let a1 be set;
  let a2 be Element of CSp a1;
  func id$ A2 -> Element of MapsC a1 equals
    [[a2,a2],id union a2];
end;

:: COH_SP:def 12
theorem
for b1 being set
for b2 being Element of CSp b1 holds
   id$ b2 = [[b2,b2],id union b2];

:: COH_SP:th 21
theorem
for b1 being set
for b2 being Element of MapsC b1 holds
   (union cod b2 = {} implies union dom b2 = {}) &
    b2 `2 is Function-like quasi_total Relation of union dom b2,union cod b2 &
    (for b3, b4 being set
          st {b3,b4} in dom b2
       holds {b2 `2 . b3,b2 `2 . b4} in cod b2);

:: COH_SP:funcnot 9 => COH_SP:func 9
definition
  let a1 be set;
  let a2, a3 be Element of MapsC a1;
  assume cod a2 = dom a3;
  func A3 * A2 -> Element of MapsC a1 equals
    [[dom a2,cod a3],a2 `2 * (a3 `2)];
end;

:: COH_SP:def 13
theorem
for b1 being set
for b2, b3 being Element of MapsC b1
      st cod b2 = dom b3
   holds b3 * b2 = [[dom b2,cod b3],b2 `2 * (b3 `2)];

:: COH_SP:th 22
theorem
for b1 being set
for b2, b3 being Element of MapsC b1
      st dom b2 = cod b3
   holds (b2 * b3) `2 = b3 `2 * (b2 `2) &
    dom (b2 * b3) = dom b3 &
    cod (b2 * b3) = cod b2;

:: COH_SP:th 23
theorem
for b1 being set
for b2, b3, b4 being Element of MapsC b1
      st dom b2 = cod b3 & dom b4 = cod b2
   holds b4 * (b2 * b3) = (b4 * b2) * b3;

:: COH_SP:th 24
theorem
for b1 being set
for b2 being Element of CSp b1 holds
   (id$ b2) `2 = id union b2 & dom id$ b2 = b2 & cod id$ b2 = b2;

:: COH_SP:th 25
theorem
for b1 being set
for b2 being Element of MapsC b1 holds
   b2 * id$ dom b2 = b2 & (id$ cod b2) * b2 = b2;

:: COH_SP:funcnot 10 => COH_SP:func 10
definition
  let a1 be set;
  func CDom A1 -> Function-like quasi_total Relation of MapsC a1,CSp a1 means
    for b1 being Element of MapsC a1 holds
       it . b1 = dom b1;
end;

:: COH_SP:def 14
theorem
for b1 being set
for b2 being Function-like quasi_total Relation of MapsC b1,CSp b1 holds
      b2 = CDom b1
   iff
      for b3 being Element of MapsC b1 holds
         b2 . b3 = dom b3;

:: COH_SP:funcnot 11 => COH_SP:func 11
definition
  let a1 be set;
  func CCod A1 -> Function-like quasi_total Relation of MapsC a1,CSp a1 means
    for b1 being Element of MapsC a1 holds
       it . b1 = cod b1;
end;

:: COH_SP:def 15
theorem
for b1 being set
for b2 being Function-like quasi_total Relation of MapsC b1,CSp b1 holds
      b2 = CCod b1
   iff
      for b3 being Element of MapsC b1 holds
         b2 . b3 = cod b3;

:: COH_SP:funcnot 12 => COH_SP:func 12
definition
  let a1 be set;
  func CComp A1 -> Function-like Relation of [:MapsC a1,MapsC a1:],MapsC a1 means
    (for b1, b2 being Element of MapsC a1 holds
        [b1,b2] in dom it
     iff
        dom b1 = cod b2) &
     (for b1, b2 being Element of MapsC a1
           st dom b1 = cod b2
        holds it . [b1,b2] = b1 * b2);
end;

:: COH_SP:def 16
theorem
for b1 being set
for b2 being Function-like Relation of [:MapsC b1,MapsC b1:],MapsC b1 holds
      b2 = CComp b1
   iff
      (for b3, b4 being Element of MapsC b1 holds
          [b3,b4] in dom b2
       iff
          dom b3 = cod b4) &
       (for b3, b4 being Element of MapsC b1
             st dom b3 = cod b4
          holds b2 . [b3,b4] = b3 * b4);

:: COH_SP:funcnot 13 => COH_SP:func 13
definition
  let a1 be set;
  func CId A1 -> Function-like quasi_total Relation of CSp a1,MapsC a1 means
    for b1 being Element of CSp a1 holds
       it . b1 = id$ b1;
end;

:: COH_SP:def 17
theorem
for b1 being set
for b2 being Function-like quasi_total Relation of CSp b1,MapsC b1 holds
      b2 = CId b1
   iff
      for b3 being Element of CSp b1 holds
         b2 . b3 = id$ b3;

:: COH_SP:th 26
theorem
for b1 being set holds
   CatStr(#CSp b1,MapsC b1,CDom b1,CCod b1,CComp b1,CId b1#) is non void Category-like CatStr;

:: COH_SP:funcnot 14 => COH_SP:func 14
definition
  let a1 be set;
  func CohCat A1 -> non void Category-like CatStr equals
    CatStr(#CSp a1,MapsC a1,CDom a1,CCod a1,CComp a1,CId a1#);
end;

:: COH_SP:def 18
theorem
for b1 being set holds
   CohCat b1 = CatStr(#CSp b1,MapsC b1,CDom b1,CCod b1,CComp b1,CId b1#);

:: COH_SP:funcnot 15 => COH_SP:func 15
definition
  let a1 be set;
  func Toler A1 -> set means
    for b1 being set holds
          b1 in it
       iff
          b1 is reflexive symmetric total Relation of a1,a1;
end;

:: COH_SP:def 19
theorem
for b1, b2 being set holds
   b2 = Toler b1
iff
   for b3 being set holds
         b3 in b2
      iff
         b3 is reflexive symmetric total Relation of b1,b1;

:: COH_SP:funcreg 5
registration
  let a1 be set;
  cluster Toler a1 -> non empty;
end;

:: COH_SP:funcnot 16 => COH_SP:func 16
definition
  let a1 be set;
  func Toler_on_subsets A1 -> set equals
    union {Toler b1 where b1 is Element of bool a1: TRUE};
end;

:: COH_SP:def 20
theorem
for b1 being set holds
   Toler_on_subsets b1 = union {Toler b2 where b2 is Element of bool b1: TRUE};

:: COH_SP:funcreg 6
registration
  let a1 be set;
  cluster Toler_on_subsets a1 -> non empty;
end;

:: COH_SP:th 27
theorem
for b1, b2 being set holds
   b1 in Toler_on_subsets b2
iff
   ex b3 being set st
      b3 c= b2 & b1 is reflexive symmetric total Relation of b3,b3;

:: COH_SP:th 28
theorem
for b1 being set holds
   nabla b1 in Toler b1;

:: COH_SP:th 30
theorem
for b1 being set holds
   {} in Toler_on_subsets b1;

:: COH_SP:th 31
theorem
for b1, b2 being set
      st b1 c= b2
   holds nabla b1 in Toler_on_subsets b2;

:: COH_SP:th 32
theorem
for b1, b2 being set
      st b1 c= b2
   holds id b1 in Toler_on_subsets b2;

:: COH_SP:th 33
theorem
for b1 being set holds
   nabla b1 in Toler_on_subsets b1;

:: COH_SP:th 34
theorem
for b1 being set holds
   id b1 in Toler_on_subsets b1;

:: COH_SP:funcnot 17 => COH_SP:func 17
definition
  let a1 be set;
  func TOL A1 -> set equals
    {[b1,b2] where b1 is Element of Toler_on_subsets a1, b2 is Element of bool a1: b1 is reflexive symmetric total Relation of b2,b2};
end;

:: COH_SP:def 21
theorem
for b1 being set holds
   TOL b1 = {[b2,b3] where b2 is Element of Toler_on_subsets b1, b3 is Element of bool b1: b2 is reflexive symmetric total Relation of b3,b3};

:: COH_SP:funcreg 7
registration
  let a1 be set;
  cluster TOL a1 -> non empty;
end;

:: COH_SP:th 35
theorem
for b1 being set holds
   [{},{}] in TOL b1;

:: COH_SP:th 36
theorem
for b1, b2 being set
      st b1 c= b2
   holds [id b1,b1] in TOL b2;

:: COH_SP:th 37
theorem
for b1, b2 being set
      st b1 c= b2
   holds [nabla b1,b1] in TOL b2;

:: COH_SP:th 38
theorem
for b1 being set holds
   [id b1,b1] in TOL b1;

:: COH_SP:th 39
theorem
for b1 being set holds
   [nabla b1,b1] in TOL b1;

:: COH_SP:funcnot 18 => COH_SP:func 18
definition
  let a1 be set;
  let a2 be Element of TOL a1;
  redefine func a2 `2 -> Element of bool a1;
end;

:: COH_SP:funcnot 19 => COH_SP:func 19
definition
  let a1 be set;
  let a2 be Element of TOL a1;
  redefine func a2 `1 -> reflexive symmetric total Relation of a2 `2,a2 `2;
end;

:: COH_SP:funcnot 20 => COH_SP:func 20
definition
  let a1 be set;
  func FuncsT A1 -> set equals
    union {Funcs(b1 `2,b2 `2) where b1 is Element of TOL a1, b2 is Element of TOL a1: TRUE};
end;

:: COH_SP:def 22
theorem
for b1 being set holds
   FuncsT b1 = union {Funcs(b2 `2,b3 `2) where b2 is Element of TOL b1, b3 is Element of TOL b1: TRUE};

:: COH_SP:funcreg 8
registration
  let a1 be set;
  cluster FuncsT a1 -> non empty functional;
end;

:: COH_SP:th 40
theorem
for b1, b2 being set holds
   b1 in FuncsT b2
iff
   ex b3, b4 being Element of TOL b2 st
      (b4 `2 = {} implies b3 `2 = {}) &
       b1 is Function-like quasi_total Relation of b3 `2,b4 `2;

:: COH_SP:funcnot 21 => COH_SP:func 21
definition
  let a1 be set;
  func MapsT A1 -> set equals
    {[[b1,b2],b3] where b1 is Element of TOL a1, b2 is Element of TOL a1, b3 is Element of FuncsT a1: (b2 `2 = {} implies b1 `2 = {}) &
     b3 is Function-like quasi_total Relation of b1 `2,b2 `2 &
     (for b4, b5 being set
           st [b4,b5] in b1 `1
        holds [b3 . b4,b3 . b5] in b2 `1)};
end;

:: COH_SP:def 23
theorem
for b1 being set holds
   MapsT b1 = {[[b2,b3],b4] where b2 is Element of TOL b1, b3 is Element of TOL b1, b4 is Element of FuncsT b1: (b3 `2 = {} implies b2 `2 = {}) &
    b4 is Function-like quasi_total Relation of b2 `2,b3 `2 &
    (for b5, b6 being set
          st [b5,b6] in b2 `1
       holds [b4 . b5,b4 . b6] in b3 `1)};

:: COH_SP:funcreg 9
registration
  let a1 be set;
  cluster MapsT a1 -> non empty;
end;

:: COH_SP:th 41
theorem
for b1 being set
for b2 being Element of MapsT b1 holds
   ex b3 being Element of FuncsT b1 st
      ex b4, b5 being Element of TOL b1 st
         b2 = [[b4,b5],b3] &
          (b5 `2 = {} implies b4 `2 = {}) &
          b3 is Function-like quasi_total Relation of b4 `2,b5 `2 &
          (for b6, b7 being set
                st [b6,b7] in b4 `1
             holds [b3 . b6,b3 . b7] in b5 `1);

:: COH_SP:th 42
theorem
for b1 being set
for b2, b3 being Element of TOL b1
for b4 being Function-like quasi_total Relation of b2 `2,b3 `2
      st (b3 `2 = {} implies b2 `2 = {}) &
         (for b5, b6 being set
               st [b5,b6] in b2 `1
            holds [b4 . b5,b4 . b6] in b3 `1)
   holds [[b2,b3],b4] in MapsT b1;

:: COH_SP:funcreg 10
registration
  let a1 be set;
  let a2 be Element of MapsT a1;
  cluster a2 `2 -> Relation-like Function-like;
end;

:: COH_SP:funcnot 22 => COH_SP:func 22
definition
  let a1 be set;
  let a2 be Element of MapsT a1;
  func dom A2 -> Element of TOL a1 equals
    a2 `1 `1;
end;

:: COH_SP:def 25
theorem
for b1 being set
for b2 being Element of MapsT b1 holds
   dom b2 = b2 `1 `1;

:: COH_SP:funcnot 23 => COH_SP:func 23
definition
  let a1 be set;
  let a2 be Element of MapsT a1;
  func cod A2 -> Element of TOL a1 equals
    a2 `1 `2;
end;

:: COH_SP:def 26
theorem
for b1 being set
for b2 being Element of MapsT b1 holds
   cod b2 = b2 `1 `2;

:: COH_SP:th 43
theorem
for b1 being set
for b2 being Element of MapsT b1 holds
   b2 = [[dom b2,cod b2],b2 `2];

:: COH_SP:funcnot 24 => COH_SP:func 24
definition
  let a1 be set;
  let a2 be Element of TOL a1;
  func id$ A2 -> Element of MapsT a1 equals
    [[a2,a2],id (a2 `2)];
end;

:: COH_SP:def 27
theorem
for b1 being set
for b2 being Element of TOL b1 holds
   id$ b2 = [[b2,b2],id (b2 `2)];

:: COH_SP:th 44
theorem
for b1 being set
for b2 being Element of MapsT b1 holds
   ((cod b2) `2 = {} implies (dom b2) `2 = {}) &
    b2 `2 is Function-like quasi_total Relation of (dom b2) `2,(cod b2) `2 &
    (for b3, b4 being set
          st [b3,b4] in (dom b2) `1
       holds [b2 `2 . b3,b2 `2 . b4] in (cod b2) `1);

:: COH_SP:funcnot 25 => COH_SP:func 25
definition
  let a1 be set;
  let a2, a3 be Element of MapsT a1;
  assume cod a2 = dom a3;
  func A3 * A2 -> Element of MapsT a1 equals
    [[dom a2,cod a3],a2 `2 * (a3 `2)];
end;

:: COH_SP:def 28
theorem
for b1 being set
for b2, b3 being Element of MapsT b1
      st cod b2 = dom b3
   holds b3 * b2 = [[dom b2,cod b3],b2 `2 * (b3 `2)];

:: COH_SP:th 45
theorem
for b1 being set
for b2, b3 being Element of MapsT b1
      st dom b2 = cod b3
   holds (b2 * b3) `2 = b3 `2 * (b2 `2) &
    dom (b2 * b3) = dom b3 &
    cod (b2 * b3) = cod b2;

:: COH_SP:th 46
theorem
for b1 being set
for b2, b3, b4 being Element of MapsT b1
      st dom b2 = cod b3 & dom b4 = cod b2
   holds b4 * (b2 * b3) = (b4 * b2) * b3;

:: COH_SP:th 47
theorem
for b1 being set
for b2 being Element of TOL b1 holds
   (id$ b2) `2 = id (b2 `2) & dom id$ b2 = b2 & cod id$ b2 = b2;

:: COH_SP:th 48
theorem
for b1 being set
for b2 being Element of MapsT b1 holds
   b2 * id$ dom b2 = b2 & (id$ cod b2) * b2 = b2;

:: COH_SP:funcnot 26 => COH_SP:func 26
definition
  let a1 be set;
  func fDom A1 -> Function-like quasi_total Relation of MapsT a1,TOL a1 means
    for b1 being Element of MapsT a1 holds
       it . b1 = dom b1;
end;

:: COH_SP:def 29
theorem
for b1 being set
for b2 being Function-like quasi_total Relation of MapsT b1,TOL b1 holds
      b2 = fDom b1
   iff
      for b3 being Element of MapsT b1 holds
         b2 . b3 = dom b3;

:: COH_SP:funcnot 27 => COH_SP:func 27
definition
  let a1 be set;
  func fCod A1 -> Function-like quasi_total Relation of MapsT a1,TOL a1 means
    for b1 being Element of MapsT a1 holds
       it . b1 = cod b1;
end;

:: COH_SP:def 30
theorem
for b1 being set
for b2 being Function-like quasi_total Relation of MapsT b1,TOL b1 holds
      b2 = fCod b1
   iff
      for b3 being Element of MapsT b1 holds
         b2 . b3 = cod b3;

:: COH_SP:funcnot 28 => COH_SP:func 28
definition
  let a1 be set;
  func fComp A1 -> Function-like Relation of [:MapsT a1,MapsT a1:],MapsT a1 means
    (for b1, b2 being Element of MapsT a1 holds
        [b1,b2] in dom it
     iff
        dom b1 = cod b2) &
     (for b1, b2 being Element of MapsT a1
           st dom b1 = cod b2
        holds it . [b1,b2] = b1 * b2);
end;

:: COH_SP:def 31
theorem
for b1 being set
for b2 being Function-like Relation of [:MapsT b1,MapsT b1:],MapsT b1 holds
      b2 = fComp b1
   iff
      (for b3, b4 being Element of MapsT b1 holds
          [b3,b4] in dom b2
       iff
          dom b3 = cod b4) &
       (for b3, b4 being Element of MapsT b1
             st dom b3 = cod b4
          holds b2 . [b3,b4] = b3 * b4);

:: COH_SP:funcnot 29 => COH_SP:func 29
definition
  let a1 be set;
  func fId A1 -> Function-like quasi_total Relation of TOL a1,MapsT a1 means
    for b1 being Element of TOL a1 holds
       it . b1 = id$ b1;
end;

:: COH_SP:def 32
theorem
for b1 being set
for b2 being Function-like quasi_total Relation of TOL b1,MapsT b1 holds
      b2 = fId b1
   iff
      for b3 being Element of TOL b1 holds
         b2 . b3 = id$ b3;

:: COH_SP:th 49
theorem
for b1 being set holds
   CatStr(#TOL b1,MapsT b1,fDom b1,fCod b1,fComp b1,fId b1#) is non void Category-like CatStr;

:: COH_SP:funcnot 30 => COH_SP:func 30
definition
  let a1 be set;
  func TolCat A1 -> non void Category-like CatStr equals
    CatStr(#TOL a1,MapsT a1,fDom a1,fCod a1,fComp a1,fId a1#);
end;

:: COH_SP:def 33
theorem
for b1 being set holds
   TolCat b1 = CatStr(#TOL b1,MapsT b1,fDom b1,fCod b1,fComp b1,fId b1#);