Article VALUED_1, MML version 4.99.1005

:: VALUED_1:exreg 1
registration
  cluster Relation-like Function-like complex-valued FinSequence-like set;
end;

:: VALUED_1:funcreg 1
registration
  let a1 be rational set;
  cluster |.a1.| -> rational complex;
end;

:: VALUED_1:funcnot 1 => VALUED_1:func 1
definition
  let a1, a2 be Relation-like Function-like complex-valued set;
  func A1 + A2 -> Relation-like Function-like set means
    proj1 it = (proj1 a1) /\ proj1 a2 &
     (for b1 being set
           st b1 in proj1 it
        holds it . b1 = (a1 . b1) + (a2 . b1));
  commutativity;
::  for a1, a2 being Relation-like Function-like complex-valued set holds
::  a1 + a2 = a2 + a1;
end;

:: VALUED_1:def 1
theorem
for b1, b2 being Relation-like Function-like complex-valued set
for b3 being Relation-like Function-like set holds
      b3 = b1 + b2
   iff
      proj1 b3 = (proj1 b1) /\ proj1 b2 &
       (for b4 being set
             st b4 in proj1 b3
          holds b3 . b4 = (b1 . b4) + (b2 . b4));

:: VALUED_1:funcreg 2
registration
  let a1, a2 be Relation-like Function-like complex-valued set;
  cluster a1 + a2 -> Relation-like Function-like complex-valued;
end;

:: VALUED_1:funcreg 3
registration
  let a1, a2 be Relation-like Function-like real-valued set;
  cluster a1 + a2 -> Relation-like Function-like real-valued;
end;

:: VALUED_1:funcreg 4
registration
  let a1, a2 be Relation-like Function-like rational-valued set;
  cluster a1 + a2 -> Relation-like Function-like rational-valued;
end;

:: VALUED_1:funcreg 5
registration
  let a1, a2 be Relation-like Function-like integer-valued set;
  cluster a1 + a2 -> Relation-like Function-like integer-valued;
end;

:: VALUED_1:funcreg 6
registration
  let a1, a2 be Relation-like Function-like natural-valued set;
  cluster a1 + a2 -> Relation-like Function-like natural-valued;
end;

:: VALUED_1:funcnot 2 => VALUED_1:func 2
definition
  let a1 be set;
  let a2, a3 be complex-membered set;
  let a4 be Function-like Relation of a1,a2;
  let a5 be Function-like Relation of a1,a3;
  redefine func a4 + a5 -> Function-like Relation of a1,COMPLEX;
  commutativity;
::  for a1 being set
::  for a2, a3 being complex-membered set
::  for a4 being Function-like Relation of a1,a2
::  for a5 being Function-like Relation of a1,a3 holds
::     a4 + a5 = a5 + a4;
end;

:: VALUED_1:funcnot 3 => VALUED_1:func 3
definition
  let a1 be set;
  let a2, a3 be real-membered set;
  let a4 be Function-like Relation of a1,a2;
  let a5 be Function-like Relation of a1,a3;
  redefine func a4 + a5 -> Function-like Relation of a1,REAL;
  commutativity;
::  for a1 being set
::  for a2, a3 being real-membered set
::  for a4 being Function-like Relation of a1,a2
::  for a5 being Function-like Relation of a1,a3 holds
::     a4 + a5 = a5 + a4;
end;

:: VALUED_1:funcnot 4 => VALUED_1:func 4
definition
  let a1 be set;
  let a2, a3 be rational-membered set;
  let a4 be Function-like Relation of a1,a2;
  let a5 be Function-like Relation of a1,a3;
  redefine func a4 + a5 -> Function-like Relation of a1,RAT;
  commutativity;
::  for a1 being set
::  for a2, a3 being rational-membered set
::  for a4 being Function-like Relation of a1,a2
::  for a5 being Function-like Relation of a1,a3 holds
::     a4 + a5 = a5 + a4;
end;

:: VALUED_1:funcnot 5 => VALUED_1:func 5
definition
  let a1 be set;
  let a2, a3 be integer-membered set;
  let a4 be Function-like Relation of a1,a2;
  let a5 be Function-like Relation of a1,a3;
  redefine func a4 + a5 -> Function-like Relation of a1,INT;
  commutativity;
::  for a1 being set
::  for a2, a3 being integer-membered set
::  for a4 being Function-like Relation of a1,a2
::  for a5 being Function-like Relation of a1,a3 holds
::     a4 + a5 = a5 + a4;
end;

:: VALUED_1:funcnot 6 => VALUED_1:func 6
definition
  let a1 be set;
  let a2, a3 be natural-membered set;
  let a4 be Function-like Relation of a1,a2;
  let a5 be Function-like Relation of a1,a3;
  redefine func a4 + a5 -> Function-like Relation of a1,NAT;
  commutativity;
::  for a1 being set
::  for a2, a3 being natural-membered set
::  for a4 being Function-like Relation of a1,a2
::  for a5 being Function-like Relation of a1,a3 holds
::     a4 + a5 = a5 + a4;
end;

:: VALUED_1:funcreg 7
registration
  let a1 be set;
  let a2, a3 be non empty complex-membered set;
  let a4 be Function-like quasi_total Relation of a1,a2;
  let a5 be Function-like quasi_total Relation of a1,a3;
  cluster a4 + a5 -> Function-like total;
end;

:: VALUED_1:funcreg 8
registration
  let a1 be set;
  let a2, a3 be non empty real-membered set;
  let a4 be Function-like quasi_total Relation of a1,a2;
  let a5 be Function-like quasi_total Relation of a1,a3;
  cluster a4 + a5 -> Function-like total;
end;

:: VALUED_1:funcreg 9
registration
  let a1 be set;
  let a2, a3 be non empty rational-membered set;
  let a4 be Function-like quasi_total Relation of a1,a2;
  let a5 be Function-like quasi_total Relation of a1,a3;
  cluster a4 + a5 -> Function-like total;
end;

:: VALUED_1:funcreg 10
registration
  let a1 be set;
  let a2, a3 be non empty integer-membered set;
  let a4 be Function-like quasi_total Relation of a1,a2;
  let a5 be Function-like quasi_total Relation of a1,a3;
  cluster a4 + a5 -> Function-like total;
end;

:: VALUED_1:funcreg 11
registration
  let a1 be set;
  let a2, a3 be non empty natural-membered set;
  let a4 be Function-like quasi_total Relation of a1,a2;
  let a5 be Function-like quasi_total Relation of a1,a3;
  cluster a4 + a5 -> Function-like total;
end;

:: VALUED_1:th 1
theorem
for b1 being set
for b2, b3 being non empty complex-membered set
for b4 being Function-like quasi_total Relation of b1,b2
for b5 being Function-like quasi_total Relation of b1,b3
for b6 being Element of b1 holds
   (b4 + b5) . b6 = (b4 . b6) + (b5 . b6);

:: VALUED_1:funcreg 12
registration
  let a1, a2 be Relation-like Function-like complex-valued FinSequence-like set;
  cluster a1 + a2 -> Relation-like Function-like FinSequence-like;
end;

