Article VALUED_0, MML version 4.99.1005

:: VALUED_0:attrnot 1 => VALUED_0:attr 1
definition
  let a1 be Relation-like set;
  attr a1 is complex-valued means
    proj2 a1 c= COMPLEX;
end;

:: VALUED_0:dfs 1
definiens
  let a1 be Relation-like set;
To prove
     a1 is complex-valued
it is sufficient to prove
  thus proj2 a1 c= COMPLEX;

:: VALUED_0:def 1
theorem
for b1 being Relation-like set holds
      b1 is complex-valued
   iff
      proj2 b1 c= COMPLEX;

:: VALUED_0:attrnot 2 => VALUED_0:attr 2
definition
  let a1 be Relation-like set;
  attr a1 is ext-real-valued means
    proj2 a1 c= ExtREAL;
end;

:: VALUED_0:dfs 2
definiens
  let a1 be Relation-like set;
To prove
     a1 is ext-real-valued
it is sufficient to prove
  thus proj2 a1 c= ExtREAL;

:: VALUED_0:def 2
theorem
for b1 being Relation-like set holds
      b1 is ext-real-valued
   iff
      proj2 b1 c= ExtREAL;

:: VALUED_0:attrnot 3 => VALUED_0:attr 3
definition
  let a1 be Relation-like set;
  attr a1 is real-valued means
    proj2 a1 c= REAL;
end;

:: VALUED_0:dfs 3
definiens
  let a1 be Relation-like set;
To prove
     a1 is real-valued
it is sufficient to prove
  thus proj2 a1 c= REAL;

:: VALUED_0:def 3
theorem
for b1 being Relation-like set holds
      b1 is real-valued
   iff
      proj2 b1 c= REAL;

:: VALUED_0:attrnot 4 => VALUED_0:attr 4
definition
  let a1 be Relation-like set;
  attr a1 is rational-valued means
    proj2 a1 c= RAT;
end;

:: VALUED_0:dfs 4
definiens
  let a1 be Relation-like set;
To prove
     a1 is rational-valued
it is sufficient to prove
  thus proj2 a1 c= RAT;

:: VALUED_0:def 4
theorem
for b1 being Relation-like set holds
      b1 is rational-valued
   iff
      proj2 b1 c= RAT;

:: VALUED_0:attrnot 5 => VALUED_0:attr 5
definition
  let a1 be Relation-like set;
  attr a1 is integer-valued means
    proj2 a1 c= INT;
end;

:: VALUED_0:dfs 5
definiens
  let a1 be Relation-like set;
To prove
     a1 is integer-valued
it is sufficient to prove
  thus proj2 a1 c= INT;

:: VALUED_0:def 5
theorem
for b1 being Relation-like set holds
      b1 is integer-valued
   iff
      proj2 b1 c= INT;

:: VALUED_0:attrnot 6 => VALUED_0:attr 6
definition
  let a1 be Relation-like set;
  attr a1 is natural-valued means
    proj2 a1 c= NAT;
end;

:: VALUED_0:dfs 6
definiens
  let a1 be Relation-like set;
To prove
     a1 is natural-valued
it is sufficient to prove
  thus proj2 a1 c= NAT;

:: VALUED_0:def 6
theorem
for b1 being Relation-like set holds
      b1 is natural-valued
   iff
      proj2 b1 c= NAT;

:: VALUED_0:condreg 1
registration
  cluster Relation-like natural-valued -> integer-valued (set);
end;

:: VALUED_0:condreg 2
registration
  cluster Relation-like integer-valued -> rational-valued (set);
end;

:: VALUED_0:condreg 3
registration
  cluster Relation-like rational-valued -> real-valued (set);
end;

:: VALUED_0:condreg 4
registration
  cluster Relation-like real-valued -> ext-real-valued (set);
end;

:: VALUED_0:condreg 5
registration
  cluster Relation-like real-valued -> complex-valued (set);
