Article DICKSON, MML version 4.99.1005

:: DICKSON:th 1
theorem
for b1 being Relation-like Function-like set
for b2 being set
      st proj1 b1 = {b2}
   holds b1 = b2 .--> (b1 . b2);

:: DICKSON:th 2
theorem
for b1 being Element of NAT holds
   b1 c= b1 + 1;

:: DICKSON:sch 1
scheme DICKSON:sch 1
{F1 -> Element of NAT,
  F2 -> Element of NAT,
  F3 -> set}:
{F3(b1) where b1 is Element of NAT: F1() < b1 & b1 <= F2() & P1[b1]} is finite


:: DICKSON:th 3
theorem
for b1 being infinite set holds
   ex b2 being Function-like quasi_total Relation of NAT,b1 st
      b2 is one-to-one;

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

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

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

:: DICKSON:attrnot 2 => DICKSON:attr 2
definition
  let a1 be RelStr;
  let a2 be Function-like quasi_total Relation of NAT,the carrier of a1;
  attr a2 is weakly-ascending means
    for b1 being Element of NAT holds
       [a2 . b1,a2 . (b1 + 1)] in the InternalRel of a1;
end;

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

:: DICKSON:def 2
theorem
for b1 being RelStr
for b2 being Function-like quasi_total Relation of NAT,the carrier of b1 holds
      b2 is weakly-ascending(b1)
   iff
      for b3 being Element of NAT holds
         [b2 . b3,b2 . (b3 + 1)] in the InternalRel of b1;

:: DICKSON:th 4
theorem
for b1 being non empty transitive RelStr
for b2 being Function-like quasi_total Relation of NAT,the carrier of b1
   st b2 is weakly-ascending(b1)
for b3, b4 being Element of NAT
      st b3 < b4
   holds b2 . b3 <= b2 . b4;

:: DICKSON:th 5
theorem
for b1 being non empty RelStr holds
      b1 is connected
   iff
      the InternalRel of b1 is_strongly_connected_in the carrier of b1;

:: DICKSON:th 7
theorem
for b1 being RelStr
for b2, b3 being set holds
   (the InternalRel of b1) -Seg b3 misses b2 & b3 in b2
iff
   b3 is_minimal_wrt b2,the InternalRel of b1;

:: DICKSON:th 8
theorem
for b1 being non empty transitive antisymmetric RelStr
for b2 being Element of the carrier of b1
for b3, b4 being set
      st b3 is_minimal_wrt ((the InternalRel of b1) -Seg b2) /\ b4,the InternalRel of b1
   holds b3 is_minimal_wrt b4,the InternalRel of b1;

:: DICKSON:attrnot 3 => DICKSON:attr 3
definition
  let a1 be RelStr;
  attr a1 is quasi_ordered means
    a1 is reflexive & a1 is transitive;
end;

:: DICKSON:dfs 3
definiens
  let a1 be RelStr;
To prove
     a1 is quasi_ordered
it is sufficient to prove
  thus a1 is reflexive & a1 is transitive;

:: DICKSON:def 3
theorem
for b1 being RelStr holds
      b1 is quasi_ordered
   iff
      b1 is reflexive & b1 is transitive;

:: DICKSON:funcnot 1 => DICKSON:func 1
definition
  let a1 be RelStr;
  assume a1 is quasi_ordered;
  func EqRel A1 -> total symmetric transitive Relation of the carrier of a1,the carrier of a1 equals
    (the InternalRel of a1) /\ ((the InternalRel of a1) ~);
end;

:: DICKSON:def 4
theorem
for b1 being RelStr
      st b1 is quasi_ordered
   holds EqRel b1 = (the InternalRel of b1) /\ ((the InternalRel of b1) ~);

:: DICKSON:th 9
theorem
for b1 being RelStr
for b2, b3 being Element of the carrier of b1
      st b1 is quasi_ordered
   holds    b2 in Class(EqRel b1,b3)
   iff
      b2 <= b3 & b3 <= b2;

