Article WELLFND1, MML version 4.99.1005

:: WELLFND1:funcnot 1 => WELLFND1:func 1
definition
  let a1 be 1-sorted;
  let a2 be set;
  let a3 be Function-like Relation of the carrier of a1,a2;
  redefine func dom a3 -> Element of bool the carrier of a1;
end;

:: WELLFND1:th 1
theorem
for b1 being set
for b2, b3 being Relation-like Function-like set
      st b2 c= b3 & b1 c= proj1 b2
   holds b2 | b1 = b3 | b1;

:: WELLFND1:th 2
theorem
for b1 being functional set
      st for b2, b3 being Relation-like Function-like set
              st b2 in b1 & b3 in b1
           holds b2 tolerates b3
   holds union b1 is Relation-like Function-like set;

:: WELLFND1:sch 1
scheme WELLFND1:sch 1
{F1 -> set,
  F2 -> set}:
ex b1 being Element of bool PFuncs(F1(),F2()) st
   for b2 being Function-like Relation of F1(),F2() holds
         b2 in b1
      iff
         P1[b2]


:: WELLFND1:funcreg 1
registration
  let a1 be set;
  cluster nextcard a1 -> non empty cardinal;
end;

:: WELLFND1:exreg 1
registration
  cluster non empty epsilon-transitive epsilon-connected ordinal infinite cardinal non trivial regular set;
end;

:: WELLFND1:th 3
theorem
for b1 being infinite cardinal regular set
for b2 being set
      st b2 c= b1 & Card b2 in b1
   holds sup b2 in b1;

:: WELLFND1:th 4
theorem
for b1 being RelStr
for b2 being set holds
   (the InternalRel of b1) -Seg b2 c= the carrier of b1;

:: WELLFND1:attrnot 1 => WAYBEL_0:attr 12
definition
  let a1 be RelStr;
  let a2 be Element of bool the carrier of a1;
  attr a2 is lower means
    for b1, b2 being set
          st b1 in a2 & [b2,b1] in the InternalRel of a1
       holds b2 in a2;
end;

:: WELLFND1:dfs 1
definiens
  let a1 be RelStr;
  let a2 be Element of bool the carrier of a1;
To prove
     a2 is lower
it is sufficient to prove
  thus for b1, b2 being set
          st b1 in a2 & [b2,b1] in the InternalRel of a1
       holds b2 in a2;

:: WELLFND1:def 1
theorem
for b1 being RelStr
for b2 being Element of bool the carrier of b1 holds
      b2 is lower(b1)
   iff
      for b3, b4 being set
            st b3 in b2 & [b4,b3] in the InternalRel of b1
         holds b4 in b2;

:: WELLFND1:th 5
theorem
for b1 being RelStr
for b2 being Element of bool the carrier of b1
for b3 being set
      st b2 is lower(b1) & b3 in b2
   holds (the InternalRel of b1) -Seg b3 c= b2;

:: WELLFND1:th 6
theorem
for b1 being RelStr
for b2 being lower Element of bool the carrier of b1
for b3 being Element of bool the carrier of b1
for b4 being set
      st b3 = b2 \/ {b4} & (the InternalRel of b1) -Seg b4 c= b2
   holds b3 is lower(b1);

:: WELLFND1:attrnot 2 => WELLFND1:attr 1
definition
  let a1 be RelStr;
  attr a1 is well_founded means
    the InternalRel of a1 is_well_founded_in the carrier of a1;
end;

:: WELLFND1:dfs 2
definiens
  let a1 be RelStr;
To prove
     a1 is well_founded
it is sufficient to prove
  thus the InternalRel of a1 is_well_founded_in the carrier of a1;

:: WELLFND1:def 2
theorem
for b1 being RelStr holds
      b1 is well_founded
   iff
      the InternalRel of b1 is_well_founded_in the carrier of b1;

:: WELLFND1:exreg 2
registration
  cluster non empty well_founded RelStr;
end;