end;

:: VALUED_0:condreg 6
registration
  cluster Relation-like empty -> natural-valued (set);
end;

:: VALUED_0:funcreg 1
registration
  cluster {} -> natural-valued;
end;

:: VALUED_0:exreg 1
registration
  cluster Relation-like Function-like natural-valued set;
end;

:: VALUED_0:funcreg 2
registration
  let a1 be Relation-like complex-valued set;
  cluster proj2 a1 -> complex-membered;
end;

:: VALUED_0:funcreg 3
registration
  let a1 be Relation-like ext-real-valued set;
  cluster proj2 a1 -> ext-real-membered;
end;

:: VALUED_0:funcreg 4
registration
  let a1 be Relation-like real-valued set;
  cluster proj2 a1 -> real-membered;
end;

:: VALUED_0:funcreg 5
registration
  let a1 be Relation-like rational-valued set;
  cluster proj2 a1 -> rational-membered;
end;

:: VALUED_0:funcreg 6
registration
  let a1 be Relation-like integer-valued set;
  cluster proj2 a1 -> integer-membered;
end;

:: VALUED_0:funcreg 7
registration
  let a1 be Relation-like natural-valued set;
  cluster proj2 a1 -> natural-membered;
end;

:: VALUED_0:th 1
theorem
for b1 being Relation-like set
for b2 being Relation-like complex-valued set
      st b1 c= b2
   holds b1 is complex-valued;

:: VALUED_0:th 2
theorem
for b1 being Relation-like set
for b2 being Relation-like ext-real-valued set
      st b1 c= b2
   holds b1 is ext-real-valued;

:: VALUED_0:th 3
theorem
for b1 being Relation-like set
for b2 being Relation-like real-valued set
      st b1 c= b2
   holds b1 is real-valued;

:: VALUED_0:th 4
theorem
for b1 being Relation-like set
for b2 being Relation-like rational-valued set
      st b1 c= b2
   holds b1 is rational-valued;

:: VALUED_0:th 5
theorem
for b1 being Relation-like set
for b2 being Relation-like integer-valued set
      st b1 c= b2
   holds b1 is integer-valued;

:: VALUED_0:th 6
theorem
for b1 being Relation-like set
for b2 being Relation-like natural-valued set
      st b1 c= b2
   holds b1 is natural-valued;

:: VALUED_0:condreg 7
registration
  let a1 be Relation-like complex-valued set;
  cluster -> complex-valued (Element of bool a1);
end;

:: VALUED_0:condreg 8
registration
  let a1 be Relation-like ext-real-valued set;
  cluster -> ext-real-valued (Element of bool a1);
end;

:: VALUED_0:condreg 9
registration
  let a1 be Relation-like real-valued set;
  cluster -> real-valued (Element of bool a1);
end;

:: VALUED_0:condreg 10
registration
  let a1 be Relation-like rational-valued set;
  cluster -> rational-valued (Element of bool a1);
end;

:: VALUED_0:condreg 11
registration
  let a1 be Relation-like integer-valued set;
  cluster -> integer-valued (Element of bool a1);
end;

:: VALUED_0:condreg 12
registration
  let a1 be Relation-like natural-valued set;
  cluster -> natural-valued (Element of bool a1);
end;

:: VALUED_0:funcreg 8
registration
  let a1, a2 be Relation-like complex-valued set;
  cluster a1 \/ a2 -> complex-valued;
end;

:: VALUED_0:funcreg 9
registration
  let a1, a2 be Relation-like ext-real-valued set;
  cluster a1 \/ a2 -> ext-real-valued;
end;

:: VALUED_0:funcreg 10
registration
  let a1, a2 be Relation-like real-valued set;
  cluster a1 \/ a2 -> real-valued;
end;

:: VALUED_0:funcreg 11
registration
  let a1, a2 be Relation-like rational-valued set;
  cluster a1 \/ a2 -> rational-valued;