:: DICKSON:funcnot 2 => DICKSON:func 2
definition
  let a1 be RelStr;
  func <=E A1 -> Relation of Class EqRel a1,Class EqRel a1 means
    for b1, b2 being set holds
       [b1,b2] in it
    iff
       ex b3, b4 being Element of the carrier of a1 st
          b1 = Class(EqRel a1,b3) & b2 = Class(EqRel a1,b4) & b3 <= b4;
end;

:: DICKSON:def 5
theorem
for b1 being RelStr
for b2 being Relation of Class EqRel b1,Class EqRel b1 holds
      b2 = <=E b1
   iff
      for b3, b4 being set holds
         [b3,b4] in b2
      iff
         ex b5, b6 being Element of the carrier of b1 st
            b3 = Class(EqRel b1,b5) & b4 = Class(EqRel b1,b6) & b5 <= b6;

:: DICKSON:th 10
theorem
for b1 being RelStr
      st b1 is quasi_ordered
   holds <=E b1 partially_orders Class EqRel b1;

:: DICKSON:th 11
theorem
for b1 being non empty RelStr
      st b1 is quasi_ordered & b1 is connected
   holds <=E b1 linearly_orders Class EqRel b1;

:: DICKSON:funcnot 3 => DICKSON:func 3
definition
  let a1 be Relation-like set;
  func A1 \~ -> Relation-like set equals
    a1 \ (a1 ~);
end;

:: DICKSON:def 6
theorem
for b1 being Relation-like set holds
   b1 \~ = b1 \ (b1 ~);

:: DICKSON:funcreg 1
registration
  let a1 be Relation-like set;
  cluster a1 \~ -> Relation-like asymmetric;
end;

:: DICKSON:funcnot 4 => DICKSON:func 4
definition
  let a1 be set;
  let a2 be Relation of a1,a1;
  redefine func a2 \~ -> Relation of a1,a1;
end;

