Article FUNCT_1, MML version 4.99.1005

:: FUNCT_1:attrnot 1 => FUNCT_1:attr 1
definition
  let a1 be set;
  attr a1 is Function-like means
    for b1, b2, b3 being set
          st [b1,b2] in a1 & [b1,b3] in a1
       holds b2 = b3;
end;

:: FUNCT_1:dfs 1
definiens
  let a1 be set;
To prove
     a1 is Function-like
it is sufficient to prove
  thus for b1, b2, b3 being set
          st [b1,b2] in a1 & [b1,b3] in a1
       holds b2 = b3;

:: FUNCT_1:def 1
theorem
for b1 being set holds
      b1 is Function-like
   iff
      for b2, b3, b4 being set
            st [b2,b3] in b1 & [b2,b4] in b1
         holds b3 = b4;

:: FUNCT_1:exreg 1
registration
  cluster Relation-like Function-like set;
end;

:: FUNCT_1:modenot 1
definition
  mode Function is Relation-like Function-like set;
end;

:: FUNCT_1:condreg 1
registration
  cluster empty -> Function-like (set);
end;

:: FUNCT_1:funcreg 1
registration
  let a1, a2 be set;
  cluster {[a1,a2]} -> Function-like;
end;

:: FUNCT_1:th 2
theorem
for b1 being set
      st (for b2 being set
               st b2 in b1
            holds ex b3, b4 being set st
               [b3,b4] = b2) &
         (for b2, b3, b4 being set
               st [b2,b3] in b1 & [b2,b4] in b1
            holds b3 = b4)
   holds b1 is Relation-like Function-like set;

:: FUNCT_1:sch 1
scheme FUNCT_1:sch 1
{F1 -> set}:
ex b1 being Relation-like Function-like set st
   for b2, b3 being set holds
      [b2,b3] in b1
   iff
      b2 in F1() & P1[b2, b3]
provided
   for b1, b2, b3 being set
         st P1[b1, b2] & P1[b1, b3]
      holds b2 = b3;


:: FUNCT_1:funcnot 1 => FUNCT_1:func 1
definition
  let a1 be Relation-like Function-like set;
  let a2 be set;
  func A1 . A2 -> set means
    [a2,it] in a1
    if a2 in proj1 a1
    otherwise it = {};
end;

:: FUNCT_1:def 4
theorem
for b1 being Relation-like Function-like set
for b2, b3 being set holds
(b2 in proj1 b1 implies    (b3 = b1 . b2
 iff
    [b2,b3] in b1)) &
 (b2 in proj1 b1 or    (b3 = b1 . b2
 iff
    b3 = {}));

:: FUNCT_1:th 8
theorem
for b1, b2 being set
for b3 being Relation-like Function-like set holds
      [b1,b2] in b3
   iff
      b1 in proj1 b3 & b2 = b3 . b1;

:: FUNCT_1:th 9
theorem
for b1, b2 being Relation-like Function-like set
      st proj1 b1 = proj1 b2 &
         (for b3 being set
               st b3 in proj1 b1
            holds b1 . b3 = b2 . b3)
   holds b1 = b2;

:: FUNCT_1:funcnot 2 => RELAT_1:func 2
definition
  let a1 be set;
  func rng A1 -> set means
    for b1 being set holds
          b1 in it
       iff
          ex b2 being set st
             b2 in proj1 a1 & b1 = a1 . b2;
end;

:: FUNCT_1:def 5
theorem
for b1 being Relation-like Function-like set
for b2 being set holds
      b2 = proj2 b1
   iff
      for b3 being set holds
            b3 in b2
         iff
            ex b4 being set st
               b4 in proj1 b1 & b3 = b1 . b4;

:: FUNCT_1:th 12
theorem
for b1 being set
for b2 being Relation-like Function-like set
      st b1 in proj1 b2
   holds b2 . b1 in proj2 b2;

:: FUNCT_1:th 14
theorem
for b1 being set
for b2 being Relation-like Function-like set
      st proj1 b2 = {b1}
   holds proj2 b2 = {b2 . b1};

:: FUNCT_1:sch 2
scheme FUNCT_1:sch 2
{F1 -> set}:
ex b1 being Relation-like Function-like set st
   proj1 b1 = F1() &
    (for b2 being set
          st b2 in F1()
       holds P1[b2, b1 . b2])