:: VALUED_1:funcnot 7 => VALUED_1:func 7
definition
  let a1 be Relation-like Function-like complex-valued set;
  let a2 be complex set;
  func A2 + A1 -> Relation-like Function-like set means
    proj1 it = proj1 a1 &
     (for b1 being set
           st b1 in proj1 it
        holds it . b1 = a2 + (a1 . b1));
end;

:: VALUED_1:def 2
theorem
for b1 being Relation-like Function-like complex-valued set
for b2 being complex set
for b3 being Relation-like Function-like set holds
      b3 = b2 + b1
   iff
      proj1 b3 = proj1 b1 &
       (for b4 being set
             st b4 in proj1 b3
          holds b3 . b4 = b2 + (b1 . b4));

:: VALUED_1:funcnot 8 => VALUED_1:func 7
notation
  let a1 be Relation-like Function-like complex-valued set;
  let a2 be complex set;
  synonym a1 + a2 for a2 + a1;
end;

:: VALUED_1:funcreg 13
registration
  let a1 be Relation-like Function-like complex-valued set;
  let a2 be complex set;
  cluster a2 + a1 -> Relation-like Function-like complex-valued;
end;

:: VALUED_1:funcreg 14
registration
  let a1 be Relation-like Function-like real-valued set;
  let a2 be real set;
  cluster a2 + a1 -> Relation-like Function-like real-valued;
end;

:: VALUED_1:funcreg 15
registration
  let a1 be Relation-like Function-like rational-valued set;
  let a2 be rational set;
  cluster a2 + a1 -> Relation-like Function-like rational-valued;
end;

:: VALUED_1:funcreg 16
registration
  let a1 be Relation-like Function-like integer-valued set;
  let a2 be integer set;
  cluster a2 + a1 -> Relation-like Function-like integer-valued;
end;

:: VALUED_1:funcreg 17
registration
  let a1 be Relation-like Function-like natural-valued set;
  let a2 be natural set;
  cluster a2 + a1 -> Relation-like Function-like natural-valued;
end;

:: VALUED_1:funcnot 9 => VALUED_1:func 8
definition
  let a1 be set;
  let a2 be complex-membered set;
  let a3 be Function-like Relation of a1,a2;
  let a4 be complex set;
  redefine func a4 + a3 -> Function-like Relation of a1,COMPLEX;
end;

:: VALUED_1:funcnot 10 => VALUED_1:func 9
definition
  let a1 be set;
  let a2 be real-membered set;
  let a3 be Function-like Relation of a1,a2;
  let a4 be real set;
  redefine func a4 + a3 -> Function-like Relation of a1,REAL;
end;

:: VALUED_1:funcnot 11 => VALUED_1:func 10
definition
  let a1 be set;
  let a2 be rational-membered set;
  let a3 be Function-like Relation of a1,a2;
  let a4 be rational set;
  redefine func a4 + a3 -> Function-like Relation of a1,RAT;
end;

:: VALUED_1:funcnot 12 => VALUED_1:func 11
definition
  let a1 be set;
  let a2 be integer-membered set;
  let a3 be Function-like Relation of a1,a2;
  let a4 be integer set;
  redefine func a4 + a3 -> Function-like Relation of a1,INT;
end;

:: VALUED_1:funcnot 13 => VALUED_1:func 12
definition
  let a1 be set;
  let a2 be natural-membered set;
  let a3 be Function-like Relation of a1,a2;
  let a4 be natural set;
  redefine func a4 + a3 -> Function-like Relation of a1,NAT;
end;

:: VALUED_1:funcreg 18
registration
  let a1 be set;
  let a2 be non empty complex-membered set;
  let a3 be Function-like quasi_total Relation of a1,a2;
  let a4 be complex set;
  cluster a4 + a3 -> Function-like total;
end;

:: VALUED_1:funcreg 19
registration
  let a1 be set;
  let a2 be non empty real-membered set;
  let a3 be Function-like quasi_total Relation of a1,a2;
  let a4 be real set;
  cluster a4 + a3 -> Function-like total;
end;

:: VALUED_1:funcreg 20
registration
  let a1 be set;
  let a2 be non empty rational-membered set;
  let a3 be Function-like quasi_total Relation of a1,a2;
  let a4 be rational set;
  cluster a4 + a3 -> Function-like total;
end;

:: VALUED_1:funcreg 21
registration
  let a1 be set;
  let a2 be non empty integer-membered set;
  let a3 be Function-like quasi_total Relation of a1,a2;
  let a4 be integer set;
  cluster a4 + a3 -> Function-like total;
end;

:: VALUED_1:funcreg 22
registration
  let a1 be set;
  let a2 be non empty natural-membered set;
  let a3 be Function-like quasi_total Relation of a1,a2;
  let a4 be natural set;
  cluster a4 + a3 -> Function-like total;
end;

:: VALUED_1:th 2
theorem
for b1 being non empty set
for b2 being non empty complex-membered set
for b3 being Function-like quasi_total Relation of b1,b2
for b4 being complex set
for b5 being Element of b1 holds
   (b4 + b3) . b5 = b4 + (b3 . b5);

:: VALUED_1:funcreg 23
registration
  let a1 be Relation-like Function-like complex-valued FinSequence-like set;
  let a2 be complex set;
  cluster a2 + a1 -> Relation-like Function-like FinSequence-like;
end;

:: VALUED_1:funcnot 14 => VALUED_1:func 13
definition
  let a1 be Relation-like Function-like complex-valued set;
  let a2 be complex set;
  func A1 - A2 -> Relation-like Function-like set equals
    (- a2) + a1;
end;

:: VALUED_1:def 3
theorem
for b1 being Relation-like Function-like complex-valued set
for b2 being complex set holds
   b1 - b2 = (- b2) + b1;

:: VALUED_1:th 3
theorem
for b1 being Relation-like Function-like complex-valued set
for b2 being complex set holds
   proj1 (b1 - b2) = proj1 b1 &
    (for b3 being set
          st b3 in proj1 b1
       holds (b1 - b2) . b3 = (b1 . b3) - b2);

:: VALUED_1:funcreg 24
registration
  let a1 be Relation-like Function-like complex-valued set;
  let a2 be complex set;
  cluster a1 - a2 -> Relation-like Function-like complex-valued;
end;

:: VALUED_1:funcreg 25
registration
  let a1 be Relation-like Function-like real-valued set;
  let a2 be real set;
  cluster a1 - a2 -> Relation-like Function-like real-valued;
end;

:: VALUED_1:funcreg 26
registration
  let a1 be Relation-like Function-like rational-valued set;
  let a2 be rational set;
  cluster a1 - a2 -> Relation-like Function-like rational-valued;
end;

:: VALUED_1:funcreg 27
registration
  let a1 be Relation-like Function-like integer-valued set;
  let a2 be integer set;
  cluster a1 - a2 -> Relation-like Function-like integer-valued;
end;

:: VALUED_1:funcnot 15 => VALUED_1:func 14
definition
  let a1 be set;
  let a2 be complex-membered set;
  let a3 be Function-like Relation of a1,a2;
  let a4 be complex set;
  redefine func a3 - a4 -> Function-like Relation of a1,COMPLEX;