:: DICKSON:funcnot 5 => DICKSON:func 5
definition
  let a1 be RelStr;
  func A1 \~ -> strict RelStr equals
    RelStr(#the carrier of a1,(the InternalRel of a1) \~#);
end;

:: DICKSON:def 7
theorem
for b1 being RelStr holds
   b1 \~ = RelStr(#the carrier of b1,(the InternalRel of b1) \~#);

:: DICKSON:funcreg 2
registration
  let a1 be non empty RelStr;
  cluster a1 \~ -> non empty strict;
end;

:: DICKSON:funcreg 3
registration
  let a1 be transitive RelStr;
  cluster a1 \~ -> strict transitive;
end;

:: DICKSON:funcreg 4
registration
  let a1 be RelStr;
  cluster a1 \~ -> strict antisymmetric;
end;

:: DICKSON:th 12
theorem
for b1 being non empty reflexive transitive antisymmetric RelStr
for b2 being Element of the carrier of b1 holds
   Class(EqRel b1,b2) = {b2};

:: DICKSON:th 13
theorem
for b1 being Relation-like set holds
      b1 = b1 \~
   iff
      b1 is asymmetric;

:: DICKSON:th 14
theorem
for b1 being Relation-like set
      st b1 is transitive
   holds b1 \~ is transitive;

:: DICKSON:th 15
theorem
for b1 being Relation-like set
for b2, b3 being set
      st b1 is antisymmetric
   holds    [b2,b3] in b1 \~
   iff
      [b2,b3] in b1 & b2 <> b3;

:: DICKSON:th 16
theorem
for b1 being RelStr
      st b1 is well_founded
   holds b1 \~ is well_founded;

:: DICKSON:th 17
theorem
for b1 being RelStr
      st b1 \~ is well_founded & b1 is antisymmetric
   holds b1 is well_founded;

:: DICKSON:th 18
theorem
for b1 being RelStr
for b2 being set
for b3 being Element of the carrier of b1 \~ holds
      b3 is_minimal_wrt b2,the InternalRel of b1 \~
   iff
      b3 in b2 &
       (for b4 being Element of the carrier of b1
             st b4 in b2 & [b4,b3] in the InternalRel of b1
          holds [b3,b4] in the InternalRel of b1);

:: DICKSON:th 19
theorem
for b1, b2 being non empty RelStr
for b3 being Function-like quasi_total Relation of the carrier of b1,the carrier of b2
      st b1 is quasi_ordered &
         b2 is antisymmetric &
         b2 \~ is well_founded &
         (for b4, b5 being Element of the carrier of b1 holds
         (b4 <= b5 implies b3 . b4 <= b3 . b5) &
          (b3 . b4 = b3 . b5 implies [b4,b5] in EqRel b1))
   holds b1 \~ is well_founded;

:: DICKSON:funcnot 6 => DICKSON:func 6
definition
  let a1 be non empty RelStr;
  let a2 be Element of bool the carrier of a1;
  func min-classes A2 -> Element of bool bool the carrier of a1 means
    for b1 being set holds
          b1 in it
       iff
          ex b2 being Element of the carrier of a1 \~ st
             b2 is_minimal_wrt a2,the InternalRel of a1 \~ & b1 = (Class(EqRel a1,b2)) /\ a2;
end;

:: DICKSON:def 8
theorem
for b1 being non empty RelStr
for b2 being Element of bool the carrier of b1
for b3 being Element of bool bool the carrier of b1 holds
      b3 = min-classes b2
   iff
      for b4 being set holds
            b4 in b3
         iff
            ex b5 being Element of the carrier of b1 \~ st
               b5 is_minimal_wrt b2,the InternalRel of b1 \~ & b4 = (Class(EqRel b1,b5)) /\ b2;

:: DICKSON:th 20
theorem
for b1 being non empty RelStr
for b2 being Element of bool the carrier of b1
for b3 being set
   st b1 is quasi_ordered & b3 in min-classes b2
for b4 being Element of the carrier of b1 \~
      st b4 in b3
   holds b4 is_minimal_wrt b2,the InternalRel of b1 \~;

:: DICKSON:th 21
theorem
for b1 being non empty RelStr holds
      b1 \~ is well_founded
   iff
      for b2 being Element of bool the carrier of b1
            st b2 <> {}
         holds ex b3 being set st
            b3 in min-classes b2;

:: DICKSON:th 22
theorem
for b1 being non empty RelStr
for b2 being Element of bool the carrier of b1
for b3 being Element of the carrier of b1 \~
      st b3 is_minimal_wrt b2,the InternalRel of b1 \~
   holds min-classes b2 is not empty;

:: DICKSON:th 23
theorem
for b1 being non empty RelStr
for b2 being Element of bool the carrier of b1
for b3 being set
      st b1 is quasi_ordered & b3 in min-classes b2
   holds b3 is not empty;

:: DICKSON:th 24
theorem
for b1 being non empty RelStr
      st b1 is quasi_ordered
   holds    b1 is connected & b1 \~ is well_founded
   iff
      for b2 being non empty Element of bool the carrier of b1 holds
         Card min-classes b2 = 1;

:: DICKSON:th 25
theorem
for b1 being non empty reflexive transitive antisymmetric RelStr holds
      the InternalRel of b1 well_orders the carrier of b1
   iff
      for b2 being non empty Element of bool the carrier of b1 holds
         Card min-classes b2 = 1;

:: DICKSON:prednot 1 => DICKSON:pred 1
definition
  let a1 be RelStr;
  let a2 be Element of bool the carrier of a1;
  let a3 be set;
  pred A3 is_Dickson-basis_of A2,A1 means
    a3 c= a2 &
     (for b1 being Element of the carrier of a1
           st b1 in a2
        holds ex b2 being Element of the carrier of a1 st
           b2 in a3 & b2 <= b1);
end;

:: DICKSON:dfs 9
definiens
  let a1 be RelStr;
  let a2 be Element of bool the carrier of a1;
  let a3 be set;
To prove
     a3 is_Dickson-basis_of a2,a1
it is sufficient to prove
  thus a3 c= a2 &
     (for b1 being Element of the carrier of a1
           st b1 in a2
        holds ex b2 being Element of the carrier of a1 st
           b2 in a3 & b2 <= b1);

:: DICKSON:def 9
theorem
for b1 being RelStr
for b2 being Element of bool the carrier of b1
for b3 being set holds
      b3 is_Dickson-basis_of b2,b1
   iff
      b3 c= b2 &
       (for b4 being Element of the carrier of b1
             st b4 in b2
          holds ex b5 being Element of the carrier of b1 st
             b5 in b3 & b5 <= b4);

:: DICKSON:th 26
theorem
for b1 being RelStr holds
   {} is_Dickson-basis_of {} the carrier of b1,b1;

:: DICKSON:th 27
theorem
for b1 being non empty RelStr
for b2 being non empty Element of bool the carrier of b1
for b3 being set
      st b3 is_Dickson-basis_of b2,b1
   holds b3 is not empty;

:: DICKSON:attrnot 4 => DICKSON:attr 4
definition
  let a1 be RelStr;
  attr a1 is Dickson means
    for b1 being Element of bool the carrier of a1 holds
       ex b2 being set st
          b2 is_Dickson-basis_of b1,a1 & b2 is finite;
end;

:: DICKSON:dfs 10
definiens
  let a1 be RelStr;
To prove
     a1 is Dickson
it is sufficient to prove
  thus for b1 being Element of bool the carrier of a1 holds
       ex b2 being set st
          b2 is_Dickson-basis_of b1,a1 & b2 is finite;

:: DICKSON:def 10
theorem
for b1 being RelStr holds
      b1 is Dickson
   iff
      for b2 being Element of bool the carrier of b1 holds
         ex b3 being set st
            b3 is_Dickson-basis_of b2,b1 & b3 is finite;

:: DICKSON:th 28
theorem
for b1 being non empty RelStr
      st b1 \~ is well_founded & b1 is connected
   holds b1 is Dickson;

:: DICKSON:th 29
theorem
for b1, b2 being RelStr
      st the InternalRel of b1 c= the InternalRel of b2 & b1 is Dickson & the carrier of b1 = the carrier of b2
   holds b2 is Dickson;

:: DICKSON:funcnot 7 => DICKSON:func 7
definition
  let a1 be Relation-like Function-like set;
  let a2 be set;
  assume proj1 a1 = NAT & a2 in proj2 a1;
  func A1 mindex A2 -> Element of NAT means
    a1 . it = a2 &
     (for b1 being Element of NAT
           st a1 . b1 = a2
        holds it <= b1);
end;

:: DICKSON:def 11
theorem
for b1 being Relation-like Function-like set
for b2 being set
   st proj1 b1 = NAT & b2 in proj2 b1
for b3 being Element of NAT holds
      b3 = b1 mindex b2
   iff
      b1 . b3 = b2 &
       (for b4 being Element of NAT
             st b1 . b4 = b2
          holds b3 <= b4);

:: DICKSON:funcnot 8 => DICKSON:func 8
definition
  let a1 be non empty 1-sorted;
  let a2 be Function-like quasi_total Relation of NAT,the carrier of a1;
  let a3 be set;
  let a4 be Element of NAT;
  assume ex b1 being Element of NAT st
       a4 < b1 & a2 . b1 = a3;
  func A2 mindex(A3,A4) -> Element of NAT means
    a2 . it = a3 &
     a4 < it &
     (for b1 being Element of NAT
           st a4 < b1 & a2 . b1 = a3
        holds it <= b1);
end;

:: DICKSON:def 12
theorem
for b1 being non empty 1-sorted
for b2 being Function-like quasi_total Relation of NAT,the carrier of b1
for b3 being set
for b4 being Element of NAT
   st ex b5 being Element of NAT st
        b4 < b5 & b2 . b5 = b3
for b5 being Element of NAT holds
      b5 = b2 mindex(b3,b4)
   iff
      b2 . b5 = b3 &
       b4 < b5 &
       (for b6 being Element of NAT
             st b4 < b6 & b2 . b6 = b3
          holds b5 <= b6);

:: DICKSON:th 30
theorem
for b1 being non empty RelStr
   st b1 is quasi_ordered & b1 is Dickson
for b2 being Function-like quasi_total Relation of NAT,the carrier of b1 holds
   ex b3, b4 being Element of NAT st
      b3 < b4 & b2 . b3 <= b2 . b4;

:: DICKSON:th 31
theorem
for b1 being RelStr
for b2 being Element of bool the carrier of b1
for b3 being Element of the carrier of b1 \~
      st b1 is quasi_ordered &
         b3 in b2 &
         ((the InternalRel of b1) -Seg b3) /\ b2 c= Class(EqRel b1,b3)
   holds b3 is_minimal_wrt b2,the InternalRel of b1 \~;

:: DICKSON:th 32
theorem
for b1 being non empty RelStr
   st b1 is quasi_ordered &
      (for b2 being Function-like quasi_total Relation of NAT,the carrier of b1 holds
         ex b3, b4 being Element of NAT st
            b3 < b4 & b2 . b3 <= b2 . b4)
for b2 being non empty Element of bool the carrier of b1 holds
   min-classes b2 is finite & min-classes b2 is not empty;

:: DICKSON:th 33
theorem
for b1 being non empty RelStr
      st b1 is quasi_ordered &
         (for b2 being non empty Element of bool the carrier of b1 holds
            min-classes b2 is finite & min-classes b2 is not empty)
   holds b1 is Dickson;

:: DICKSON:th 34
theorem
for b1 being non empty RelStr
      st b1 is quasi_ordered & b1 is Dickson
   holds b1 \~ is well_founded;

:: DICKSON:th 35
theorem
for b1 being non empty reflexive transitive antisymmetric RelStr
for b2 being non empty Element of bool the carrier of b1
      st b1 is Dickson
   holds ex b3 being set st
      b3 is_Dickson-basis_of b2,b1 &
       (for b4 being set
             st b4 is_Dickson-basis_of b2,b1
          holds b3 c= b4);

:: DICKSON:funcnot 9 => DICKSON:func 9
definition
  let a1 be non empty RelStr;
  let a2 be Element of bool the carrier of a1;
  assume a1 is Dickson;
  func Dickson-bases(A2,A1) -> non empty Element of bool bool the carrier of a1 means
    for b1 being set holds
          b1 in it
       iff
          b1 is_Dickson-basis_of a2,a1;
end;

:: DICKSON:def 13
theorem
for b1 being non empty RelStr
for b2 being Element of bool the carrier of b1
   st b1 is Dickson
for b3 being non empty Element of bool bool the carrier of b1 holds
      b3 = Dickson-bases(b2,b1)
   iff
      for b4 being set holds
            b4 in b3
         iff
            b4 is_Dickson-basis_of b2,b1;

:: DICKSON:th 36
theorem
for b1 being non empty RelStr
for b2 being Function-like quasi_total Relation of NAT,the carrier of b1
      st b1 is Dickson
   holds ex b3 being Function-like quasi_total Relation of NAT,the carrier of b1 st
      b3 is subsequence of b2 & b3 is weakly-ascending(b1);

:: DICKSON:th 37
theorem
for b1 being RelStr
      st b1 is empty
   holds b1 is Dickson;

:: DICKSON:th 38
theorem
for b1, b2 being RelStr
      st b1 is Dickson & b2 is Dickson & b1 is quasi_ordered & b2 is quasi_ordered
   holds [:b1,b2:] is quasi_ordered & [:b1,b2:] is Dickson;

:: DICKSON:th 39
theorem
for b1, b2 being RelStr
      st b1,b2 are_isomorphic & b1 is Dickson & b1 is quasi_ordered
   holds b2 is quasi_ordered & b2 is Dickson;

:: DICKSON:th 40
theorem
for b1 being RelStr-yielding ManySortedSet of 1
for b2 being Element of 1 holds
   b1 . b2,product b1 are_isomorphic;

:: DICKSON:funcreg 5
registration
  let a1 be set;
  let a2 be RelStr-yielding ManySortedSet of a1;
  let a3 be Element of bool a1;
  cluster a2 | a3 -> Relation-like RelStr-yielding;
end;

:: DICKSON:th 41
theorem
for b1 being non empty Element of NAT
for b2 being RelStr-yielding ManySortedSet of b1 holds
      product b2 is not empty
   iff
      b2 is non-Empty;

:: DICKSON:th 42
theorem
for b1 being non empty Element of NAT
for b2 being RelStr-yielding ManySortedSet of b1 + 1
for b3 being Element of bool (b1 + 1)
for b4 being Element of b1 + 1
      st b3 = b1 & b4 = b1
   holds [:product (b2 | b3),b2 . b4:],product b2 are_isomorphic;

:: DICKSON:th 43
theorem
for b1 being non empty Element of NAT
for b2 being RelStr-yielding ManySortedSet of b1
      st for b3 being Element of b1 holds
           b2 . b3 is Dickson & b2 . b3 is quasi_ordered
   holds product b2 is quasi_ordered & product b2 is Dickson;

:: DICKSON:funcreg 6
registration
  let a1 be RelStr-yielding ManySortedSet of {};
  cluster product a1 -> non empty strict;
end;

:: DICKSON:funcreg 7
registration
  let a1 be RelStr-yielding ManySortedSet of {};
  cluster product a1 -> strict antisymmetric;
end;

:: DICKSON:funcreg 8
registration
  let a1 be RelStr-yielding ManySortedSet of {};
  cluster product a1 -> strict quasi_ordered;
end;

:: DICKSON:funcreg 9
registration
  let a1 be RelStr-yielding ManySortedSet of {};
  cluster product a1 -> strict Dickson;
end;

:: DICKSON:funcnot 10 => DICKSON:func 10
definition
  func NATOrd -> Relation of NAT,NAT equals
    {[b1,b2] where b1 is Element of NAT, b2 is Element of NAT: b1 <= b2};
end;

:: DICKSON:def 14
theorem
NATOrd = {[b1,b2] where b1 is Element of NAT, b2 is Element of NAT: b1 <= b2};

:: DICKSON:th 44
theorem
NATOrd is_reflexive_in NAT;

:: DICKSON:th 45
theorem
NATOrd is_antisymmetric_in NAT;

:: DICKSON:th 46
theorem
NATOrd is_strongly_connected_in NAT;

:: DICKSON:th 47
theorem
NATOrd is_transitive_in NAT;

:: DICKSON:funcnot 11 => DICKSON:func 11
definition
  func OrderedNAT -> non empty RelStr equals
    RelStr(#NAT,NATOrd#);
end;

:: DICKSON:def 15
theorem
OrderedNAT = RelStr(#NAT,NATOrd#);

:: DICKSON:funcreg 10
registration
  cluster OrderedNAT -> non empty connected;
end;

:: DICKSON:funcreg 11
registration
  cluster OrderedNAT -> non empty Dickson;
end;

:: DICKSON:funcreg 12
registration
  cluster OrderedNAT -> non empty quasi_ordered;
end;

:: DICKSON:funcreg 13
registration
  cluster OrderedNAT -> non empty antisymmetric;
end;

:: DICKSON:funcreg 14
registration
  cluster OrderedNAT -> non empty transitive;
end;

:: DICKSON:funcreg 15
registration
  cluster OrderedNAT -> non empty well_founded;
end;

:: DICKSON:funcreg 16
registration
  let a1 be Element of NAT;
  cluster product (a1 --> OrderedNAT) -> non empty strict;
end;

:: DICKSON:funcreg 17
registration
  let a1 be Element of NAT;
  cluster product (a1 --> OrderedNAT) -> strict Dickson;
end;

:: DICKSON:funcreg 18
registration
  let a1 be Element of NAT;
  cluster product (a1 --> OrderedNAT) -> strict quasi_ordered;
end;

:: DICKSON:funcreg 19
registration
  let a1 be Element of NAT;
  cluster product (a1 --> OrderedNAT) -> strict antisymmetric;
end;

:: DICKSON:th 48
theorem
for b1 being RelStr
      st b1 is Dickson & b1 is quasi_ordered
   holds [:b1,OrderedNAT:] is quasi_ordered & [:b1,OrderedNAT:] is Dickson;

:: DICKSON:th 49
theorem
for b1, b2 being non empty RelStr
      st b1 is Dickson & b1 is quasi_ordered & b2 is quasi_ordered & the InternalRel of b1 c= the InternalRel of b2 & the carrier of b1 = the carrier of b2
   holds b2 \~ is well_founded;

:: DICKSON:th 50
theorem
for b1 being non empty RelStr
      st b1 is quasi_ordered
   holds    b1 is Dickson
   iff
      for b2 being non empty RelStr
            st b2 is quasi_ordered & the InternalRel of b1 c= the InternalRel of b2 & the carrier of b1 = the carrier of b2
         holds b2 \~ is well_founded;