provided
   for b1, b2, b3 being set
         st b1 in F1() & P1[b1, b2] & P1[b1, b3]
      holds b2 = b3
and
   for b1 being set
         st b1 in F1()
      holds ex b2 being set st
         P1[b1, b2];


:: FUNCT_1:sch 3
scheme FUNCT_1:sch 3
{F1 -> set,
  F2 -> set}:
ex b1 being Relation-like Function-like set st
   proj1 b1 = F1() &
    (for b2 being set
          st b2 in F1()
       holds b1 . b2 = F2(b2))


:: FUNCT_1:th 15
theorem
for b1 being set
   st b1 <> {}
for b2 being set holds
   ex b3 being Relation-like Function-like set st
      proj1 b3 = b1 & proj2 b3 = {b2};

:: FUNCT_1:th 16
theorem
for b1 being set
      st for b2, b3 being Relation-like Function-like set
              st proj1 b2 = b1 & proj1 b3 = b1
           holds b2 = b3
   holds b1 = {};

:: FUNCT_1:th 17
theorem
for b1 being set
for b2, b3 being Relation-like Function-like set
      st proj1 b2 = proj1 b3 & proj2 b2 = {b1} & proj2 b3 = {b1}
   holds b2 = b3;

:: FUNCT_1:th 18
theorem
for b1, b2 being set
      st (b1 = {} implies b2 = {})
   holds ex b3 being Relation-like Function-like set st
      b2 = proj1 b3 & proj2 b3 c= b1;

:: FUNCT_1:th 19
theorem
for b1 being set
for b2 being Relation-like Function-like set
      st for b3 being set
              st b3 in b1
           holds ex b4 being set st
              b4 in proj1 b2 & b3 = b2 . b4
   holds b1 c= proj2 b2;

:: FUNCT_1:funcnot 3 => RELAT_1:func 5
notation
  let a1, a2 be Relation-like Function-like set;
  synonym a2 * a1 for a1 * a2;
end;

:: FUNCT_1:funcreg 2
registration
  let a1, a2 be Relation-like Function-like set;
  cluster a1 * a2 -> Relation-like Function-like;
end;

:: FUNCT_1:th 20
theorem
for b1, b2, b3 being Relation-like Function-like set
      st (for b4 being set holds
               b4 in proj1 b3
            iff
               b4 in proj1 b1 & b1 . b4 in proj1 b2) &
         (for b4 being set
               st b4 in proj1 b3
            holds b3 . b4 = b2 . (b1 . b4))
   holds b3 = b1 * b2;

:: FUNCT_1:th 21
theorem
for b1 being set
for b2, b3 being Relation-like Function-like set holds
   b1 in proj1 (b3 * b2)
iff
   b1 in proj1 b3 & b3 . b1 in proj1 b2;

:: FUNCT_1:th 22
theorem
for b1 being set
for b2, b3 being Relation-like Function-like set
      st b1 in proj1 (b3 * b2)
   holds (b3 * b2) . b1 = b2 . (b3 . b1);

:: FUNCT_1:th 23
theorem
for b1 being set
for b2, b3 being Relation-like Function-like set
      st b1 in proj1 b2
   holds (b2 * b3) . b1 = b3 . (b2 . b1);

:: FUNCT_1:th 25
theorem
for b1 being set
for b2, b3 being Relation-like Function-like set
      st b1 in proj2 (b3 * b2)
   holds b1 in proj2 b2;

:: FUNCT_1:th 27
theorem
for b1, b2 being Relation-like Function-like set
      st proj1 (b2 * b1) = proj1 b2
   holds proj2 b2 c= proj1 b1;

:: FUNCT_1:th 33
theorem
for b1 being set
for b2 being Relation-like Function-like set
      st proj2 b2 c= b1 &
         (for b3, b4 being Relation-like Function-like set
               st proj1 b3 = b1 & proj1 b4 = b1 & b2 * b3 = b2 * b4
            holds b3 = b4)
   holds b1 = proj2 b2;

:: FUNCT_1:funcreg 3
registration
  let a1 be set;
  cluster id a1 -> Relation-like Function-like;
end;

:: FUNCT_1:th 34
theorem
for b1 being set
for b2 being Relation-like Function-like set holds
      b2 = id b1
   iff
      proj1 b2 = b1 &
       (for b3 being set
             st b3 in b1
          holds b2 . b3 = b3);

:: FUNCT_1:th 35
theorem
for b1, b2 being set
      st b1 in b2
   holds (id b2) . b1 = b1;