:: WELLFND1:attrnot 3 => WELLFND1:attr 2
definition
  let a1 be RelStr;
  let a2 be Element of bool the carrier of a1;
  attr a2 is well_founded means
    the InternalRel of a1 is_well_founded_in a2;
end;

:: WELLFND1:dfs 3
definiens
  let a1 be RelStr;
  let a2 be Element of bool the carrier of a1;
To prove
     a2 is well_founded
it is sufficient to prove
  thus the InternalRel of a1 is_well_founded_in a2;

:: WELLFND1:def 3
theorem
for b1 being RelStr
for b2 being Element of bool the carrier of b1 holds
      b2 is well_founded(b1)
   iff
      the InternalRel of b1 is_well_founded_in b2;

:: WELLFND1:exreg 3
registration
  let a1 be RelStr;
  cluster well_founded Element of bool the carrier of a1;
end;

:: WELLFND1:funcnot 2 => WELLFND1:func 2
definition
  let a1 be RelStr;
  func well_founded-Part A1 -> Element of bool the carrier of a1 means
    it = union {b1 where b1 is Element of bool the carrier of a1: b1 is well_founded(a1) & b1 is lower(a1)};
end;

:: WELLFND1:def 4
theorem
for b1 being RelStr
for b2 being Element of bool the carrier of b1 holds
      b2 = well_founded-Part b1
   iff
      b2 = union {b3 where b3 is Element of bool the carrier of b1: b3 is well_founded(b1) & b3 is lower(b1)};

:: WELLFND1:funcreg 2
registration
  let a1 be RelStr;
  cluster well_founded-Part a1 -> lower well_founded;
end;

:: WELLFND1:th 7
theorem
for b1 being non empty RelStr
for b2 being Element of the carrier of b1 holds
   {b2} is well_founded Element of bool the carrier of b1;

:: WELLFND1:th 8
theorem
for b1 being RelStr
for b2, b3 being well_founded Element of bool the carrier of b1
      st b2 is lower(b1)
   holds b2 \/ b3 is well_founded Element of bool the carrier of b1;

:: WELLFND1:th 9
theorem
for b1 being RelStr holds
      b1 is well_founded
   iff
      well_founded-Part b1 = the carrier of b1;

:: WELLFND1:th 10
theorem
for b1 being non empty RelStr
for b2 being Element of the carrier of b1
      st (the InternalRel of b1) -Seg b2 c= well_founded-Part b1
   holds b2 in well_founded-Part b1;

:: WELLFND1:sch 2
scheme WELLFND1:sch 2
{F1 -> non empty RelStr,
  F2 -> Element of the carrier of F1()}:
ex b1 being Element of the carrier of F1() st
   P1[b1] &
    (for b2 being Element of the carrier of F1()
          st b1 <> b2 & P1[b2]
       holds not [b2,b1] in the InternalRel of F1())
provided
   P1[F2()]
and
   F1() is well_founded;


:: WELLFND1:th 11
theorem
for b1 being non empty RelStr holds
      b1 is well_founded
   iff
      for b2 being set
            st for b3 being Element of the carrier of b1
                    st (the InternalRel of b1) -Seg b3 c= b2
                 holds b3 in b2
         holds the carrier of b1 c= b2;

:: WELLFND1:sch 3
scheme WELLFND1:sch 3
{F1 -> non empty RelStr}:
for b1 being Element of the carrier of F1() holds
   P1[b1]
provided
   for b1 being Element of the carrier of F1()
         st for b2 being Element of the carrier of F1()
                 st b2 <> b1 & [b2,b1] in the InternalRel of F1()
              holds P1[b2]
      holds P1[b1]
and
   F1() is well_founded;


:: WELLFND1:prednot 1 => WELLFND1:pred 1
definition
  let a1 be non empty RelStr;
  let a2 be non empty set;
  let a3 be Function-like quasi_total Relation of [:the carrier of a1,PFuncs(the carrier of a1,a2):],a2;
  let a4 be Relation-like Function-like set;
  pred A4 is_recursively_expressed_by A3 means
    for b1 being Element of the carrier of a1 holds
       a4 . b1 = a3 .(b1,a4 | ((the InternalRel of a1) -Seg b1));