end;

:: VALUED_0:funcreg 12
registration
  let a1, a2 be Relation-like integer-valued set;
  cluster a1 \/ a2 -> integer-valued;
end;

:: VALUED_0:funcreg 13
registration
  let a1, a2 be Relation-like natural-valued set;
  cluster a1 \/ a2 -> natural-valued;
end;

:: VALUED_0:funcreg 14
registration
  let a1 be Relation-like complex-valued set;
  let a2 be Relation-like set;
  cluster a1 /\ a2 -> complex-valued;
end;

:: VALUED_0:funcreg 15
registration
  let a1 be Relation-like complex-valued set;
  let a2 be Relation-like set;
  cluster a1 \ a2 -> complex-valued;
end;

:: VALUED_0:funcreg 16
registration
  let a1 be Relation-like ext-real-valued set;
  let a2 be Relation-like set;
  cluster a1 /\ a2 -> ext-real-valued;
end;

:: VALUED_0:funcreg 17
registration
  let a1 be Relation-like ext-real-valued set;
  let a2 be Relation-like set;
  cluster a1 \ a2 -> ext-real-valued;
end;

:: VALUED_0:funcreg 18
registration
  let a1 be Relation-like real-valued set;
  let a2 be Relation-like set;
  cluster a1 /\ a2 -> real-valued;
end;

:: VALUED_0:funcreg 19
registration
  let a1 be Relation-like real-valued set;
  let a2 be Relation-like set;
  cluster a1 \ a2 -> real-valued;
end;

:: VALUED_0:funcreg 20
registration
  let a1 be Relation-like rational-valued set;
  let a2 be Relation-like set;
  cluster a1 /\ a2 -> rational-valued;
end;

:: VALUED_0:funcreg 21
registration
  let a1 be Relation-like rational-valued set;
  let a2 be Relation-like set;
  cluster a1 \ a2 -> rational-valued;
end;

:: VALUED_0:funcreg 22
registration
  let a1 be Relation-like integer-valued set;
  let a2 be Relation-like set;
  cluster a1 /\ a2 -> integer-valued;
end;

:: VALUED_0:funcreg 23
registration
  let a1 be Relation-like integer-valued set;
  let a2 be Relation-like set;
  cluster a1 \ a2 -> integer-valued;
end;

:: VALUED_0:funcreg 24
registration
  let a1 be Relation-like natural-valued set;
  let a2 be Relation-like set;
  cluster a1 /\ a2 -> natural-valued;
end;

:: VALUED_0:funcreg 25
registration
  let a1 be Relation-like natural-valued set;
  let a2 be Relation-like set;
  cluster a1 \ a2 -> natural-valued;
end;

:: VALUED_0:funcreg 26
registration
  let a1, a2 be Relation-like complex-valued set;
  cluster a1 \+\ a2 -> complex-valued;
end;

:: VALUED_0:funcreg 27
registration
  let a1, a2 be Relation-like ext-real-valued set;
  cluster a1 \+\ a2 -> ext-real-valued;
end;

:: VALUED_0:funcreg 28
registration
  let a1, a2 be Relation-like real-valued set;
  cluster a1 \+\ a2 -> real-valued;
end;

:: VALUED_0:funcreg 29
registration
  let a1, a2 be Relation-like rational-valued set;
  cluster a1 \+\ a2 -> rational-valued;
end;

:: VALUED_0:funcreg 30
registration
  let a1, a2 be Relation-like integer-valued set;
  cluster a1 \+\ a2 -> integer-valued;
end;

:: VALUED_0:funcreg 31
registration
  let a1, a2 be Relation-like natural-valued set;
  cluster a1 \+\ a2 -> natural-valued;
end;

:: VALUED_0:funcreg 32
registration
  let a1 be Relation-like complex-valued set;
  let a2 be set;
  cluster a1 .: a2 -> complex-membered;