:: FUNCT_1:th 37
theorem
for b1 being set
for b2 being Relation-like Function-like set holds
   proj1 ((id b1) * b2) = (proj1 b2) /\ b1;

:: FUNCT_1:th 38
theorem
for b1, b2 being set
for b3 being Relation-like Function-like set
      st b1 in (proj1 b3) /\ b2
   holds b3 . b1 = ((id b2) * b3) . b1;

:: FUNCT_1:th 40
theorem
for b1, b2 being set
for b3 being Relation-like Function-like set holds
      b1 in proj1 (b3 * id b2)
   iff
      b1 in proj1 b3 & b3 . b1 in b2;

:: FUNCT_1:th 43
theorem
for b1, b2 being set holds
(id b2) * id b1 = id (b1 /\ b2);

:: FUNCT_1:th 44
theorem
for b1, b2 being Relation-like Function-like set
      st proj2 b1 = proj1 b2 & b1 * b2 = b1
   holds b2 = id proj1 b2;

:: FUNCT_1:attrnot 2 => FUNCT_1:attr 2
definition
  let a1 be Relation-like Function-like set;
  attr a1 is one-to-one means
    for b1, b2 being set
          st b1 in proj1 a1 & b2 in proj1 a1 & a1 . b1 = a1 . b2
       holds b1 = b2;
end;

:: FUNCT_1:dfs 4
definiens
  let a1 be Relation-like Function-like set;
To prove
     a1 is one-to-one
it is sufficient to prove
  thus for b1, b2 being set
          st b1 in proj1 a1 & b2 in proj1 a1 & a1 . b1 = a1 . b2
       holds b1 = b2;

:: FUNCT_1:def 8
theorem
for b1 being Relation-like Function-like set holds
      b1 is one-to-one
   iff
      for b2, b3 being set
            st b2 in proj1 b1 & b3 in proj1 b1 & b1 . b2 = b1 . b3
         holds b2 = b3;

:: FUNCT_1:th 46
theorem
for b1, b2 being Relation-like Function-like set
      st b1 is one-to-one & b2 is one-to-one
   holds b1 * b2 is one-to-one;

:: FUNCT_1:th 47
theorem
for b1, b2 being Relation-like Function-like set
      st b2 * b1 is one-to-one & proj2 b2 c= proj1 b1
   holds b2 is one-to-one;

:: FUNCT_1:th 48
theorem
for b1, b2 being Relation-like Function-like set
      st b2 * b1 is one-to-one & proj2 b2 = proj1 b1
   holds b2 is one-to-one & b1 is one-to-one;

:: FUNCT_1:th 49
theorem
for b1 being Relation-like Function-like set holds
      b1 is one-to-one
   iff
      for b2, b3 being Relation-like Function-like set
            st proj2 b2 c= proj1 b1 & proj2 b3 c= proj1 b1 & proj1 b2 = proj1 b3 & b2 * b1 = b3 * b1
         holds b2 = b3;

:: FUNCT_1:th 50
theorem
for b1 being set
for b2, b3 being Relation-like Function-like set
      st proj1 b2 = b1 & proj1 b3 = b1 & proj2 b3 c= b1 & b2 is one-to-one & b3 * b2 = b2
   holds b3 = id b1;

:: FUNCT_1:th 51
theorem
for b1, b2 being Relation-like Function-like set
      st proj2 (b2 * b1) = proj2 b1 & b1 is one-to-one
   holds proj1 b1 c= proj2 b2;

:: FUNCT_1:th 52
theorem
for b1 being set holds
   id b1 is one-to-one;

:: FUNCT_1:funcreg 4
registration
  let a1 be set;
  cluster id a1 -> Relation-like one-to-one;
end;

:: FUNCT_1:th 53
theorem
for b1 being Relation-like Function-like set
      st ex b2 being Relation-like Function-like set st
           b1 * b2 = id proj1 b1
   holds b1 is one-to-one;

:: FUNCT_1:exreg 2
registration
  cluster empty Relation-like Function-like set;
end;

:: FUNCT_1:condreg 2
registration
  cluster empty Relation-like Function-like -> one-to-one (set);
end;

:: FUNCT_1:exreg 3
registration
  cluster Relation-like Function-like one-to-one set;
end;

:: FUNCT_1:funcreg 5
registration
  let a1 be Relation-like Function-like one-to-one set;
  cluster a1 ~ -> Relation-like Function-like;