end;

:: VALUED_1:funcnot 16 => VALUED_1:func 15
definition
  let a1 be set;
  let a2 be real-membered set;
  let a3 be Function-like Relation of a1,a2;
  let a4 be real set;
  redefine func a3 - a4 -> Function-like Relation of a1,REAL;
end;

:: VALUED_1:funcnot 17 => VALUED_1:func 16
definition
  let a1 be set;
  let a2 be rational-membered set;
  let a3 be Function-like Relation of a1,a2;
  let a4 be rational set;
  redefine func a3 - a4 -> Function-like Relation of a1,RAT;
end;

:: VALUED_1:funcnot 18 => VALUED_1:func 17
definition
  let a1 be set;
  let a2 be integer-membered set;
  let a3 be Function-like Relation of a1,a2;
  let a4 be integer set;
  redefine func a3 - a4 -> Function-like Relation of a1,INT;
end;

:: VALUED_1:funcreg 28
registration
  let a1 be set;
  let a2 be non empty complex-membered set;
  let a3 be Function-like quasi_total Relation of a1,a2;
  let a4 be complex set;
  cluster a3 - a4 -> Function-like total;
end;

:: VALUED_1:funcreg 29
registration
  let a1 be set;
  let a2 be non empty real-membered set;
  let a3 be Function-like quasi_total Relation of a1,a2;
  let a4 be real set;
  cluster a3 - a4 -> Function-like total;
end;

:: VALUED_1:funcreg 30
registration
  let a1 be set;
  let a2 be non empty rational-membered set;
  let a3 be Function-like quasi_total Relation of a1,a2;
  let a4 be rational set;
  cluster a3 - a4 -> Function-like total;
end;

:: VALUED_1:funcreg 31
registration
  let a1 be set;
  let a2 be non empty integer-membered set;
  let a3 be Function-like quasi_total Relation of a1,a2;
  let a4 be integer set;
  cluster a3 - a4 -> Function-like total;
end;

:: VALUED_1:th 4
theorem
for b1 being non empty set
for b2 being non empty complex-membered set
for b3 being Function-like quasi_total Relation of b1,b2
for b4 being complex set
for b5 being Element of b1 holds
   (b3 - b4) . b5 = (b3 . b5) - b4;

:: VALUED_1:funcreg 32
registration
  let a1 be Relation-like Function-like complex-valued FinSequence-like set;
  let a2 be complex set;
  cluster a1 - a2 -> Relation-like Function-like FinSequence-like;
end;