end;

:: VALUED_0:funcreg 33
registration
  let a1 be Relation-like ext-real-valued set;
  let a2 be set;
  cluster a1 .: a2 -> ext-real-membered;
end;

:: VALUED_0:funcreg 34
registration
  let a1 be Relation-like real-valued set;
  let a2 be set;
  cluster a1 .: a2 -> real-membered;
end;

:: VALUED_0:funcreg 35
registration
  let a1 be Relation-like rational-valued set;
  let a2 be set;
  cluster a1 .: a2 -> rational-membered;
end;

:: VALUED_0:funcreg 36
registration
  let a1 be Relation-like integer-valued set;
  let a2 be set;
  cluster a1 .: a2 -> integer-membered;
end;

:: VALUED_0:funcreg 37
registration
  let a1 be Relation-like natural-valued set;
  let a2 be set;
  cluster a1 .: a2 -> natural-membered;
end;

:: VALUED_0:funcreg 38
registration
  let a1 be Relation-like complex-valued set;
  let a2 be set;
  cluster Im(a1,a2) -> complex-membered;
end;

:: VALUED_0:funcreg 39
registration
  let a1 be Relation-like ext-real-valued set;
  let a2 be set;
  cluster Im(a1,a2) -> ext-real-membered;
end;

:: VALUED_0:funcreg 40
registration
  let a1 be Relation-like real-valued set;
  let a2 be set;
  cluster Im(a1,a2) -> real-membered;
end;

:: VALUED_0:funcreg 41
registration
  let a1 be Relation-like rational-valued set;
  let a2 be set;
  cluster Im(a1,a2) -> rational-membered;
end;

:: VALUED_0:funcreg 42
registration
  let a1 be Relation-like integer-valued set;
  let a2 be set;
  cluster Im(a1,a2) -> integer-membered;
end;

:: VALUED_0:funcreg 43
registration
  let a1 be Relation-like natural-valued set;
  let a2 be set;
  cluster Im(a1,a2) -> natural-membered;
end;

:: VALUED_0:funcreg 44
registration
  let a1 be Relation-like complex-valued set;
  let a2 be set;
  cluster a1 | a2 -> Relation-like complex-valued;
end;

:: VALUED_0:funcreg 45
registration
  let a1 be Relation-like ext-real-valued set;
  let a2 be set;
  cluster a1 | a2 -> Relation-like ext-real-valued;
end;

:: VALUED_0:funcreg 46
registration
  let a1 be Relation-like real-valued set;
  let a2 be set;
  cluster a1 | a2 -> Relation-like real-valued;
end;

:: VALUED_0:funcreg 47
registration
  let a1 be Relation-like rational-valued set;
  let a2 be set;
  cluster a1 | a2 -> Relation-like rational-valued;
end;

:: VALUED_0:funcreg 48
registration
  let a1 be Relation-like integer-valued set;
  let a2 be set;
  cluster a1 | a2 -> Relation-like integer-valued;
end;

:: VALUED_0:funcreg 49
registration
  let a1 be Relation-like natural-valued set;
  let a2 be set;
  cluster a1 | a2 -> Relation-like natural-valued;
end;

:: VALUED_0:funcreg 50
registration
  let a1 be complex-membered set;
  cluster id a1 -> Relation-like complex-valued;
end;

:: VALUED_0:funcreg 51
registration
  let a1 be ext-real-membered set;
  cluster id a1 -> Relation-like ext-real-valued;
end;

:: VALUED_0:funcreg 52
registration
  let a1 be real-membered set;
  cluster id a1 -> Relation-like real-valued;
end;

:: VALUED_0:funcreg 53
registration
  let a1 be rational-membered set;
  cluster id a1 -> Relation-like rational-valued;
end;

:: VALUED_0:funcreg 54
registration
  let a1 be integer-membered set;
  cluster id a1 -> Relation-like integer-valued;
