Article PARTFUN3, MML version 4.99.1005

:: PARTFUN3:funcreg 1
registration
  let a1 be real set;
  cluster a1 / a1 -> non negative;
end;

:: PARTFUN3:funcreg 2
registration
  let a1 be real set;
  cluster a1 * a1 -> non negative;
end;

:: PARTFUN3:funcreg 3
registration
  let a1 be real set;
  cluster a1 * (a1 ") -> non negative;
end;

:: PARTFUN3:funcreg 4
registration
  let a1 be real non negative set;
  cluster sqrt a1 -> real non negative;
end;

:: PARTFUN3:funcreg 5
registration
  let a1 be real positive set;
  cluster sqrt a1 -> real positive;
end;

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

:: PARTFUN3:funcreg 6
registration
  let a1 be Relation-like non-empty Function-like set;
  cluster a1 " {0} -> empty;
end;

:: PARTFUN3:attrnot 1 => PARTFUN3:attr 1
definition
  let a1 be Relation-like set;
  attr a1 is positive-yielding means
    for b1 being real set
          st b1 in proj2 a1
       holds 0 < b1;
end;

:: PARTFUN3:dfs 1
definiens
  let a1 be Relation-like set;
To prove
     a1 is positive-yielding
it is sufficient to prove
  thus for b1 being real set
          st b1 in proj2 a1
       holds 0 < b1;

:: PARTFUN3:def 1
theorem
for b1 being Relation-like set holds
      b1 is positive-yielding
   iff
      for b2 being real set
            st b2 in proj2 b1
         holds 0 < b2;

:: PARTFUN3:attrnot 2 => PARTFUN3:attr 2
definition
  let a1 be Relation-like set;
  attr a1 is negative-yielding means
    for b1 being real set
          st b1 in proj2 a1
       holds b1 < 0;
end;

:: PARTFUN3:dfs 2
definiens
  let a1 be Relation-like set;
To prove
     a1 is negative-yielding
it is sufficient to prove
  thus for b1 being real set
          st b1 in proj2 a1
       holds b1 < 0;

:: PARTFUN3:def 2
theorem
for b1 being Relation-like set holds
      b1 is negative-yielding
   iff
      for b2 being real set
            st b2 in proj2 b1
         holds b2 < 0;

:: PARTFUN3:attrnot 3 => PARTFUN3:attr 3
definition
  let a1 be Relation-like set;
  attr a1 is nonpositive-yielding means
    for b1 being real set
          st b1 in proj2 a1
       holds b1 <= 0;
end;

:: PARTFUN3:dfs 3
definiens
  let a1 be Relation-like set;
To prove
     a1 is nonpositive-yielding
it is sufficient to prove
  thus for b1 being real set
          st b1 in proj2 a1
       holds b1 <= 0;

:: PARTFUN3:def 3
theorem
for b1 being Relation-like set holds
      b1 is nonpositive-yielding
   iff
      for b2 being real set
            st b2 in proj2 b1
         holds b2 <= 0;

:: PARTFUN3:attrnot 4 => PARTFUN3:attr 4
definition
  let a1 be Relation-like set;
  attr a1 is nonnegative-yielding means
    for b1 being real set
          st b1 in proj2 a1
       holds 0 <= b1;
end;

:: PARTFUN3:dfs 4
definiens
  let a1 be Relation-like set;
To prove
     a1 is nonnegative-yielding
it is sufficient to prove
  thus for b1 being real set
          st b1 in proj2 a1
       holds 0 <= b1;

:: PARTFUN3:def 4
theorem
for b1 being Relation-like set holds
      b1 is nonnegative-yielding
   iff
      for b2 being real set
            st b2 in proj2 b1
         holds 0 <= b2;

:: PARTFUN3:funcreg 7
registration
  let a1 be set;
  let a2 be real positive set;
  cluster a1 --> a2 -> positive-yielding;
end;

:: PARTFUN3:funcreg 8
registration
  let a1 be set;
  let a2 be real negative set;
  cluster a1 --> a2 -> negative-yielding;
end;

:: PARTFUN3:funcreg 9
registration
  let a1 be set;
  let a2 be real non positive set;
  cluster a1 --> a2 -> nonpositive-yielding;
end;

:: PARTFUN3:funcreg 10
registration
  let a1 be set;
  let a2 be real non negative set;
  cluster a1 --> a2 -> nonnegative-yielding;
end;

:: PARTFUN3:funcreg 11
registration
  let a1 be non empty set;
  cluster a1 --> 0 -> non non-empty;
end;

:: PARTFUN3:condreg 1
registration
  cluster Relation-like positive-yielding -> non-empty nonnegative-yielding (set);
end;

:: PARTFUN3:condreg 2
registration
  cluster Relation-like negative-yielding -> non-empty nonpositive-yielding (set);
end;

:: PARTFUN3:exreg 1
registration
  let a1 be set;
  cluster Relation-like Function-like quasi_total complex-valued ext-real-valued real-valued total negative-yielding Relation of a1,REAL;
end;

:: PARTFUN3:exreg 2
registration
  let a1 be set;
  cluster Relation-like Function-like quasi_total complex-valued ext-real-valued real-valued total positive-yielding Relation of a1,REAL;
end;

:: PARTFUN3:exreg 3
registration
  cluster Relation-like non-empty Function-like real-valued set;
end;

:: PARTFUN3:th 2
theorem
for b1 being Relation-like non-empty Function-like real-valued set holds
   proj1 (b1 ^) = proj1 b1;

:: PARTFUN3:th 3
theorem
for b1 being non empty set
for b2 being Function-like Relation of b1,REAL
for b3 being non-empty Function-like Relation of b1,REAL holds
   dom (b2 / b3) = (dom b2) /\ dom b3;

:: PARTFUN3:funcreg 12
registration
  let a1 be set;
  let a2, a3 be Function-like nonpositive-yielding Relation of a1,REAL;
  cluster a2 + a3 -> Relation-like Function-like nonpositive-yielding;
end;

:: PARTFUN3:funcreg 13
registration
  let a1 be set;
  let a2, a3 be Function-like nonnegative-yielding Relation of a1,REAL;
  cluster a2 + a3 -> Relation-like Function-like nonnegative-yielding;
end;

:: PARTFUN3:funcreg 14
registration
  let a1 be set;
  let a2 be Function-like positive-yielding Relation of a1,REAL;
  let a3 be Function-like nonnegative-yielding Relation of a1,REAL;
  cluster a2 + a3 -> Relation-like Function-like positive-yielding;
end;

:: PARTFUN3:funcreg 15
registration
  let a1 be set;
  let a2 be Function-like nonnegative-yielding Relation of a1,REAL;
  let a3 be Function-like positive-yielding Relation of a1,REAL;
  cluster a2 + a3 -> Relation-like Function-like positive-yielding;
end;

:: PARTFUN3:funcreg 16
registration
  let a1 be set;
  let a2 be Function-like nonpositive-yielding Relation of a1,REAL;
  let a3 be Function-like negative-yielding Relation of a1,REAL;
  cluster a2 + a3 -> Relation-like Function-like negative-yielding;
end;

:: PARTFUN3:funcreg 17
registration
  let a1 be set;
  let a2 be Function-like negative-yielding Relation of a1,REAL;
  let a3 be Function-like nonpositive-yielding Relation of a1,REAL;
  cluster a2 + a3 -> Relation-like Function-like negative-yielding;
end;

:: PARTFUN3:funcreg 18
registration
  let a1 be set;
  let a2 be Function-like nonnegative-yielding Relation of a1,REAL;
  let a3 be Function-like nonpositive-yielding Relation of a1,REAL;
  cluster a2 - a3 -> Relation-like Function-like nonnegative-yielding;
end;

:: PARTFUN3:funcreg 19
registration
  let a1 be set;
  let a2 be Function-like nonpositive-yielding Relation of a1,REAL;
  let a3 be Function-like nonnegative-yielding Relation of a1,REAL;
  cluster a2 - a3 -> Relation-like Function-like nonpositive-yielding;
end;

:: PARTFUN3:funcreg 20
registration
  let a1 be set;
  let a2 be Function-like positive-yielding Relation of a1,REAL;
  let a3 be Function-like nonpositive-yielding Relation of a1,REAL;
  cluster a2 - a3 -> Relation-like Function-like positive-yielding;
end;

:: PARTFUN3:funcreg 21
registration
  let a1 be set;
  let a2 be Function-like nonpositive-yielding Relation of a1,REAL;
  let a3 be Function-like positive-yielding Relation of a1,REAL;
  cluster a2 - a3 -> Relation-like Function-like negative-yielding;
end;

:: PARTFUN3:funcreg 22
registration
  let a1 be set;
  let a2 be Function-like negative-yielding Relation of a1,REAL;
  let a3 be Function-like nonnegative-yielding Relation of a1,REAL;
  cluster a2 - a3 -> Relation-like Function-like negative-yielding;
end;

:: PARTFUN3:funcreg 23
registration
  let a1 be set;
  let a2 be Function-like nonnegative-yielding Relation of a1,REAL;
  let a3 be Function-like negative-yielding Relation of a1,REAL;
  cluster a2 - a3 -> Relation-like Function-like positive-yielding;
end;

:: PARTFUN3:funcreg 24
registration
  let a1 be set;
  let a2, a3 be Function-like nonpositive-yielding Relation of a1,REAL;
  cluster a2 (#) a3 -> Relation-like Function-like nonnegative-yielding;
end;

:: PARTFUN3:funcreg 25
registration
  let a1 be set;
  let a2, a3 be Function-like nonnegative-yielding Relation of a1,REAL;
  cluster a2 (#) a3 -> Relation-like Function-like nonnegative-yielding;
end;

:: PARTFUN3:funcreg 26
registration
  let a1 be set;
  let a2 be Function-like nonpositive-yielding Relation of a1,REAL;
  let a3 be Function-like nonnegative-yielding Relation of a1,REAL;
  cluster a2 (#) a3 -> Relation-like Function-like nonpositive-yielding;
end;

:: PARTFUN3:funcreg 27
registration
  let a1 be set;
  let a2 be Function-like nonnegative-yielding Relation of a1,REAL;
  let a3 be Function-like nonpositive-yielding Relation of a1,REAL;
  cluster a2 (#) a3 -> Relation-like Function-like nonpositive-yielding;
end;

:: PARTFUN3:funcreg 28
registration
  let a1 be set;
  let a2 be Function-like positive-yielding Relation of a1,REAL;
  let a3 be Function-like negative-yielding Relation of a1,REAL;
  cluster a2 (#) a3 -> Relation-like Function-like negative-yielding;
end;

:: PARTFUN3:funcreg 29
registration
  let a1 be set;
  let a2 be Function-like negative-yielding Relation of a1,REAL;
  let a3 be Function-like positive-yielding Relation of a1,REAL;
  cluster a2 (#) a3 -> Relation-like Function-like negative-yielding;
end;

:: PARTFUN3:funcreg 30
registration
  let a1 be set;
  let a2, a3 be Function-like positive-yielding Relation of a1,REAL;
  cluster a2 (#) a3 -> Relation-like Function-like positive-yielding;
end;

:: PARTFUN3:funcreg 31
registration
  let a1 be set;
  let a2, a3 be Function-like negative-yielding Relation of a1,REAL;
  cluster a2 (#) a3 -> Relation-like Function-like positive-yielding;
end;

:: PARTFUN3:funcreg 32
registration
  let a1 be set;
  let a2, a3 be non-empty Function-like Relation of a1,REAL;
  cluster a2 (#) a3 -> Relation-like non-empty Function-like;
end;

:: PARTFUN3:funcreg 33
registration
  let a1 be set;
  let a2 be Function-like Relation of a1,REAL;
  cluster a2 (#) a2 -> Relation-like Function-like nonnegative-yielding;
end;

:: PARTFUN3:funcreg 34
registration
  let a1 be set;
  let a2 be real non positive set;
  let a3 be Function-like nonpositive-yielding Relation of a1,REAL;
  cluster a2 (#) a3 -> Relation-like Function-like nonnegative-yielding;
end;

:: PARTFUN3:funcreg 35
registration
  let a1 be set;
  let a2 be real non negative set;
  let a3 be Function-like nonnegative-yielding Relation of a1,REAL;
  cluster a2 (#) a3 -> Relation-like Function-like nonnegative-yielding;
end;

:: PARTFUN3:funcreg 36
registration
  let a1 be set;
  let a2 be real non positive set;
  let a3 be Function-like nonnegative-yielding Relation of a1,REAL;
  cluster a2 (#) a3 -> Relation-like Function-like nonpositive-yielding;
end;

:: PARTFUN3:funcreg 37
registration
  let a1 be set;
  let a2 be real non negative set;
  let a3 be Function-like nonpositive-yielding Relation of a1,REAL;
  cluster a2 (#) a3 -> Relation-like Function-like nonpositive-yielding;
end;

:: PARTFUN3:funcreg 38
registration
  let a1 be set;
  let a2 be real positive set;
  let a3 be Function-like negative-yielding Relation of a1,REAL;
  cluster a2 (#) a3 -> Relation-like Function-like negative-yielding;
end;

:: PARTFUN3:funcreg 39
registration
  let a1 be set;
  let a2 be real negative set;
  let a3 be Function-like positive-yielding Relation of a1,REAL;
  cluster a2 (#) a3 -> Relation-like Function-like negative-yielding;
end;

:: PARTFUN3:funcreg 40
registration
  let a1 be set;
  let a2 be real positive set;
  let a3 be Function-like positive-yielding Relation of a1,REAL;
  cluster a2 (#) a3 -> Relation-like Function-like positive-yielding;
end;

:: PARTFUN3:funcreg 41
registration
  let a1 be set;
  let a2 be real negative set;
  let a3 be Function-like negative-yielding Relation of a1,REAL;
  cluster a2 (#) a3 -> Relation-like Function-like positive-yielding;
end;

:: PARTFUN3:funcreg 42
registration
  let a1 be set;
  let a2 be non empty real set;
  let a3 be non-empty Function-like Relation of a1,REAL;
  cluster a2 (#) a3 -> Relation-like non-empty Function-like;
end;

:: PARTFUN3:funcreg 43
registration
  let a1 be non empty set;
  let a2, a3 be Function-like nonpositive-yielding Relation of a1,REAL;
  cluster a2 / a3 -> Relation-like Function-like nonnegative-yielding;
end;

:: PARTFUN3:funcreg 44
registration
  let a1 be non empty set;
  let a2, a3 be Function-like nonnegative-yielding Relation of a1,REAL;
  cluster a2 / a3 -> Relation-like Function-like nonnegative-yielding;
end;

:: PARTFUN3:funcreg 45
registration
  let a1 be non empty set;
  let a2 be Function-like nonpositive-yielding Relation of a1,REAL;
  let a3 be Function-like nonnegative-yielding Relation of a1,REAL;
  cluster a2 / a3 -> Relation-like Function-like nonpositive-yielding;
end;

:: PARTFUN3:funcreg 46
registration
  let a1 be non empty set;
  let a2 be Function-like nonnegative-yielding Relation of a1,REAL;
  let a3 be Function-like nonpositive-yielding Relation of a1,REAL;
  cluster a2 / a3 -> Relation-like Function-like nonpositive-yielding;
end;

:: PARTFUN3:funcreg 47
registration
  let a1 be non empty set;
  let a2 be Function-like positive-yielding Relation of a1,REAL;
  let a3 be Function-like negative-yielding Relation of a1,REAL;
  cluster a2 / a3 -> Relation-like Function-like negative-yielding;
end;

:: PARTFUN3:funcreg 48
registration
  let a1 be non empty set;
  let a2 be Function-like negative-yielding Relation of a1,REAL;
  let a3 be Function-like positive-yielding Relation of a1,REAL;
  cluster a2 / a3 -> Relation-like Function-like negative-yielding;
end;

:: PARTFUN3:funcreg 49
registration
  let a1 be non empty set;
  let a2, a3 be Function-like positive-yielding Relation of a1,REAL;
  cluster a2 / a3 -> Relation-like Function-like positive-yielding;
end;

:: PARTFUN3:funcreg 50
registration
  let a1 be non empty set;
  let a2, a3 be Function-like negative-yielding Relation of a1,REAL;
  cluster a2 / a3 -> Relation-like Function-like positive-yielding;
end;

:: PARTFUN3:funcreg 51
registration
  let a1 be non empty set;
  let a2 be Function-like Relation of a1,REAL;
  cluster a2 / a2 -> Relation-like Function-like nonnegative-yielding;
end;

:: PARTFUN3:funcreg 52
registration
  let a1 be non empty set;
  let a2, a3 be non-empty Function-like Relation of a1,REAL;
  cluster a2 / a3 -> Relation-like non-empty Function-like;
end;

:: PARTFUN3:funcreg 53
registration
  let a1 be set;
  let a2 be Function-like quasi_total nonpositive-yielding Relation of a1,REAL;
  cluster a2 " -> Relation-like Function-like complex-valued nonpositive-yielding;
end;

:: PARTFUN3:funcreg 54
registration
  let a1 be set;
  let a2 be Function-like quasi_total nonnegative-yielding Relation of a1,REAL;
  cluster a2 " -> Relation-like Function-like complex-valued nonnegative-yielding;
end;

:: PARTFUN3:funcreg 55
registration
  let a1 be set;
  let a2 be Function-like quasi_total positive-yielding Relation of a1,REAL;
  cluster a2 " -> Relation-like Function-like complex-valued positive-yielding;
end;

:: PARTFUN3:funcreg 56
registration
  let a1 be set;
  let a2 be Function-like quasi_total negative-yielding Relation of a1,REAL;
  cluster a2 " -> Relation-like Function-like complex-valued negative-yielding;
end;

:: PARTFUN3:funcreg 57
registration
  let a1 be set;
  let a2 be non-empty Function-like quasi_total Relation of a1,REAL;
  cluster a2 " -> Relation-like non-empty Function-like complex-valued;
end;

:: PARTFUN3:funcreg 58
registration
  let a1 be set;
  let a2 be non-empty Function-like quasi_total Relation of a1,REAL;
  cluster - a2 -> Relation-like non-empty Function-like complex-valued;
end;

:: PARTFUN3:funcreg 59
registration
  let a1 be set;
  let a2 be Function-like quasi_total nonpositive-yielding Relation of a1,REAL;
  cluster - a2 -> Relation-like Function-like complex-valued nonnegative-yielding;
end;

:: PARTFUN3:funcreg 60
registration
  let a1 be set;
  let a2 be Function-like quasi_total nonnegative-yielding Relation of a1,REAL;
  cluster - a2 -> Relation-like Function-like complex-valued nonpositive-yielding;
end;

:: PARTFUN3:funcreg 61
registration
  let a1 be set;
  let a2 be Function-like quasi_total positive-yielding Relation of a1,REAL;
  cluster - a2 -> Relation-like Function-like complex-valued negative-yielding;
end;

:: PARTFUN3:funcreg 62
registration
  let a1 be set;
  let a2 be Function-like quasi_total negative-yielding Relation of a1,REAL;
  cluster - a2 -> Relation-like Function-like complex-valued positive-yielding;
end;

:: PARTFUN3:funcreg 63
registration
  let a1 be set;
  let a2 be Function-like quasi_total Relation of a1,REAL;
  cluster |.a2.| -> Relation-like Function-like real-valued nonnegative-yielding;
end;

:: PARTFUN3:funcreg 64
registration
  let a1 be set;
  let a2 be non-empty Function-like quasi_total Relation of a1,REAL;
  cluster |.a2.| -> Relation-like Function-like real-valued positive-yielding;
end;

:: PARTFUN3:funcreg 65
registration
  let a1 be non empty set;
  let a2 be Function-like quasi_total nonpositive-yielding Relation of a1,REAL;
  cluster a2 ^ -> Relation-like Function-like nonpositive-yielding;
end;

:: PARTFUN3:funcreg 66
registration
  let a1 be non empty set;
  let a2 be Function-like quasi_total nonnegative-yielding Relation of a1,REAL;
  cluster a2 ^ -> Relation-like Function-like nonnegative-yielding;
end;

:: PARTFUN3:funcreg 67
registration
  let a1 be non empty set;
  let a2 be Function-like quasi_total positive-yielding Relation of a1,REAL;
  cluster a2 ^ -> Relation-like Function-like positive-yielding;
end;

:: PARTFUN3:funcreg 68
registration
  let a1 be non empty set;
  let a2 be Function-like quasi_total negative-yielding Relation of a1,REAL;
  cluster a2 ^ -> Relation-like Function-like negative-yielding;
end;

:: PARTFUN3:funcreg 69
registration
  let a1 be non empty set;
  let a2 be non-empty Function-like quasi_total Relation of a1,REAL;
  cluster a2 ^ -> Relation-like non-empty Function-like;
end;

:: PARTFUN3:funcnot 1 => PARTFUN3:func 1
definition
  let a1 be Relation-like Function-like real-valued set;
  func sqrt A1 -> Relation-like Function-like set means
    proj1 it = proj1 a1 &
     (for b1 being set
           st b1 in proj1 it
        holds it . b1 = sqrt (a1 . b1));
end;

:: PARTFUN3:def 5
theorem
for b1 being Relation-like Function-like real-valued set
for b2 being Relation-like Function-like set holds
      b2 = sqrt b1
   iff
      proj1 b2 = proj1 b1 &
       (for b3 being set
             st b3 in proj1 b2
          holds b2 . b3 = sqrt (b1 . b3));

:: PARTFUN3:funcreg 70
registration
  let a1 be Relation-like Function-like real-valued set;
  cluster sqrt a1 -> Relation-like Function-like real-valued;
end;

:: PARTFUN3:funcnot 2 => PARTFUN3:func 2
definition
  let a1 be set;
  let a2 be real-membered set;
  let a3 be Function-like Relation of a1,a2;
  redefine func sqrt a3 -> Function-like Relation of a1,REAL;
end;

:: PARTFUN3:funcreg 71
registration
  let a1 be set;
  let a2 be Function-like quasi_total nonnegative-yielding Relation of a1,REAL;
  cluster sqrt a2 -> Relation-like Function-like nonnegative-yielding;
end;

:: PARTFUN3:funcreg 72
registration
  let a1 be set;
  let a2 be Function-like quasi_total positive-yielding Relation of a1,REAL;
  cluster sqrt a2 -> Relation-like Function-like positive-yielding;
end;

:: PARTFUN3:funcnot 3 => PARTFUN3:func 3
definition
  let a1 be set;
  let a2 be Function-like quasi_total Relation of a1,REAL;
  redefine func sqrt a2 -> Function-like quasi_total Relation of a1,REAL;
end;

:: PARTFUN3:funcnot 4 => PARTFUN3:func 4
definition
  let a1 be set;
  let a2 be non-empty Function-like quasi_total Relation of a1,REAL;
  redefine func a2 ^ -> Function-like quasi_total Relation of a1,REAL;
end;

:: PARTFUN3:funcnot 5 => PARTFUN3:func 5
definition
  let a1 be non empty set;
  let a2 be Function-like quasi_total Relation of a1,REAL;
  let a3 be non-empty Function-like quasi_total Relation of a1,REAL;
  redefine func a2 / a3 -> Function-like quasi_total Relation of a1,REAL;
end;

:: PARTFUN3:funcnot 6 => PARTFUN3:func 6
definition
  let a1 be non empty TopSpace-like TopStruct;
  let a2, a3 be Function-like quasi_total continuous Relation of the carrier of a1,REAL;
  redefine func a2 + a3 -> Function-like quasi_total continuous Relation of the carrier of a1,REAL;
  commutativity;
::  for a1 being non empty TopSpace-like TopStruct
::  for a2, a3 being Function-like quasi_total continuous Relation of the carrier of a1,REAL holds
::  a2 + a3 = a3 + a2;
end;

:: PARTFUN3:funcnot 7 => PARTFUN3:func 7
definition
  let a1 be non empty TopSpace-like TopStruct;
  let a2, a3 be Function-like quasi_total continuous Relation of the carrier of a1,REAL;
  redefine func a2 - a3 -> Function-like quasi_total continuous Relation of the carrier of a1,REAL;
end;

:: PARTFUN3:funcnot 8 => PARTFUN3:func 8
definition
  let a1 be non empty TopSpace-like TopStruct;
  let a2, a3 be Function-like quasi_total continuous Relation of the carrier of a1,REAL;
  redefine func a2 (#) a3 -> Function-like quasi_total continuous Relation of the carrier of a1,REAL;
  commutativity;
::  for a1 being non empty TopSpace-like TopStruct
::  for a2, a3 being Function-like quasi_total continuous Relation of the carrier of a1,REAL holds
::  a2 (#) a3 = a3 (#) a2;
end;

:: PARTFUN3:funcnot 9 => PARTFUN3:func 9
definition
  let a1 be non empty TopSpace-like TopStruct;
  let a2 be Function-like quasi_total continuous Relation of the carrier of a1,REAL;
  redefine func - a2 -> Function-like quasi_total continuous Relation of the carrier of a1,REAL;
  involutiveness;
::  for a1 being non empty TopSpace-like TopStruct
::  for a2 being Function-like quasi_total continuous Relation of the carrier of a1,REAL holds
::     - - a2 = a2;
end;

:: PARTFUN3:funcnot 10 => PARTFUN3:func 10
definition
  let a1 be non empty TopSpace-like TopStruct;
  let a2 be Function-like quasi_total continuous Relation of the carrier of a1,REAL;
  redefine func abs a2 -> Function-like quasi_total continuous Relation of the carrier of a1,REAL;
  projectivity;
::  for a1 being non empty TopSpace-like TopStruct
::  for a2 being Function-like quasi_total continuous Relation of the carrier of a1,REAL holds
::     abs abs a2 = abs a2;
end;

:: PARTFUN3:exreg 4
registration
  let a1 be non empty TopSpace-like TopStruct;
  cluster Relation-like Function-like non empty quasi_total complex-valued ext-real-valued real-valued continuous total positive-yielding Relation of the carrier of a1,REAL;
end;

:: PARTFUN3:exreg 5
registration
  let a1 be non empty TopSpace-like TopStruct;
  cluster Relation-like Function-like non empty quasi_total complex-valued ext-real-valued real-valued continuous total negative-yielding Relation of the carrier of a1,REAL;
end;

:: PARTFUN3:funcnot 11 => PARTFUN3:func 11
definition
  let a1 be non empty TopSpace-like TopStruct;
  let a2 be Function-like quasi_total continuous nonnegative-yielding Relation of the carrier of a1,REAL;
  redefine func sqrt a2 -> Function-like quasi_total continuous Relation of the carrier of a1,REAL;
end;

:: PARTFUN3:funcnot 12 => PARTFUN3:func 12
definition
  let a1 be non empty TopSpace-like TopStruct;
  let a2 be Function-like quasi_total continuous Relation of the carrier of a1,REAL;
  let a3 be real set;
  redefine func a3 (#) a2 -> Function-like quasi_total continuous Relation of the carrier of a1,REAL;
end;

:: PARTFUN3:funcnot 13 => PARTFUN3:func 13
definition
  let a1 be non empty TopSpace-like TopStruct;
  let a2 be non-empty Function-like quasi_total continuous Relation of the carrier of a1,REAL;
  redefine func a2 ^ -> Function-like quasi_total continuous Relation of the carrier of a1,REAL;
end;

:: PARTFUN3:funcnot 14 => PARTFUN3:func 14
definition
  let a1 be non empty TopSpace-like TopStruct;
  let a2 be Function-like quasi_total continuous Relation of the carrier of a1,REAL;
  let a3 be non-empty Function-like quasi_total continuous Relation of the carrier of a1,REAL;
  redefine func a2 / a3 -> Function-like quasi_total continuous Relation of the carrier of a1,REAL;
end;