:: VALUED_1:funcnot 19 => VALUED_1:func 18
definition
  let a1, a2 be Relation-like Function-like complex-valued set;
  func A1 (#) A2 -> Relation-like Function-like set means
    proj1 it = (proj1 a1) /\ proj1 a2 &
     (for b1 being set
           st b1 in proj1 it
        holds it . b1 = (a1 . b1) * (a2 . b1));
  commutativity;
::  for a1, a2 being Relation-like Function-like complex-valued set holds
::  a1 (#) a2 = a2 (#) a1;
end;

:: VALUED_1:def 4
theorem
for b1, b2 being Relation-like Function-like complex-valued set
for b3 being Relation-like Function-like set holds
      b3 = b1 (#) b2
   iff
      proj1 b3 = (proj1 b1) /\ proj1 b2 &
       (for b4 being set
             st b4 in proj1 b3
          holds b3 . b4 = (b1 . b4) * (b2 . b4));

:: VALUED_1:th 5
theorem
for b1, b2 being Relation-like Function-like complex-valued set
for b3 being set holds
   (b1 (#) b2) . b3 = (b1 . b3) * (b2 . b3);

:: VALUED_1:funcreg 33
registration
  let a1, a2 be Relation-like Function-like complex-valued set;
  cluster a1 (#) a2 -> Relation-like Function-like complex-valued;
end;

:: VALUED_1:funcreg 34
registration
  let a1, a2 be Relation-like Function-like real-valued set;
  cluster a1 (#) a2 -> Relation-like Function-like real-valued;
end;

:: VALUED_1:funcreg 35
registration
  let a1, a2 be Relation-like Function-like rational-valued set;
  cluster a1 (#) a2 -> Relation-like Function-like rational-valued;
end;

:: VALUED_1:funcreg 36
registration
  let a1, a2 be Relation-like Function-like integer-valued set;
  cluster a1 (#) a2 -> Relation-like Function-like integer-valued;
end;

:: VALUED_1:funcreg 37
registration
  let a1, a2 be Relation-like Function-like natural-valued set;
  cluster a1 (#) a2 -> Relation-like Function-like natural-valued;
end;

:: VALUED_1:funcnot 20 => VALUED_1:func 19
definition
  let a1 be set;
  let a2, a3 be complex-membered set;
  let a4 be Function-like Relation of a1,a2;
  let a5 be Function-like Relation of a1,a3;
  redefine func a4 (#) a5 -> Function-like Relation of a1,COMPLEX;
  commutativity;
::  for a1 being set
::  for a2, a3 being complex-membered set
::  for a4 being Function-like Relation of a1,a2
::  for a5 being Function-like Relation of a1,a3 holds
::     a4 (#) a5 = a5 (#) a4;
end;

:: VALUED_1:funcnot 21 => VALUED_1:func 20
definition
  let a1 be set;
  let a2, a3 be real-membered set;
  let a4 be Function-like Relation of a1,a2;
  let a5 be Function-like Relation of a1,a3;
  redefine func a4 (#) a5 -> Function-like Relation of a1,REAL;
  commutativity;
::  for a1 being set
::  for a2, a3 being real-membered set
::  for a4 being Function-like Relation of a1,a2
::  for a5 being Function-like Relation of a1,a3 holds
::     a4 (#) a5 = a5 (#) a4;
end;

:: VALUED_1:funcnot 22 => VALUED_1:func 21
definition
  let a1 be set;
  let a2, a3 be rational-membered set;
  let a4 be Function-like Relation of a1,a2;
  let a5 be Function-like Relation of a1,a3;
  redefine func a4 (#) a5 -> Function-like Relation of a1,RAT;
  commutativity;
::  for a1 being set
::  for a2, a3 being rational-membered set
::  for a4 being Function-like Relation of a1,a2
::  for a5 being Function-like Relation of a1,a3 holds
::     a4 (#) a5 = a5 (#) a4;
end;

:: VALUED_1:funcnot 23 => VALUED_1:func 22
definition
  let a1 be set;
  let a2, a3 be integer-membered set;
  let a4 be Function-like Relation of a1,a2;
  let a5 be Function-like Relation of a1,a3;
  redefine func a4 (#) a5 -> Function-like Relation of a1,INT;
  commutativity;
::  for a1 being set
::  for a2, a3 being integer-membered set
::  for a4 being Function-like Relation of a1,a2
::  for a5 being Function-like Relation of a1,a3 holds
::     a4 (#) a5 = a5 (#) a4;
end;

:: VALUED_1:funcnot 24 => VALUED_1:func 23
definition
  let a1 be set;
  let a2, a3 be natural-membered set;
  let a4 be Function-like Relation of a1,a2;
  let a5 be Function-like Relation of a1,a3;
  redefine func a4 (#) a5 -> Function-like Relation of a1,NAT;
  commutativity;
::  for a1 being set
::  for a2, a3 being natural-membered set
::  for a4 being Function-like Relation of a1,a2
::  for a5 being Function-like Relation of a1,a3 holds
::     a4 (#) a5 = a5 (#) a4;
end;

:: VALUED_1:funcreg 38
registration
  let a1 be set;
  let a2, a3 be non empty complex-membered set;
  let a4 be Function-like quasi_total Relation of a1,a2;
  let a5 be Function-like quasi_total Relation of a1,a3;
  cluster a4 (#) a5 -> Function-like total;
end;

:: VALUED_1:funcreg 39
registration
  let a1 be set;
  let a2, a3 be non empty real-membered set;
  let a4 be Function-like quasi_total Relation of a1,a2;
  let a5 be Function-like quasi_total Relation of a1,a3;
  cluster a4 (#) a5 -> Function-like total;
end;

:: VALUED_1:funcreg 40
registration
  let a1 be set;
  let a2, a3 be non empty rational-membered set;
  let a4 be Function-like quasi_total Relation of a1,a2;
  let a5 be Function-like quasi_total Relation of a1,a3;
  cluster a4 (#) a5 -> Function-like total;
end;

:: VALUED_1:funcreg 41
registration
  let a1 be set;
  let a2, a3 be non empty integer-membered set;
  let a4 be Function-like quasi_total Relation of a1,a2;
  let a5 be Function-like quasi_total Relation of a1,a3;
  cluster a4 (#) a5 -> Function-like total;
end;

:: VALUED_1:funcreg 42
registration
  let a1 be set;
  let a2, a3 be non empty natural-membered set;
  let a4 be Function-like quasi_total Relation of a1,a2;
  let a5 be Function-like quasi_total Relation of a1,a3;
  cluster a4 (#) a5 -> Function-like total;
end;

:: VALUED_1:funcreg 43
registration
  let a1, a2 be Relation-like Function-like complex-valued FinSequence-like set;
  cluster a1 (#) a2 -> Relation-like Function-like FinSequence-like;
end;

:: VALUED_1:funcnot 25 => VALUED_1:func 24
definition
  let a1 be Relation-like Function-like complex-valued set;
  let a2 be complex set;
  func A2 (#) A1 -> Relation-like Function-like set means
    proj1 it = proj1 a1 &
     (for b1 being set
           st b1 in proj1 it
        holds it . b1 = a2 * (a1 . b1));
end;

:: VALUED_1:def 5
theorem
for b1 being Relation-like Function-like complex-valued set
for b2 being complex set
for b3 being Relation-like Function-like set holds
      b3 = b2 (#) b1
   iff
      proj1 b3 = proj1 b1 &
       (for b4 being set
             st b4 in proj1 b3
          holds b3 . b4 = b2 * (b1 . b4));

:: VALUED_1:funcnot 26 => VALUED_1:func 24
notation
  let a1 be Relation-like Function-like complex-valued set;
  let a2 be complex set;
  synonym a1 (#) a2 for a2 (#) a1;
end;

:: VALUED_1:th 6
theorem
for b1 being Relation-like Function-like complex-valued set
for b2 being complex set
for b3 being set holds
   (b2 (#) b1) . b3 = b2 * (b1 . b3);

:: VALUED_1:funcreg 44
registration
  let a1 be Relation-like Function-like complex-valued set;
  let a2 be complex set;
  cluster a2 (#) a1 -> Relation-like Function-like complex-valued;
end;

:: VALUED_1:funcreg 45
registration
  let a1 be Relation-like Function-like real-valued set;
  let a2 be real set;
  cluster a2 (#) a1 -> Relation-like Function-like real-valued;
end;

:: VALUED_1:funcreg 46
registration
  let a1 be Relation-like Function-like rational-valued set;
  let a2 be rational set;
  cluster a2 (#) a1 -> Relation-like Function-like rational-valued;
end;

:: VALUED_1:funcreg 47
registration
  let a1 be Relation-like Function-like integer-valued set;
  let a2 be integer set;
  cluster a2 (#) a1 -> Relation-like Function-like integer-valued;
end;

:: VALUED_1:funcreg 48
registration
  let a1 be Relation-like Function-like natural-valued set;
  let a2 be natural set;
  cluster a2 (#) a1 -> Relation-like Function-like natural-valued;
end;

:: VALUED_1:funcnot 27 => VALUED_1:func 25
definition
  let a1 be set;
  let a2 be complex-membered set;
  let a3 be Function-like Relation of a1,a2;
  let a4 be complex set;
  redefine func a4 (#) a3 -> Function-like Relation of a1,COMPLEX;
end;

:: VALUED_1:funcnot 28 => VALUED_1:func 26
definition
  let a1 be set;
  let a2 be real-membered set;
  let a3 be Function-like Relation of a1,a2;
  let a4 be real set;
  redefine func a4 (#) a3 -> Function-like Relation of a1,REAL;
end;

:: VALUED_1:funcnot 29 => VALUED_1:func 27
definition
  let a1 be set;
  let a2 be rational-membered set;
  let a3 be Function-like Relation of a1,a2;
  let a4 be rational set;
  redefine func a4 (#) a3 -> Function-like Relation of a1,RAT;
end;

:: VALUED_1:funcnot 30 => VALUED_1:func 28
definition
  let a1 be set;
  let a2 be integer-membered set;
  let a3 be Function-like Relation of a1,a2;
  let a4 be integer set;
  redefine func a4 (#) a3 -> Function-like Relation of a1,INT;
end;

:: VALUED_1:funcnot 31 => VALUED_1:func 29
definition
  let a1 be set;
  let a2 be natural-membered set;
  let a3 be Function-like Relation of a1,a2;
  let a4 be natural set;
  redefine func a4 (#) a3 -> Function-like Relation of a1,NAT;
end;

:: VALUED_1:funcreg 49
registration
  let a1 be set;
  let a2 be non empty complex-membered set;
  let a3 be Function-like quasi_total Relation of a1,a2;
  let a4 be complex set;
  cluster a4 (#) a3 -> Function-like total;
end;

:: VALUED_1:funcreg 50
registration
  let a1 be set;
  let a2 be non empty real-membered set;
  let a3 be Function-like quasi_total Relation of a1,a2;
  let a4 be real set;
  cluster a4 (#) a3 -> Function-like total;
end;

:: VALUED_1:funcreg 51
registration
  let a1 be set;
  let a2 be non empty rational-membered set;
  let a3 be Function-like quasi_total Relation of a1,a2;
  let a4 be rational set;
  cluster a4 (#) a3 -> Function-like total;
end;

:: VALUED_1:funcreg 52
registration
  let a1 be set;
  let a2 be non empty integer-membered set;
  let a3 be Function-like quasi_total Relation of a1,a2;
  let a4 be integer set;
  cluster a4 (#) a3 -> Function-like total;
end;

:: VALUED_1:funcreg 53
registration
  let a1 be set;
  let a2 be non empty natural-membered set;
  let a3 be Function-like quasi_total Relation of a1,a2;
  let a4 be natural set;
  cluster a4 (#) a3 -> Function-like total;
end;

:: VALUED_1:th 7
theorem
for b1 being non empty set
for b2 being non empty complex-membered set
for b3 being Function-like quasi_total Relation of b1,b2
for b4 being complex set
for b5 being Function-like quasi_total Relation of b1,COMPLEX
      st for b6 being Element of b1 holds
           b5 . b6 = b4 * (b3 . b6)
   holds b5 = b4 (#) b3;

:: VALUED_1:funcreg 54
registration
  let a1 be Relation-like Function-like complex-valued FinSequence-like set;
  let a2 be complex set;
  cluster a2 (#) a1 -> Relation-like Function-like FinSequence-like;
end;

:: VALUED_1:funcnot 32 => VALUED_1:func 30
definition
  let a1 be Relation-like Function-like complex-valued set;
  func - A1 -> Relation-like Function-like complex-valued set equals
    (- 1) (#) a1;
  involutiveness;
::  for a1 being Relation-like Function-like complex-valued set holds
::     - - a1 = a1;
end;

:: VALUED_1:def 6
theorem
for b1 being Relation-like Function-like complex-valued set holds
   - b1 = (- 1) (#) b1;

:: VALUED_1:th 8
theorem
for b1 being Relation-like Function-like complex-valued set holds
   proj1 - b1 = proj1 b1 &
    (for b2 being set holds
       (- b1) . b2 = - (b1 . b2));

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

:: VALUED_1:funcreg 55
registration
  let a1 be Relation-like Function-like complex-valued set;
  cluster - a1 -> Relation-like Function-like complex-valued;
end;

:: VALUED_1:funcreg 56
registration
  let a1 be Relation-like Function-like real-valued set;
  cluster - a1 -> Relation-like Function-like complex-valued real-valued;
end;

:: VALUED_1:funcreg 57
registration
  let a1 be Relation-like Function-like rational-valued set;
  cluster - a1 -> Relation-like Function-like complex-valued rational-valued;
end;

:: VALUED_1:funcreg 58
registration
  let a1 be Relation-like Function-like integer-valued set;
  cluster - a1 -> Relation-like Function-like complex-valued integer-valued;
end;

:: VALUED_1:funcnot 33 => VALUED_1:func 31
definition
  let a1 be set;
  let a2 be complex-membered set;
  let a3 be Function-like Relation of a1,a2;
  redefine func - a3 -> Function-like Relation of a1,COMPLEX;
  involutiveness;
::  for a1 being set
::  for a2 being complex-membered set
::  for a3 being Function-like Relation of a1,a2 holds
::     - - a3 = a3;
end;

:: VALUED_1:funcnot 34 => VALUED_1:func 32
definition
  let a1 be set;
  let a2 be real-membered set;
  let a3 be Function-like Relation of a1,a2;
  redefine func - a3 -> Function-like Relation of a1,REAL;
  involutiveness;
::  for a1 being set
::  for a2 being real-membered set
::  for a3 being Function-like Relation of a1,a2 holds
::     - - a3 = a3;
end;

:: VALUED_1:funcnot 35 => VALUED_1:func 33
definition
  let a1 be set;
  let a2 be rational-membered set;
  let a3 be Function-like Relation of a1,a2;
  redefine func - a3 -> Function-like Relation of a1,RAT;
  involutiveness;
::  for a1 being set
::  for a2 being rational-membered set
::  for a3 being Function-like Relation of a1,a2 holds
::     - - a3 = a3;
end;

:: VALUED_1:funcnot 36 => VALUED_1:func 34
definition
  let a1 be set;
  let a2 be integer-membered set;
  let a3 be Function-like Relation of a1,a2;
  redefine func - a3 -> Function-like Relation of a1,INT;
  involutiveness;
::  for a1 being set
::  for a2 being integer-membered set
::  for a3 being Function-like Relation of a1,a2 holds
::     - - a3 = a3;
end;

:: VALUED_1:funcreg 59
registration
  let a1 be set;
  let a2 be non empty complex-membered set;
  let a3 be Function-like quasi_total Relation of a1,a2;
  cluster - a3 -> Function-like total;
end;

:: VALUED_1:funcreg 60
registration
  let a1 be set;
  let a2 be non empty real-membered set;
  let a3 be Function-like quasi_total Relation of a1,a2;
  cluster - a3 -> Function-like total;
end;

:: VALUED_1:funcreg 61
registration
  let a1 be set;
  let a2 be non empty rational-membered set;
  let a3 be Function-like quasi_total Relation of a1,a2;
  cluster - a3 -> Function-like total;
end;

:: VALUED_1:funcreg 62
registration
  let a1 be set;
  let a2 be non empty integer-membered set;
  let a3 be Function-like quasi_total Relation of a1,a2;
  cluster - a3 -> Function-like total;
end;

:: VALUED_1:funcreg 63
registration
  let a1 be Relation-like Function-like complex-valued FinSequence-like set;
  cluster - a1 -> Relation-like Function-like complex-valued FinSequence-like;
end;

:: VALUED_1:funcnot 37 => VALUED_1:func 35
definition
  let a1 be Relation-like Function-like complex-valued set;
  func A1 " -> Relation-like Function-like complex-valued set means
    proj1 it = proj1 a1 &
     (for b1 being set
           st b1 in proj1 it
        holds it . b1 = (a1 . b1) ");
  involutiveness;
::  for a1 being Relation-like Function-like complex-valued set holds
::     a1 " " = a1;
end;

:: VALUED_1:def 7
theorem
for b1, b2 being Relation-like Function-like complex-valued set holds
   b2 = b1 "
iff
   proj1 b2 = proj1 b1 &
    (for b3 being set
          st b3 in proj1 b2
       holds b2 . b3 = (b1 . b3) ");

:: VALUED_1:th 10
theorem
for b1 being Relation-like Function-like complex-valued set
for b2 being set holds
   b1 " . b2 = (b1 . b2) ";

:: VALUED_1:funcreg 64
registration
  let a1 be Relation-like Function-like real-valued set;
  cluster a1 " -> Relation-like Function-like complex-valued real-valued;
end;

:: VALUED_1:funcreg 65
registration
  let a1 be Relation-like Function-like rational-valued set;
  cluster a1 " -> Relation-like Function-like complex-valued rational-valued;
end;

:: VALUED_1:funcnot 38 => VALUED_1:func 36
definition
  let a1 be set;
  let a2 be complex-membered set;
  let a3 be Function-like Relation of a1,a2;
  redefine func a3 " -> Function-like Relation of a1,COMPLEX;
  involutiveness;
::  for a1 being set
::  for a2 being complex-membered set
::  for a3 being Function-like Relation of a1,a2 holds
::     a3 " " = a3;
end;

:: VALUED_1:funcnot 39 => VALUED_1:func 37
definition
  let a1 be set;
  let a2 be real-membered set;
  let a3 be Function-like Relation of a1,a2;
  redefine func a3 " -> Function-like Relation of a1,REAL;
  involutiveness;
::  for a1 being set
::  for a2 being real-membered set
::  for a3 being Function-like Relation of a1,a2 holds
::     a3 " " = a3;
end;

:: VALUED_1:funcnot 40 => VALUED_1:func 38
definition
  let a1 be set;
  let a2 be rational-membered set;
  let a3 be Function-like Relation of a1,a2;
  redefine func a3 " -> Function-like Relation of a1,RAT;
  involutiveness;
::  for a1 being set
::  for a2 being rational-membered set
::  for a3 being Function-like Relation of a1,a2 holds
::     a3 " " = a3;
end;

:: VALUED_1:funcreg 66
registration
  let a1 be set;
  let a2 be non empty complex-membered set;
  let a3 be Function-like quasi_total Relation of a1,a2;
  cluster a3 " -> Function-like total;
end;

:: VALUED_1:funcreg 67
registration
  let a1 be set;
  let a2 be non empty real-membered set;
  let a3 be Function-like quasi_total Relation of a1,a2;
  cluster a3 " -> Function-like total;
end;

:: VALUED_1:funcreg 68
registration
  let a1 be set;
  let a2 be non empty rational-membered set;
  let a3 be Function-like quasi_total Relation of a1,a2;
  cluster a3 " -> Function-like total;
end;

:: VALUED_1:funcreg 69
registration
  let a1 be Relation-like Function-like complex-valued FinSequence-like set;
  cluster a1 " -> Relation-like Function-like complex-valued FinSequence-like;
end;

:: VALUED_1:funcnot 41 => VALUED_1:func 39
definition
  let a1 be Relation-like Function-like complex-valued set;
  func A1 ^2 -> Relation-like Function-like set equals
    a1 (#) a1;
end;

:: VALUED_1:def 8
theorem
for b1 being Relation-like Function-like complex-valued set holds
   b1 ^2 = b1 (#) b1;

:: VALUED_1:th 11
theorem
for b1 being Relation-like Function-like complex-valued set holds
   proj1 (b1 ^2) = proj1 b1 &
    (for b2 being set holds
       b1 ^2 . b2 = (b1 . b2) ^2);

:: VALUED_1:funcreg 70
registration
  let a1 be Relation-like Function-like complex-valued set;
  cluster a1 ^2 -> Relation-like Function-like complex-valued;
end;

:: VALUED_1:funcreg 71
registration
  let a1 be Relation-like Function-like real-valued set;
  cluster a1 ^2 -> Relation-like Function-like real-valued;
end;

:: VALUED_1:funcreg 72
registration
  let a1 be Relation-like Function-like rational-valued set;
  cluster a1 ^2 -> Relation-like Function-like rational-valued;
end;

:: VALUED_1:funcreg 73
registration
  let a1 be Relation-like Function-like integer-valued set;
  cluster a1 ^2 -> Relation-like Function-like integer-valued;
end;

:: VALUED_1:funcreg 74
registration
  let a1 be Relation-like Function-like natural-valued set;
  cluster a1 ^2 -> Relation-like Function-like natural-valued;
end;

:: VALUED_1:funcnot 42 => VALUED_1:func 40
definition
  let a1 be set;
  let a2 be complex-membered set;
  let a3 be Function-like Relation of a1,a2;
  redefine func a3 ^2 -> Function-like Relation of a1,COMPLEX;
end;

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

:: VALUED_1:funcnot 44 => VALUED_1:func 42
definition
  let a1 be set;
  let a2 be rational-membered set;
  let a3 be Function-like Relation of a1,a2;
  redefine func a3 ^2 -> Function-like Relation of a1,RAT;
end;

:: VALUED_1:funcnot 45 => VALUED_1:func 43
definition
  let a1 be set;
  let a2 be integer-membered set;
  let a3 be Function-like Relation of a1,a2;
  redefine func a3 ^2 -> Function-like Relation of a1,INT;
end;

:: VALUED_1:funcnot 46 => VALUED_1:func 44
definition
  let a1 be set;
  let a2 be natural-membered set;
  let a3 be Function-like Relation of a1,a2;
  redefine func a3 ^2 -> Function-like Relation of a1,NAT;
end;

:: VALUED_1:funcreg 75
registration
  let a1 be set;
  let a2 be non empty complex-membered set;
  let a3 be Function-like quasi_total Relation of a1,a2;
  cluster a3 ^2 -> Function-like total;
end;

:: VALUED_1:funcreg 76
registration
  let a1 be set;
  let a2 be non empty real-membered set;
  let a3 be Function-like quasi_total Relation of a1,a2;
  cluster a3 ^2 -> Function-like total;
end;

:: VALUED_1:funcreg 77
registration
  let a1 be set;
  let a2 be non empty rational-membered set;
  let a3 be Function-like quasi_total Relation of a1,a2;
  cluster a3 ^2 -> Function-like total;
end;

:: VALUED_1:funcreg 78
registration
  let a1 be set;
  let a2 be non empty integer-membered set;
  let a3 be Function-like quasi_total Relation of a1,a2;
  cluster a3 ^2 -> Function-like total;
end;

:: VALUED_1:funcreg 79
registration
  let a1 be set;
  let a2 be non empty natural-membered set;
  let a3 be Function-like quasi_total Relation of a1,a2;
  cluster a3 ^2 -> Function-like total;
end;

:: VALUED_1:funcreg 80
registration
  let a1 be Relation-like Function-like complex-valued FinSequence-like set;
  cluster a1 ^2 -> Relation-like Function-like FinSequence-like;
end;

:: VALUED_1:funcnot 47 => VALUED_1:func 45
definition
  let a1, a2 be Relation-like Function-like complex-valued set;
  func A1 - A2 -> Relation-like Function-like set equals
    a1 + - a2;
end;

:: VALUED_1:def 9
theorem
for b1, b2 being Relation-like Function-like complex-valued set holds
b1 - b2 = b1 + - b2;

:: VALUED_1:funcreg 81
registration
  let a1, a2 be Relation-like Function-like complex-valued set;
  cluster a1 - a2 -> Relation-like Function-like complex-valued;
end;

:: VALUED_1:funcreg 82
registration
  let a1, a2 be Relation-like Function-like real-valued set;
  cluster a1 - a2 -> Relation-like Function-like real-valued;
end;

:: VALUED_1:funcreg 83
registration
  let a1, a2 be Relation-like Function-like rational-valued set;
  cluster a1 - a2 -> Relation-like Function-like rational-valued;
end;

:: VALUED_1:funcreg 84
registration
  let a1, a2 be Relation-like Function-like integer-valued set;
  cluster a1 - a2 -> Relation-like Function-like integer-valued;
end;

:: VALUED_1:th 12
theorem
for b1, b2 being Relation-like Function-like complex-valued set holds
proj1 (b1 - b2) = (proj1 b1) /\ proj1 b2;

:: VALUED_1:th 13
theorem
for b1, b2 being Relation-like Function-like complex-valued set
for b3 being set
      st b3 in proj1 (b1 - b2)
   holds (b1 - b2) . b3 = (b1 . b3) - (b2 . b3);

:: VALUED_1:th 14
theorem
for b1, b2 being Relation-like Function-like complex-valued set
for b3 being Relation-like Function-like set
      st proj1 b3 = proj1 (b1 - b2) &
         (for b4 being set
               st b4 in proj1 b3
            holds b3 . b4 = (b1 . b4) - (b2 . b4))
   holds b3 = b1 - b2;

:: VALUED_1:funcnot 48 => VALUED_1:func 46
definition
  let a1 be set;
  let a2, a3 be complex-membered set;
  let a4 be Function-like Relation of a1,a2;
  let a5 be Function-like Relation of a1,a3;
  redefine func a4 - a5 -> Function-like Relation of a1,COMPLEX;
end;

:: VALUED_1:funcnot 49 => VALUED_1:func 47
definition
  let a1 be set;
  let a2, a3 be real-membered set;
  let a4 be Function-like Relation of a1,a2;
  let a5 be Function-like Relation of a1,a3;
  redefine func a4 - a5 -> Function-like Relation of a1,REAL;
end;

:: VALUED_1:funcnot 50 => VALUED_1:func 48
definition
  let a1 be set;
  let a2, a3 be rational-membered set;
  let a4 be Function-like Relation of a1,a2;
  let a5 be Function-like Relation of a1,a3;
  redefine func a4 - a5 -> Function-like Relation of a1,RAT;
end;

:: VALUED_1:funcnot 51 => VALUED_1:func 49
definition
  let a1 be set;
  let a2, a3 be integer-membered set;
  let a4 be Function-like Relation of a1,a2;
  let a5 be Function-like Relation of a1,a3;
  redefine func a4 - a5 -> Function-like Relation of a1,INT;
end;

:: VALUED_1:funcreg 85
registration
  let a1 be set;
  let a2, a3 be non empty complex-membered set;
  let a4 be Function-like quasi_total Relation of a1,a2;
  let a5 be Function-like quasi_total Relation of a1,a3;
  cluster a4 - a5 -> Function-like total;
end;

:: VALUED_1:funcreg 86
registration
  let a1 be set;
  let a2, a3 be non empty real-membered set;
  let a4 be Function-like quasi_total Relation of a1,a2;
  let a5 be Function-like quasi_total Relation of a1,a3;
  cluster a4 - a5 -> Function-like total;
end;

:: VALUED_1:funcreg 87
registration
  let a1 be set;
  let a2, a3 be non empty rational-membered set;
  let a4 be Function-like quasi_total Relation of a1,a2;
  let a5 be Function-like quasi_total Relation of a1,a3;
  cluster a4 - a5 -> Function-like total;
end;

:: VALUED_1:funcreg 88
registration
  let a1 be set;
  let a2, a3 be non empty integer-membered set;
  let a4 be Function-like quasi_total Relation of a1,a2;
  let a5 be Function-like quasi_total Relation of a1,a3;
  cluster a4 - a5 -> Function-like total;
end;

:: VALUED_1:th 15
theorem
for b1 being set
for b2, b3 being non empty complex-membered set
for b4 being Function-like quasi_total Relation of b1,b2
for b5 being Function-like quasi_total Relation of b1,b3
for b6 being Element of b1 holds
   (b4 - b5) . b6 = (b4 . b6) - (b5 . b6);

:: VALUED_1:funcreg 89
registration
  let a1, a2 be Relation-like Function-like complex-valued FinSequence-like set;
  cluster a1 - a2 -> Relation-like Function-like FinSequence-like;
end;

:: VALUED_1:funcnot 52 => VALUED_1:func 50
definition
  let a1, a2 be Relation-like Function-like complex-valued set;
  func A1 /" A2 -> Relation-like Function-like set equals
    a1 (#) (a2 ");
end;

:: VALUED_1:def 10
theorem
for b1, b2 being Relation-like Function-like complex-valued set holds
b1 /" b2 = b1 (#) (b2 ");

:: VALUED_1:th 16
theorem
for b1, b2 being Relation-like Function-like complex-valued set holds
proj1 (b1 /" b2) = (proj1 b1) /\ proj1 b2;

:: VALUED_1:th 17
theorem
for b1, b2 being Relation-like Function-like complex-valued set
for b3 being set holds
   (b1 /" b2) . b3 = (b1 . b3) / (b2 . b3);

:: VALUED_1:funcreg 90
registration
  let a1, a2 be Relation-like Function-like complex-valued set;
  cluster a1 /" a2 -> Relation-like Function-like complex-valued;
end;

:: VALUED_1:funcreg 91
registration
  let a1, a2 be Relation-like Function-like real-valued set;
  cluster a1 /" a2 -> Relation-like Function-like real-valued;
end;

:: VALUED_1:funcreg 92
registration
  let a1, a2 be Relation-like Function-like rational-valued set;
  cluster a1 /" a2 -> Relation-like Function-like rational-valued;
end;

:: VALUED_1:funcnot 53 => VALUED_1:func 51
definition
  let a1 be set;
  let a2, a3 be complex-membered set;
  let a4 be Function-like Relation of a1,a2;
  let a5 be Function-like Relation of a1,a3;
  redefine func a4 /" a5 -> Function-like Relation of a1,COMPLEX;
end;

:: VALUED_1:funcnot 54 => VALUED_1:func 52
definition
  let a1 be set;
  let a2, a3 be real-membered set;
  let a4 be Function-like Relation of a1,a2;
  let a5 be Function-like Relation of a1,a3;
  redefine func a4 /" a5 -> Function-like Relation of a1,REAL;
end;

:: VALUED_1:funcnot 55 => VALUED_1:func 53
definition
  let a1 be set;
  let a2, a3 be rational-membered set;
  let a4 be Function-like Relation of a1,a2;
  let a5 be Function-like Relation of a1,a3;
  redefine func a4 /" a5 -> Function-like Relation of a1,RAT;
end;

:: VALUED_1:funcreg 93
registration
  let a1 be set;
  let a2, a3 be non empty complex-membered set;
  let a4 be Function-like quasi_total Relation of a1,a2;
  let a5 be Function-like quasi_total Relation of a1,a3;
  cluster a4 /" a5 -> Function-like total;
end;

:: VALUED_1:funcreg 94
registration
  let a1 be set;
  let a2, a3 be non empty real-membered set;
  let a4 be Function-like quasi_total Relation of a1,a2;
  let a5 be Function-like quasi_total Relation of a1,a3;
  cluster a4 /" a5 -> Function-like total;
end;

:: VALUED_1:funcreg 95
registration
  let a1 be set;
  let a2, a3 be non empty rational-membered set;
  let a4 be Function-like quasi_total Relation of a1,a2;
  let a5 be Function-like quasi_total Relation of a1,a3;
  cluster a4 /" a5 -> Function-like total;
end;

:: VALUED_1:funcreg 96
registration
  let a1, a2 be Relation-like Function-like complex-valued FinSequence-like set;
  cluster a1 /" a2 -> Relation-like Function-like FinSequence-like;
end;

:: VALUED_1:funcnot 56 => VALUED_1:func 54
definition
  let a1 be Relation-like Function-like complex-valued set;
  func |.A1.| -> Relation-like Function-like real-valued set means
    proj1 it = proj1 a1 &
     (for b1 being set
           st b1 in proj1 it
        holds it . b1 = |.a1 . b1.|);
  projectivity;
::  for a1 being Relation-like Function-like complex-valued set holds
::     |.|.a1.|.| = |.a1.|;
end;

:: VALUED_1:def 11
theorem
for b1 being Relation-like Function-like complex-valued set
for b2 being Relation-like Function-like real-valued set holds
      b2 = |.b1.|
   iff
      proj1 b2 = proj1 b1 &
       (for b3 being set
             st b3 in proj1 b2
          holds b2 . b3 = |.b1 . b3.|);

:: VALUED_1:funcnot 57 => VALUED_1:func 54
notation
  let a1 be Relation-like Function-like complex-valued set;
  synonym abs a1 for |.a1.|;
end;

:: VALUED_1:th 18
theorem
for b1 being Relation-like Function-like complex-valued set
for b2 being set holds
   |.b1.| . b2 = |.b1 . b2.|;

:: VALUED_1:funcreg 97
registration
  let a1 be Relation-like Function-like rational-valued set;
  cluster |.a1.| -> Relation-like Function-like real-valued rational-valued;
end;

:: VALUED_1:funcreg 98
registration
  let a1 be Relation-like Function-like integer-valued set;
  cluster |.a1.| -> Relation-like Function-like real-valued natural-valued;
end;

:: VALUED_1:funcnot 58 => VALUED_1:func 55
definition
  let a1 be set;
  let a2 be complex-membered set;
  let a3 be Function-like Relation of a1,a2;
  redefine func |.a3.| -> Function-like Relation of a1,REAL;
  projectivity;
::  for a1 being set
::  for a2 being complex-membered set
::  for a3 being Function-like Relation of a1,a2 holds
::     |.|.a3.|.| = |.a3.|;
end;

:: VALUED_1:funcnot 59 => VALUED_1:func 56
definition
  let a1 be set;
  let a2 be complex-membered set;
  let a3 be Function-like Relation of a1,a2;
  redefine func abs a3 -> Function-like Relation of a1,REAL;
  projectivity;
::  for a1 being set
::  for a2 being complex-membered set
::  for a3 being Function-like Relation of a1,a2 holds
::     abs abs a3 = abs a3;
end;

:: VALUED_1:funcnot 60 => VALUED_1:func 57
definition
  let a1 be set;
  let a2 be rational-membered set;
  let a3 be Function-like Relation of a1,a2;
  redefine func |.a3.| -> Function-like Relation of a1,RAT;
  projectivity;
::  for a1 being set
::  for a2 being rational-membered set
::  for a3 being Function-like Relation of a1,a2 holds
::     |.|.a3.|.| = |.a3.|;
end;

:: VALUED_1:funcnot 61 => VALUED_1:func 58
definition
  let a1 be set;
  let a2 be rational-membered set;
  let a3 be Function-like Relation of a1,a2;
  redefine func abs a3 -> Function-like Relation of a1,RAT;
  projectivity;
::  for a1 being set
::  for a2 being rational-membered set
::  for a3 being Function-like Relation of a1,a2 holds
::     abs abs a3 = abs a3;
end;

:: VALUED_1:funcnot 62 => VALUED_1:func 59
definition
  let a1 be set;
  let a2 be integer-membered set;
  let a3 be Function-like Relation of a1,a2;
  redefine func |.a3.| -> Function-like Relation of a1,NAT;
  projectivity;
::  for a1 being set
::  for a2 being integer-membered set
::  for a3 being Function-like Relation of a1,a2 holds
::     |.|.a3.|.| = |.a3.|;
end;

:: VALUED_1:funcnot 63 => VALUED_1:func 60
definition
  let a1 be set;
  let a2 be integer-membered set;
  let a3 be Function-like Relation of a1,a2;
  redefine func abs a3 -> Function-like Relation of a1,NAT;
  projectivity;
::  for a1 being set
::  for a2 being integer-membered set
::  for a3 being Function-like Relation of a1,a2 holds
::     abs abs a3 = abs a3;
end;

:: VALUED_1:funcreg 99
registration
  let a1 be set;
  let a2 be non empty complex-membered set;
  let a3 be Function-like quasi_total Relation of a1,a2;
  cluster |.a3.| -> Function-like total;
end;

:: VALUED_1:funcreg 100
registration
  let a1 be set;
  let a2 be non empty rational-membered set;
  let a3 be Function-like quasi_total Relation of a1,a2;
  cluster |.a3.| -> Function-like total;
end;

:: VALUED_1:funcreg 101
registration
  let a1 be set;
  let a2 be non empty integer-membered set;
  let a3 be Function-like quasi_total Relation of a1,a2;
  cluster |.a3.| -> Function-like total;
end;

:: VALUED_1:funcreg 102
registration
  let a1 be Relation-like Function-like complex-valued FinSequence-like set;
  cluster |.a1.| -> Relation-like Function-like real-valued FinSequence-like;
end;

:: VALUED_1:th 19
theorem
for b1, b2 being Relation-like Function-like FinSequence-like set
for b3 being Relation-like Function-like set
      st proj1 b3 = (dom b1) /\ dom b2
   holds b3 is Relation-like Function-like FinSequence-like set;

:: VALUED_1:funcnot 64 => VALUED_1:func 61
definition
  let a1 be Relation-like Function-like set;
  let a2 be Element of NAT;
  func Shift(A1,A2) -> Relation-like Function-like set means
    proj1 it = {b1 + a2 where b1 is Element of NAT: b1 in proj1 a1} &
     (for b1 being Element of NAT
           st b1 in proj1 a1
        holds it . (b1 + a2) = a1 . b1);
end;

:: VALUED_1:def 12
theorem
for b1 being Relation-like Function-like set
for b2 being Element of NAT
for b3 being Relation-like Function-like set holds
      b3 = Shift(b1,b2)
   iff
      proj1 b3 = {b4 + b2 where b4 is Element of NAT: b4 in proj1 b1} &
       (for b4 being Element of NAT
             st b4 in proj1 b1
          holds b3 . (b4 + b2) = b1 . b4);

:: VALUED_1:th 20
theorem
for b1 being Relation-like Function-like set
for b2 being Element of NAT holds
   proj1 Shift(b1,b2) c= NAT;

:: VALUED_1:th 21
theorem
for b1, b2 being Relation-like Function-like set
for b3 being Element of NAT
      st b1 c= b2
   holds Shift(b1,b3) c= Shift(b2,b3);

:: VALUED_1:th 22
theorem
for b1, b2 being Element of NAT
for b3 being Relation-like Function-like set holds
   Shift(Shift(b3,b1),b2) = Shift(b3,b1 + b2);

:: VALUED_1:th 23
theorem
for b1, b2 being Relation-like Function-like set
for b3 being Element of NAT holds
   Shift(b1 * b2,b3) = (Shift(b1,b3)) * b2;

:: VALUED_1:th 24
theorem
for b1 being Element of NAT
for b2, b3 being Relation-like Function-like set holds
Shift(b2 +* b3,b1) = (Shift(b2,b1)) +* Shift(b3,b1);