end;

:: VALUED_0:funcreg 55
registration
  let a1 be natural-membered set;
  cluster id a1 -> Relation-like natural-valued;
end;

:: VALUED_0:funcreg 56
registration
  let a1 be Relation-like set;
  let a2 be Relation-like complex-valued set;
  cluster a1 * a2 -> Relation-like complex-valued;
end;

:: VALUED_0:funcreg 57
registration
  let a1 be Relation-like set;
  let a2 be Relation-like ext-real-valued set;
  cluster a1 * a2 -> Relation-like ext-real-valued;
end;

:: VALUED_0:funcreg 58
registration
  let a1 be Relation-like set;
  let a2 be Relation-like real-valued set;
  cluster a1 * a2 -> Relation-like real-valued;
end;

:: VALUED_0:funcreg 59
registration
  let a1 be Relation-like set;
  let a2 be Relation-like rational-valued set;
  cluster a1 * a2 -> Relation-like rational-valued;
end;

:: VALUED_0:funcreg 60
registration
  let a1 be Relation-like set;
  let a2 be Relation-like integer-valued set;
  cluster a1 * a2 -> Relation-like integer-valued;
end;

:: VALUED_0:funcreg 61
registration
  let a1 be Relation-like set;
  let a2 be Relation-like natural-valued set;
  cluster a1 * a2 -> Relation-like natural-valued;
end;

:: VALUED_0:attrnot 7 => VALUED_0:attr 1
definition
  let a1 be Relation-like set;
  attr a1 is complex-valued means
    for b1 being set
          st b1 in proj1 a1
       holds a1 . b1 is complex;
end;

:: VALUED_0:dfs 7
definiens
  let a1 be Relation-like Function-like set;
To prove
     a1 is complex-valued
it is sufficient to prove
  thus for b1 being set
          st b1 in proj1 a1
       holds a1 . b1 is complex;

:: VALUED_0:def 7
theorem
for b1 being Relation-like Function-like set holds
      b1 is complex-valued
   iff
      for b2 being set
            st b2 in proj1 b1
         holds b1 . b2 is complex;

:: VALUED_0:attrnot 8 => VALUED_0:attr 2
definition
  let a1 be Relation-like set;
  attr a1 is ext-real-valued means
    for b1 being set
          st b1 in proj1 a1
       holds a1 . b1 is ext-real;
end;

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

:: VALUED_0:def 8
theorem
for b1 being Relation-like Function-like set holds
      b1 is ext-real-valued
   iff
      for b2 being set
            st b2 in proj1 b1
         holds b1 . b2 is ext-real;

:: VALUED_0:attrnot 9 => VALUED_0:attr 3
definition
  let a1 be Relation-like set;
  attr a1 is real-valued means
    for b1 being set
          st b1 in proj1 a1
       holds a1 . b1 is real;
end;

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

:: VALUED_0:def 9
theorem
for b1 being Relation-like Function-like set holds
      b1 is real-valued
   iff
      for b2 being set
            st b2 in proj1 b1
         holds b1 . b2 is real;

:: VALUED_0:attrnot 10 => VALUED_0:attr 4
definition
  let a1 be Relation-like set;
  attr a1 is rational-valued means
    for b1 being set
          st b1 in proj1 a1
       holds a1 . b1 is rational;
end;

:: VALUED_0:dfs 10
definiens
  let a1 be Relation-like Function-like set;
To prove
     a1 is rational-valued
it is sufficient to prove
  thus for b1 being set
          st b1 in proj1 a1
       holds a1 . b1 is rational;

:: VALUED_0:def 10
theorem
for b1 being Relation-like Function-like set holds
      b1 is rational-valued
   iff
      for b2 being set
            st b2 in proj1 b1
         holds b1 . b2 is rational;