end;

:: FUNCT_1:funcnot 4 => FUNCT_1:func 2
definition
  let a1 be Relation-like Function-like set;
  assume a1 is one-to-one;
  func A1 " -> Relation-like Function-like set equals
    a1 ~;
end;

:: FUNCT_1:def 9
theorem
for b1 being Relation-like Function-like set
      st b1 is one-to-one
   holds b1 " = b1 ~;

:: FUNCT_1:th 54
theorem
for b1 being Relation-like Function-like set
   st b1 is one-to-one
for b2 being Relation-like Function-like set holds
      b2 = b1 "
   iff
      proj1 b2 = proj2 b1 &
       (for b3, b4 being set holds
          b3 in proj2 b1 & b4 = b2 . b3
       iff
          b4 in proj1 b1 & b3 = b1 . b4);

:: FUNCT_1:th 55
theorem
for b1 being Relation-like Function-like set
      st b1 is one-to-one
   holds proj2 b1 = proj1 (b1 ") & proj1 b1 = proj2 (b1 ");

:: FUNCT_1:th 56
theorem
for b1 being set
for b2 being Relation-like Function-like set
      st b2 is one-to-one & b1 in proj1 b2
   holds b1 = b2 " . (b2 . b1) & b1 = (b2 * (b2 ")) . b1;

:: FUNCT_1:th 57
theorem
for b1 being set
for b2 being Relation-like Function-like set
      st b2 is one-to-one & b1 in proj2 b2
   holds b1 = b2 . (b2 " . b1) & b1 = (b2 " * b2) . b1;

:: FUNCT_1:th 58
theorem
for b1 being Relation-like Function-like set
      st b1 is one-to-one
   holds proj1 (b1 * (b1 ")) = proj1 b1 & proj2 (b1 * (b1 ")) = proj1 b1;

:: FUNCT_1:th 59
theorem
for b1 being Relation-like Function-like set
      st b1 is one-to-one
   holds proj1 (b1 " * b1) = proj2 b1 & proj2 (b1 " * b1) = proj2 b1;

:: FUNCT_1:th 60
theorem
for b1, b2 being Relation-like Function-like set
      st b1 is one-to-one &
         proj1 b1 = proj2 b2 &
         proj2 b1 = proj1 b2 &
         (for b3, b4 being set
               st b3 in proj1 b1 & b4 in proj1 b2
            holds    b1 . b3 = b4
            iff
               b2 . b4 = b3)
   holds b2 = b1 ";