end;

:: WELLFND1:dfs 5
definiens
  let a1 be non empty RelStr;
  let a2 be non empty set;
  let a3 be Function-like quasi_total Relation of [:the carrier of a1,PFuncs(the carrier of a1,a2):],a2;
  let a4 be Relation-like Function-like set;
To prove
     a4 is_recursively_expressed_by a3
it is sufficient to prove
  thus for b1 being Element of the carrier of a1 holds
       a4 . b1 = a3 .(b1,a4 | ((the InternalRel of a1) -Seg b1));

:: WELLFND1:def 5
theorem
for b1 being non empty RelStr
for b2 being non empty set
for b3 being Function-like quasi_total Relation of [:the carrier of b1,PFuncs(the carrier of b1,b2):],b2
for b4 being Relation-like Function-like set holds
      b4 is_recursively_expressed_by b3
   iff
      for b5 being Element of the carrier of b1 holds
         b4 . b5 = b3 .(b5,b4 | ((the InternalRel of b1) -Seg b5));

:: WELLFND1:th 12
theorem
for b1 being non empty RelStr holds
      b1 is well_founded
   iff
      for b2 being non empty set
      for b3 being Function-like quasi_total Relation of [:the carrier of b1,PFuncs(the carrier of b1,b2):],b2 holds
         ex b4 being Function-like quasi_total Relation of the carrier of b1,b2 st
            b4 is_recursively_expressed_by b3;

:: WELLFND1:th 13
theorem
for b1 being non empty RelStr
for b2 being non trivial set
      st for b3 being Function-like quasi_total Relation of [:the carrier of b1,PFuncs(the carrier of b1,b2):],b2
        for b4, b5 being Function-like quasi_total Relation of the carrier of b1,b2
              st b4 is_recursively_expressed_by b3 & b5 is_recursively_expressed_by b3
           holds b4 = b5
   holds b1 is well_founded;

:: WELLFND1:th 14
theorem
for b1 being non empty well_founded RelStr
for b2 being non empty set
for b3 being Function-like quasi_total Relation of [:the carrier of b1,PFuncs(the carrier of b1,b2):],b2
for b4, b5 being Function-like quasi_total Relation of the carrier of b1,b2
      st b4 is_recursively_expressed_by b3 & b5 is_recursively_expressed_by b3
   holds b4 = b5;

:: WELLFND1:attrnot 4 => WELLFND1:attr 3
definition
  let a1 be RelStr;
  let a2 be Function-like quasi_total Relation of NAT,the carrier of a1;
  attr a2 is descending means
    for b1 being Element of NAT holds
       a2 . (b1 + 1) <> a2 . b1 &
        [a2 . (b1 + 1),a2 . b1] in the InternalRel of a1;
end;

:: WELLFND1:dfs 6
definiens
  let a1 be RelStr;
  let a2 be Function-like quasi_total Relation of NAT,the carrier of a1;
To prove
     a2 is descending
it is sufficient to prove
  thus for b1 being Element of NAT holds
       a2 . (b1 + 1) <> a2 . b1 &
        [a2 . (b1 + 1),a2 . b1] in the InternalRel of a1;

:: WELLFND1:def 7
theorem
for b1 being RelStr
for b2 being Function-like quasi_total Relation of NAT,the carrier of b1 holds
      b2 is descending(b1)
   iff
      for b3 being Element of NAT holds
         b2 . (b3 + 1) <> b2 . b3 &
          [b2 . (b3 + 1),b2 . b3] in the InternalRel of b1;

:: WELLFND1:th 15
theorem
for b1 being non empty RelStr holds
      b1 is well_founded
   iff
      for b2 being Function-like quasi_total Relation of NAT,the carrier of b1 holds
         b2 is not descending(b1);