:: VALUED_0:attrnot 11 => VALUED_0:attr 5
definition
  let a1 be Relation-like set;
  attr a1 is integer-valued means
    for b1 being set
          st b1 in proj1 a1
       holds a1 . b1 is integer;
end;

:: VALUED_0:dfs 11
definiens
  let a1 be Relation-like Function-like set;
To prove
     a1 is integer-valued
it is sufficient to prove
  thus for b1 being set
          st b1 in proj1 a1
       holds a1 . b1 is integer;

:: VALUED_0:def 11
theorem
for b1 being Relation-like Function-like set holds
      b1 is integer-valued
   iff
      for b2 being set
            st b2 in proj1 b1
         holds b1 . b2 is integer;

:: VALUED_0:attrnot 12 => VALUED_0:attr 6
definition
  let a1 be Relation-like set;
  attr a1 is natural-valued means
    for b1 being set
          st b1 in proj1 a1
       holds a1 . b1 is natural;
end;

:: VALUED_0:dfs 12
definiens
  let a1 be Relation-like Function-like set;
To prove
     a1 is natural-valued
it is sufficient to prove
  thus for b1 being set
          st b1 in proj1 a1
       holds a1 . b1 is natural;

:: VALUED_0:def 12
theorem
for b1 being Relation-like Function-like set holds
      b1 is natural-valued
   iff
      for b2 being set
            st b2 in proj1 b1
         holds b1 . b2 is natural;

:: VALUED_0:th 7
theorem
for b1 being Relation-like Function-like set holds
      b1 is complex-valued
   iff
      for b2 being set holds
         b1 . b2 is complex;

:: VALUED_0:th 8
theorem
for b1 being Relation-like Function-like set holds
      b1 is ext-real-valued
   iff
      for b2 being set holds
         b1 . b2 is ext-real;

:: VALUED_0:th 9
theorem
for b1 being Relation-like Function-like set holds
      b1 is real-valued
   iff
      for b2 being set holds
         b1 . b2 is real;

:: VALUED_0:th 10
theorem
for b1 being Relation-like Function-like set holds
      b1 is rational-valued
   iff
      for b2 being set holds
         b1 . b2 is rational;

:: VALUED_0:th 11
theorem
for b1 being Relation-like Function-like set holds
      b1 is integer-valued
   iff
      for b2 being set holds
         b1 . b2 is integer;

:: VALUED_0:th 12
theorem
for b1 being Relation-like Function-like set holds
      b1 is natural-valued
   iff
      for b2 being set holds
         b1 . b2 is natural;

:: VALUED_0:funcreg 62
registration
  let a1 be Relation-like Function-like complex-valued set;
  let a2 be set;
  cluster a1 . a2 -> complex;
end;

:: VALUED_0:funcreg 63
registration
  let a1 be Relation-like Function-like ext-real-valued set;
  let a2 be set;
  cluster a1 . a2 -> ext-real;
end;

:: VALUED_0:funcreg 64
registration
  let a1 be Relation-like Function-like real-valued set;
  let a2 be set;
  cluster a1 . a2 -> real;
end;

:: VALUED_0:funcreg 65
registration
  let a1 be Relation-like Function-like rational-valued set;
  let a2 be set;
  cluster a1 . a2 -> rational;
end;

:: VALUED_0:funcreg 66
registration
  let a1 be Relation-like Function-like integer-valued set;
  let a2 be set;
  cluster a1 . a2 -> integer;
end;

:: VALUED_0:funcreg 67
registration
  let a1 be Relation-like Function-like natural-valued set;
  let a2 be set;
  cluster a1 . a2 -> natural;
end;

:: VALUED_0:funcreg 68
registration
  let a1 be set;
  let a2 be complex set;
  cluster a1 --> a2 -> complex-valued;
end;

:: VALUED_0:funcreg 69
registration
  let a1 be set;
  let a2 be ext-real set;
  cluster a1 --> a2 -> ext-real-valued;
end;