:: FUNCT_1:th 61
theorem
for b1 being Relation-like Function-like set
      st b1 is one-to-one
   holds b1 * (b1 ") = id proj1 b1 & b1 " * b1 = id proj2 b1;

:: FUNCT_1:th 62
theorem
for b1 being Relation-like Function-like set
      st b1 is one-to-one
   holds b1 " is one-to-one;

:: FUNCT_1:funcreg 6
registration
  let a1 be Relation-like Function-like one-to-one set;
  cluster a1 " -> Relation-like Function-like one-to-one;
end;

:: FUNCT_1:funcreg 7
registration
  let a1, a2 be Relation-like Function-like one-to-one set;
  cluster a1 * a2 -> Relation-like one-to-one;
end;

:: FUNCT_1:th 63
theorem
for b1, b2 being Relation-like Function-like set
      st b1 is one-to-one & proj2 b1 = proj1 b2 & b1 * b2 = id proj1 b1
   holds b2 = b1 ";

:: FUNCT_1:th 64
theorem
for b1, b2 being Relation-like Function-like set
      st b1 is one-to-one & proj2 b2 = proj1 b1 & b2 * b1 = id proj2 b1
   holds b2 = b1 ";

:: FUNCT_1:th 65
theorem
for b1 being Relation-like Function-like set
      st b1 is one-to-one
   holds b1 " " = b1;

:: FUNCT_1:th 66
theorem
for b1, b2 being Relation-like Function-like set
      st b1 is one-to-one & b2 is one-to-one
   holds (b1 * b2) " = b2 " * (b1 ");

:: FUNCT_1:th 67
theorem
for b1 being set holds
   (id b1) " = id b1;

:: FUNCT_1:funcreg 8
registration
  let a1 be Relation-like Function-like set;
  let a2 be set;
  cluster a1 | a2 -> Relation-like Function-like;
end;

:: FUNCT_1:th 68
theorem
for b1 being set
for b2, b3 being Relation-like Function-like set holds
   b2 = b3 | b1
iff
   proj1 b2 = (proj1 b3) /\ b1 &
    (for b4 being set
          st b4 in proj1 b2
       holds b2 . b4 = b3 . b4);

:: FUNCT_1:th 70
theorem
for b1, b2 being set
for b3 being Relation-like Function-like set
      st b1 in proj1 (b3 | b2)
   holds (b3 | b2) . b1 = b3 . b1;

:: FUNCT_1:th 71
theorem
for b1, b2 being set
for b3 being Relation-like Function-like set
      st b1 in (proj1 b3) /\ b2
   holds (b3 | b2) . b1 = b3 . b1;

:: FUNCT_1:th 72
theorem
for b1, b2 being set
for b3 being Relation-like Function-like set
      st b1 in b2
   holds (b3 | b2) . b1 = b3 . b1;

:: FUNCT_1:th 73
theorem
for b1, b2 being set
for b3 being Relation-like Function-like set
      st b1 in proj1 b3 & b1 in b2
   holds b3 . b1 in proj2 (b3 | b2);

:: FUNCT_1:th 82
theorem
for b1, b2 being set
for b3 being Relation-like Function-like set
      st b1 c= b2
   holds (b3 | b1) | b2 = b3 | b1 & (b3 | b2) | b1 = b3 | b1;

:: FUNCT_1:th 84
theorem
for b1 being set
for b2 being Relation-like Function-like set
      st b2 is one-to-one
   holds b2 | b1 is one-to-one;

:: FUNCT_1:funcreg 9
registration
  let a1 be set;
  let a2 be Relation-like Function-like set;
  cluster a1 | a2 -> Relation-like Function-like;
end;

:: FUNCT_1:th 85
theorem
for b1 being set
for b2, b3 being Relation-like Function-like set holds
   b2 = b1 | b3
iff
   (for b4 being set holds
          b4 in proj1 b2
       iff
          b4 in proj1 b3 & b3 . b4 in b1) &
    (for b4 being set
          st b4 in proj1 b2
       holds b2 . b4 = b3 . b4);

:: FUNCT_1:th 86
theorem
for b1, b2 being set
for b3 being Relation-like Function-like set holds
      b1 in proj1 (b2 | b3)
   iff
      b1 in proj1 b3 & b3 . b1 in b2;

:: FUNCT_1:th 87
theorem
for b1, b2 being set
for b3 being Relation-like Function-like set
      st b1 in proj1 (b2 | b3)
   holds (b2 | b3) . b1 = b3 . b1;

:: FUNCT_1:th 89
theorem
for b1 being set
for b2 being Relation-like Function-like set holds
   proj1 (b1 | b2) c= proj1 b2;

:: FUNCT_1:th 97
theorem
for b1, b2 being set
for b3 being Relation-like Function-like set
      st b1 c= b2
   holds b2 | (b1 | b3) = b1 | b3 & b1 | (b2 | b3) = b1 | b3;

:: FUNCT_1:th 99
theorem
for b1 being set
for b2 being Relation-like Function-like set
      st b2 is one-to-one
   holds b1 | b2 is one-to-one;

:: FUNCT_1:funcnot 5 => RELAT_1:func 9
definition
  let a1 be Relation-like set;
  let a2 be set;
  func A1 .: A2 -> set means
    for b1 being set holds
          b1 in it
       iff
          ex b2 being set st
             b2 in proj1 a1 & b2 in a2 & b1 = a1 . b2;
end;

:: FUNCT_1:def 12
theorem
for b1 being Relation-like Function-like set
for b2, b3 being set holds
   b3 = b1 .: b2
iff
   for b4 being set holds
         b4 in b3
      iff
         ex b5 being set st
            b5 in proj1 b1 & b5 in b2 & b4 = b1 . b5;

:: FUNCT_1:th 117
theorem
for b1 being set
for b2 being Relation-like Function-like set
      st b1 in proj1 b2
   holds Im(b2,b1) = {b2 . b1};

:: FUNCT_1:th 118
theorem
for b1, b2 being set
for b3 being Relation-like Function-like set
      st b1 in proj1 b3 & b2 in proj1 b3
   holds b3 .: {b1,b2} = {b3 . b1,b3 . b2};

:: FUNCT_1:th 120
theorem
for b1, b2 being set
for b3 being Relation-like Function-like set holds
   (b1 | b3) .: b2 c= b3 .: b2;

:: FUNCT_1:th 121
theorem
for b1, b2 being set
for b3 being Relation-like Function-like set
      st b3 is one-to-one
   holds b3 .: (b1 /\ b2) = (b3 .: b1) /\ (b3 .: b2);

:: FUNCT_1:th 122
theorem
for b1 being Relation-like Function-like set
      st for b2, b3 being set holds
        b1 .: (b2 /\ b3) = (b1 .: b2) /\ (b1 .: b3)
   holds b1 is one-to-one;

:: FUNCT_1:th 123
theorem
for b1, b2 being set
for b3 being Relation-like Function-like set
      st b3 is one-to-one
   holds b3 .: (b1 \ b2) = (b3 .: b1) \ (b3 .: b2);

:: FUNCT_1:th 124
theorem
for b1 being Relation-like Function-like set
      st for b2, b3 being set holds
        b1 .: (b2 \ b3) = (b1 .: b2) \ (b1 .: b3)
   holds b1 is one-to-one;

:: FUNCT_1:th 125
theorem
for b1, b2 being set
for b3 being Relation-like Function-like set
      st b1 misses b2 & b3 is one-to-one
   holds b3 .: b1 misses b3 .: b2;

:: FUNCT_1:th 126
theorem
for b1, b2 being set
for b3 being Relation-like Function-like set holds
   (b1 | b3) .: b2 = b1 /\ (b3 .: b2);

:: FUNCT_1:funcnot 6 => RELAT_1:func 10
definition
  let a1 be Relation-like set;
  let a2 be set;
  func A1 " A2 -> set means
    for b1 being set holds
          b1 in it
       iff
          b1 in proj1 a1 & a1 . b1 in a2;
end;

:: FUNCT_1:def 13
theorem
for b1 being Relation-like Function-like set
for b2, b3 being set holds
   b3 = b1 " b2
iff
   for b4 being set holds
         b4 in b3
      iff
         b4 in proj1 b1 & b1 . b4 in b2;

:: FUNCT_1:th 137
theorem
for b1, b2 being set
for b3 being Relation-like Function-like set holds
   b3 " (b1 /\ b2) = (b3 " b1) /\ (b3 " b2);

:: FUNCT_1:th 138
theorem
for b1, b2 being set
for b3 being Relation-like Function-like set holds
   b3 " (b1 \ b2) = (b3 " b1) \ (b3 " b2);

:: FUNCT_1:th 139
theorem
for b1, b2 being set
for b3 being Relation-like set holds
   (b3 | b1) " b2 = b1 /\ (b3 " b2);

:: FUNCT_1:th 141
theorem
for b1 being Relation-like Function-like set
for b2, b3 being set
      st b2 misses b3
   holds b1 " b2 misses b1 " b3;

:: FUNCT_1:th 142
theorem
for b1 being set
for b2 being Relation-like set holds
      b1 in proj2 b2
   iff
      b2 " {b1} <> {};

:: FUNCT_1:th 143
theorem
for b1 being set
for b2 being Relation-like set
      st for b3 being set
              st b3 in b1
           holds b2 " {b3} <> {}
   holds b1 c= proj2 b2;

:: FUNCT_1:th 144
theorem
for b1 being Relation-like Function-like set holds
      for b2 being set
            st b2 in proj2 b1
         holds ex b3 being set st
            b1 " {b2} = {b3}
   iff
      b1 is one-to-one;

:: FUNCT_1:th 145
theorem
for b1 being set
for b2 being Relation-like Function-like set holds
   b2 .: (b2 " b1) c= b1;

:: FUNCT_1:th 146
theorem
for b1 being set
for b2 being Relation-like set
      st b1 c= proj1 b2
   holds b1 c= b2 " (b2 .: b1);

:: FUNCT_1:th 147
theorem
for b1 being set
for b2 being Relation-like Function-like set
      st b1 c= proj2 b2
   holds b2 .: (b2 " b1) = b1;

:: FUNCT_1:th 148
theorem
for b1 being set
for b2 being Relation-like Function-like set holds
   b2 .: (b2 " b1) = b1 /\ (b2 .: proj1 b2);

:: FUNCT_1:th 149
theorem
for b1, b2 being set
for b3 being Relation-like Function-like set holds
   b3 .: (b1 /\ (b3 " b2)) c= (b3 .: b1) /\ b2;

:: FUNCT_1:th 150
theorem
for b1, b2 being set
for b3 being Relation-like Function-like set holds
   b3 .: (b1 /\ (b3 " b2)) = (b3 .: b1) /\ b2;

:: FUNCT_1:th 151
theorem
for b1, b2 being set
for b3 being Relation-like set holds
   b1 /\ (b3 " b2) c= b3 " ((b3 .: b1) /\ b2);

:: FUNCT_1:th 152
theorem
for b1 being set
for b2 being Relation-like Function-like set
      st b2 is one-to-one
   holds b2 " (b2 .: b1) c= b1;

:: FUNCT_1:th 153
theorem
for b1 being Relation-like Function-like set
      st for b2 being set holds
           b1 " (b1 .: b2) c= b2
   holds b1 is one-to-one;

:: FUNCT_1:th 154
theorem
for b1 being set
for b2 being Relation-like Function-like set
      st b2 is one-to-one
   holds b2 .: b1 = b2 " " b1;

:: FUNCT_1:th 155
theorem
for b1 being set
for b2 being Relation-like Function-like set
      st b2 is one-to-one
   holds b2 " b1 = b2 " .: b1;

:: FUNCT_1:th 156
theorem
for b1 being set
for b2, b3, b4 being Relation-like Function-like set
      st b1 = proj2 b2 & proj1 b3 = b1 & proj1 b4 = b1 & b2 * b3 = b2 * b4
   holds b3 = b4;

:: FUNCT_1:th 157
theorem
for b1, b2 being set
for b3 being Relation-like Function-like set
      st b3 .: b1 c= b3 .: b2 & b1 c= proj1 b3 & b3 is one-to-one
   holds b1 c= b2;

:: FUNCT_1:th 158
theorem
for b1, b2 being set
for b3 being Relation-like Function-like set
      st b3 " b1 c= b3 " b2 & b1 c= proj2 b3
   holds b1 c= b2;

:: FUNCT_1:th 159
theorem
for b1 being Relation-like Function-like set holds
      b1 is one-to-one
   iff
      for b2 being set holds
         ex b3 being set st
            b1 " {b2} c= {b3};

:: FUNCT_1:th 160
theorem
for b1 being set
for b2, b3 being Relation-like set
      st proj2 b2 c= proj1 b3
   holds b2 " b1 c= (b2 * b3) " (b3 .: b1);

:: FUNCT_1:th 161
theorem
for b1, b2 being set
for b3 being Relation-like Function-like set
      st b3 " b1 = b3 " b2 & b1 c= proj2 b3 & b2 c= proj2 b3
   holds b1 = b2;

:: FUNCT_1:th 162
theorem
for b1 being set
for b2 being Element of bool b1 holds
   (id b1) .: b2 = b2;

:: FUNCT_1:attrnot 3 => RELAT_1:attr 3
definition
  let a1 be Relation-like set;
  attr a1 is empty-yielding means
    for b1 being set
          st b1 in proj1 a1
       holds a1 . b1 is empty;
end;

:: FUNCT_1:dfs 8
definiens
  let a1 be Relation-like Function-like set;
To prove
     a1 is empty-yielding
it is sufficient to prove
  thus for b1 being set
          st b1 in proj1 a1
       holds a1 . b1 is empty;

:: FUNCT_1:def 14
theorem
for b1 being Relation-like Function-like set holds
      b1 is empty-yielding
   iff
      for b2 being set
            st b2 in proj1 b1
         holds b1 . b2 is empty;

:: FUNCT_1:exreg 4
registration
  cluster Relation-like empty-yielding Function-like set;
end;

:: FUNCT_1:attrnot 4 => RELAT_1:attr 2
definition
  let a1 be Relation-like set;
  attr a1 is non-empty means
    for b1 being set
          st b1 in proj1 a1
       holds a1 . b1 is not empty;
end;

:: FUNCT_1:dfs 9
definiens
  let a1 be Relation-like Function-like set;
To prove
     a1 is non-empty
it is sufficient to prove
  thus for b1 being set
          st b1 in proj1 a1
       holds a1 . b1 is not empty;

:: FUNCT_1:def 15
theorem
for b1 being Relation-like Function-like set holds
      b1 is non-empty
   iff
      for b2 being set
            st b2 in proj1 b1
         holds b1 . b2 is not empty;

:: FUNCT_1:exreg 5
registration
  cluster Relation-like non-empty Function-like set;
end;

:: FUNCT_1:sch 4
scheme FUNCT_1:sch 4
{F1 -> non empty set,
  F2 -> set}:
ex b1 being Relation-like Function-like set st
   proj1 b1 = F1() &
    (for b2 being Element of F1() holds
       b1 . b2 = F2(b2))


:: FUNCT_1:funcreg 10
registration
  let a1 be Relation-like non-empty Function-like set;
  cluster proj2 a1 -> with_non-empty_elements;
end;

:: FUNCT_1:attrnot 5 => FUNCT_1:attr 3
definition
  let a1 be Relation-like Function-like set;
  attr a1 is constant means
    for b1, b2 being set
          st b1 in proj1 a1 & b2 in proj1 a1
       holds a1 . b1 = a1 . b2;
end;

:: FUNCT_1:dfs 10
definiens
  let a1 be Relation-like Function-like set;
To prove
     a1 is constant
it is sufficient to prove
  thus for b1, b2 being set
          st b1 in proj1 a1 & b2 in proj1 a1
       holds a1 . b1 = a1 . b2;

:: FUNCT_1:def 16
theorem
for b1 being Relation-like Function-like set holds
      b1 is constant
   iff
      for b2, b3 being set
            st b2 in proj1 b1 & b3 in proj1 b1
         holds b1 . b2 = b1 . b3;

:: FUNCT_1:th 163
theorem
for b1, b2 being set
for b3 being Relation-like Function-like set
      st b1 c= proj1 b3 & b3 .: b1 c= b2
   holds b1 c= b3 " b2;

:: FUNCT_1:th 164
theorem
for b1 being set
for b2 being Relation-like Function-like set
      st b1 c= proj1 b2 & b2 is one-to-one
   holds b2 " (b2 .: b1) = b1;

:: FUNCT_1:prednot 1 => HIDDEN:pred 1
definition
  let a1, a2 be set;
  pred A1 = A2 means
    proj1 a1 = proj1 a2 &
     (for b1 being set
           st b1 in proj1 a1
        holds a1 . b1 = a2 . b1);
  symmetry;
::  for a1, a2 being set
::        st a1 = a2
::     holds a2 = a1;
  reflexivity;
::  for a1 being set holds
::     a1 = a1;
end;

:: FUNCT_1:dfs 11
definiens
  let a1, a2 be Relation-like Function-like set;
To prove
     a1 = a2
it is sufficient to prove
  thus proj1 a1 = proj1 a2 &
     (for b1 being set
           st b1 in proj1 a1
        holds a1 . b1 = a2 . b1);

:: FUNCT_1:def 17
theorem
for b1, b2 being Relation-like Function-like set holds
   b1 = b2
iff
   proj1 b1 = proj1 b2 &
    (for b3 being set
          st b3 in proj1 b1
       holds b1 . b3 = b2 . b3);

:: FUNCT_1:exreg 6
registration
  cluster non empty Relation-like non-empty Function-like set;
end;

:: FUNCT_1:funcreg 11
registration
  let a1 be non empty Relation-like non-empty Function-like set;
  let a2 be Element of proj1 a1;
  cluster a1 . a2 -> non empty;
end;

:: FUNCT_1:condreg 3
registration
  let a1 be Relation-like Function-like set;
  cluster -> Function-like (Element of bool a1);
end;

:: FUNCT_1:th 165
theorem
for b1, b2 being Relation-like Function-like set
for b3 being set
      st b3 c= proj1 b1 & b3 c= proj1 b2
   holds    b1 | b3 = b2 | b3
   iff
      for b4 being set
            st b4 in b3
         holds b1 . b4 = b2 . b4;

:: FUNCT_1:th 166
theorem
for b1, b2 being Relation-like Function-like set
for b3 being set
      st proj1 b1 = proj1 b2 &
         (for b4 being set
               st b4 in b3
            holds b1 . b4 = b2 . b4)
   holds b1 | b3 = b2 | b3;

:: FUNCT_1:th 167
theorem
for b1 being Relation-like Function-like set
for b2 being set holds
   proj2 (b1 | {b2}) c= {b1 . b2};

:: FUNCT_1:th 168
theorem
for b1 being Relation-like Function-like set
for b2 being set
      st b2 in proj1 b1
   holds proj2 (b1 | {b2}) = {b1 . b2};