:: VALUED_0:funcreg 70
registration
  let a1 be set;
  let a2 be real set;
  cluster a1 --> a2 -> real-valued;
end;

:: VALUED_0:funcreg 71
registration
  let a1 be set;
  let a2 be rational set;
  cluster a1 --> a2 -> rational-valued;
end;

:: VALUED_0:funcreg 72
registration
  let a1 be set;
  let a2 be integer set;
  cluster a1 --> a2 -> integer-valued;
end;

:: VALUED_0:funcreg 73
registration
  let a1 be set;
  let a2 be natural set;
  cluster a1 --> a2 -> natural-valued;
end;

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

:: VALUED_0:funcreg 75
registration
  let a1, a2 be Relation-like Function-like ext-real-valued set;
  cluster a1 +* a2 -> Relation-like Function-like ext-real-valued;
end;

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

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

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

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

:: VALUED_0:funcreg 80
registration
  let a1 be set;
  let a2 be complex set;
  cluster a1 .--> a2 -> complex-valued;
end;

:: VALUED_0:funcreg 81
registration
  let a1 be set;
  let a2 be ext-real set;
  cluster a1 .--> a2 -> ext-real-valued;
end;

:: VALUED_0:funcreg 82
registration
  let a1 be set;
  let a2 be real set;
  cluster a1 .--> a2 -> real-valued;
end;

:: VALUED_0:funcreg 83
registration
  let a1 be set;
  let a2 be rational set;
  cluster a1 .--> a2 -> rational-valued;
end;

:: VALUED_0:funcreg 84
registration
  let a1 be set;
  let a2 be integer set;
  cluster a1 .--> a2 -> integer-valued;
end;

:: VALUED_0:funcreg 85
registration
  let a1 be set;
  let a2 be natural set;
  cluster a1 .--> a2 -> natural-valued;
end;

:: VALUED_0:condreg 13
registration
  let a1 be set;
  let a2 be complex-membered set;
  cluster -> complex-valued (Relation of a1,a2);
end;

:: VALUED_0:condreg 14
registration
  let a1 be set;
  let a2 be ext-real-membered set;
  cluster -> ext-real-valued (Relation of a1,a2);
end;

:: VALUED_0:condreg 15
registration
  let a1 be set;
  let a2 be real-membered set;
  cluster -> real-valued (Relation of a1,a2);
end;

:: VALUED_0:condreg 16
registration
  let a1 be set;
  let a2 be rational-membered set;
  cluster -> rational-valued (Relation of a1,a2);
end;

:: VALUED_0:condreg 17
registration
  let a1 be set;
  let a2 be integer-membered set;
  cluster -> integer-valued (Relation of a1,a2);
end;

:: VALUED_0:condreg 18
registration
  let a1 be set;
  let a2 be natural-membered set;
  cluster -> natural-valued (Relation of a1,a2);
end;

:: VALUED_0:funcreg 86
registration
  let a1 be set;
  let a2 be complex-membered set;
  cluster [:a1,a2:] -> complex-valued;
end;

:: VALUED_0:funcreg 87
registration
  let a1 be set;
  let a2 be ext-real-membered set;
  cluster [:a1,a2:] -> ext-real-valued;
end;

:: VALUED_0:funcreg 88
registration
  let a1 be set;
  let a2 be real-membered set;
  cluster [:a1,a2:] -> real-valued;
end;

:: VALUED_0:funcreg 89
registration
  let a1 be set;
  let a2 be rational-membered set;
  cluster [:a1,a2:] -> rational-valued;
end;

:: VALUED_0:funcreg 90
registration
  let a1 be set;
  let a2 be integer-membered set;
  cluster [:a1,a2:] -> integer-valued;
end;

:: VALUED_0:funcreg 91
registration
  let a1 be set;
  let a2 be natural-membered set;
  cluster [:a1,a2:] -> natural-valued;
end;