Article WAYBEL_0, MML version 4.99.1005

:: WAYBEL_0:attrnot 1 => WAYBEL_0:attr 1
definition
  let a1 be RelStr;
  let a2 be Element of bool the carrier of a1;
  attr a2 is directed means
    for b1, b2 being Element of the carrier of a1
          st b1 in a2 & b2 in a2
       holds ex b3 being Element of the carrier of a1 st
          b3 in a2 & b1 <= b3 & b2 <= b3;
end;

:: WAYBEL_0:dfs 1
definiens
  let a1 be RelStr;
  let a2 be Element of bool the carrier of a1;
To prove
     a2 is directed
it is sufficient to prove
  thus for b1, b2 being Element of the carrier of a1
          st b1 in a2 & b2 in a2
       holds ex b3 being Element of the carrier of a1 st
          b3 in a2 & b1 <= b3 & b2 <= b3;

:: WAYBEL_0:def 1
theorem
for b1 being RelStr
for b2 being Element of bool the carrier of b1 holds
      b2 is directed(b1)
   iff
      for b3, b4 being Element of the carrier of b1
            st b3 in b2 & b4 in b2
         holds ex b5 being Element of the carrier of b1 st
            b5 in b2 & b3 <= b5 & b4 <= b5;

:: WAYBEL_0:attrnot 2 => WAYBEL_0:attr 2
definition
  let a1 be RelStr;
  let a2 be Element of bool the carrier of a1;
  attr a2 is filtered means
    for b1, b2 being Element of the carrier of a1
          st b1 in a2 & b2 in a2
       holds ex b3 being Element of the carrier of a1 st
          b3 in a2 & b3 <= b1 & b3 <= b2;
end;

:: WAYBEL_0:dfs 2
definiens
  let a1 be RelStr;
  let a2 be Element of bool the carrier of a1;
To prove
     a2 is filtered
it is sufficient to prove
  thus for b1, b2 being Element of the carrier of a1
          st b1 in a2 & b2 in a2
       holds ex b3 being Element of the carrier of a1 st
          b3 in a2 & b3 <= b1 & b3 <= b2;

:: WAYBEL_0:def 2
theorem
for b1 being RelStr
for b2 being Element of bool the carrier of b1 holds
      b2 is filtered(b1)
   iff
      for b3, b4 being Element of the carrier of b1
            st b3 in b2 & b4 in b2
         holds ex b5 being Element of the carrier of b1 st
            b5 in b2 & b5 <= b3 & b5 <= b4;

:: WAYBEL_0:th 1
theorem
for b1 being non empty transitive RelStr
for b2 being Element of bool the carrier of b1 holds
      b2 is not empty & b2 is directed(b1)
   iff
      for b3 being finite Element of bool b2 holds
         ex b4 being Element of the carrier of b1 st
            b4 in b2 & b3 is_<=_than b4;

:: WAYBEL_0:th 2
theorem
for b1 being non empty transitive RelStr
for b2 being Element of bool the carrier of b1 holds
      b2 is not empty & b2 is filtered(b1)
   iff
      for b3 being finite Element of bool b2 holds
         ex b4 being Element of the carrier of b1 st
            b4 in b2 & b4 is_<=_than b3;

:: WAYBEL_0:funcreg 1
registration
  let a1 be RelStr;
  cluster {} a1 -> directed filtered;
end;

:: WAYBEL_0:exreg 1
registration
  let a1 be RelStr;
  cluster directed filtered Element of bool the carrier of a1;
end;

:: WAYBEL_0:th 3
theorem
for b1, b2 being RelStr
   st RelStr(#the carrier of b1,the InternalRel of b1#) = RelStr(#the carrier of b2,the InternalRel of b2#)
for b3 being Element of bool the carrier of b1
for b4 being Element of bool the carrier of b2
      st b3 = b4 & b3 is directed(b1)
   holds b4 is directed(b2);

:: WAYBEL_0:th 4
theorem
for b1, b2 being RelStr
   st RelStr(#the carrier of b1,the InternalRel of b1#) = RelStr(#the carrier of b2,the InternalRel of b2#)
for b3 being Element of bool the carrier of b1
for b4 being Element of bool the carrier of b2
      st b3 = b4 & b3 is filtered(b1)
   holds b4 is filtered(b2);

:: WAYBEL_0:th 5
theorem
for b1 being non empty reflexive RelStr
for b2 being Element of the carrier of b1 holds
   {b2} is directed(b1) & {b2} is filtered(b1);

:: WAYBEL_0:exreg 2
registration
  let a1 be non empty reflexive RelStr;
  cluster non empty finite directed filtered Element of bool the carrier of a1;
end;

:: WAYBEL_0:funcreg 2
registration
  let a1 be with_suprema RelStr;
  cluster [#] a1 -> directed;
end;

:: WAYBEL_0:funcreg 3
registration
  let a1 be non empty upper-bounded RelStr;
  cluster [#] a1 -> directed;
end;

:: WAYBEL_0:funcreg 4
registration
  let a1 be with_infima RelStr;
  cluster [#] a1 -> filtered;
end;

:: WAYBEL_0:funcreg 5
registration
  let a1 be non empty lower-bounded RelStr;
  cluster [#] a1 -> filtered;
end;

:: WAYBEL_0:attrnot 3 => WAYBEL_0:attr 3
definition
  let a1 be non empty RelStr;
  let a2 be SubRelStr of a1;
  attr a2 is filtered-infs-inheriting means
    for b1 being filtered Element of bool the carrier of a2
          st b1 <> {} & ex_inf_of b1,a1
       holds "/\"(b1,a1) in the carrier of a2;
end;

:: WAYBEL_0:dfs 3
definiens
  let a1 be non empty RelStr;
  let a2 be SubRelStr of a1;
To prove
     a2 is filtered-infs-inheriting
it is sufficient to prove
  thus for b1 being filtered Element of bool the carrier of a2
          st b1 <> {} & ex_inf_of b1,a1
       holds "/\"(b1,a1) in the carrier of a2;

:: WAYBEL_0:def 3
theorem
for b1 being non empty RelStr
for b2 being SubRelStr of b1 holds
      b2 is filtered-infs-inheriting(b1)
   iff
      for b3 being filtered Element of bool the carrier of b2
            st b3 <> {} & ex_inf_of b3,b1
         holds "/\"(b3,b1) in the carrier of b2;

:: WAYBEL_0:attrnot 4 => WAYBEL_0:attr 4
definition
  let a1 be non empty RelStr;
  let a2 be SubRelStr of a1;
  attr a2 is directed-sups-inheriting means
    for b1 being directed Element of bool the carrier of a2
          st b1 <> {} & ex_sup_of b1,a1
       holds "\/"(b1,a1) in the carrier of a2;
end;

:: WAYBEL_0:dfs 4
definiens
  let a1 be non empty RelStr;
  let a2 be SubRelStr of a1;
To prove
     a2 is directed-sups-inheriting
it is sufficient to prove
  thus for b1 being directed Element of bool the carrier of a2
          st b1 <> {} & ex_sup_of b1,a1
       holds "\/"(b1,a1) in the carrier of a2;

:: WAYBEL_0:def 4
theorem
for b1 being non empty RelStr
for b2 being SubRelStr of b1 holds
      b2 is directed-sups-inheriting(b1)
   iff
      for b3 being directed Element of bool the carrier of b2
            st b3 <> {} & ex_sup_of b3,b1
         holds "\/"(b3,b1) in the carrier of b2;

:: WAYBEL_0:condreg 1
registration
  let a1 be non empty RelStr;
  cluster infs-inheriting -> filtered-infs-inheriting (SubRelStr of a1);
end;

:: WAYBEL_0:condreg 2
registration
  let a1 be non empty RelStr;
  cluster sups-inheriting -> directed-sups-inheriting (SubRelStr of a1);
end;

:: WAYBEL_0:exreg 3
registration
  let a1 be non empty RelStr;
  cluster non empty strict full infs-inheriting sups-inheriting SubRelStr of a1;
end;

:: WAYBEL_0:th 6
theorem
for b1 being non empty transitive RelStr
for b2 being non empty full filtered-infs-inheriting SubRelStr of b1
for b3 being filtered Element of bool the carrier of b2
      st b3 <> {} & ex_inf_of b3,b1
   holds ex_inf_of b3,b2 & "/\"(b3,b2) = "/\"(b3,b1);

:: WAYBEL_0:th 7
theorem
for b1 being non empty transitive RelStr
for b2 being non empty full directed-sups-inheriting SubRelStr of b1
for b3 being directed Element of bool the carrier of b2
      st b3 <> {} & ex_sup_of b3,b1
   holds ex_sup_of b3,b2 & "\/"(b3,b2) = "\/"(b3,b1);

:: WAYBEL_0:attrnot 5 => WAYBEL_0:attr 5
definition
  let a1, a2 be RelStr;
  let a3 be Function-like quasi_total Relation of the carrier of a1,the carrier of a2;
  attr a3 is antitone means
    for b1, b2 being Element of the carrier of a1
       st b1 <= b2
    for b3, b4 being Element of the carrier of a2
          st b3 = a3 . b1 & b4 = a3 . b2
       holds b4 <= b3;
end;

:: WAYBEL_0:dfs 5
definiens
  let a1, a2 be RelStr;
  let a3 be Function-like quasi_total Relation of the carrier of a1,the carrier of a2;
To prove
     a3 is antitone
it is sufficient to prove
  thus for b1, b2 being Element of the carrier of a1
       st b1 <= b2
    for b3, b4 being Element of the carrier of a2
          st b3 = a3 . b1 & b4 = a3 . b2
       holds b4 <= b3;

:: WAYBEL_0:def 5
theorem
for b1, b2 being RelStr
for b3 being Function-like quasi_total Relation of the carrier of b1,the carrier of b2 holds
      b3 is antitone(b1, b2)
   iff
      for b4, b5 being Element of the carrier of b1
         st b4 <= b5
      for b6, b7 being Element of the carrier of b2
            st b6 = b3 . b4 & b7 = b3 . b5
         holds b7 <= b6;

:: WAYBEL_0:structnot 1 => WAYBEL_0:struct 1
definition
  let a1 be 1-sorted;
  struct(RelStr) NetStr(#
    carrier -> set,
    InternalRel -> Relation of the carrier of it,the carrier of it,
    mapping -> Function-like quasi_total Relation of the carrier of it,the carrier of A1
  #);
end;

:: WAYBEL_0:attrnot 6 => WAYBEL_0:attr 6
definition
  let a1 be 1-sorted;
  let a2 be NetStr over a1;
  attr a2 is strict;
end;

:: WAYBEL_0:exreg 4
registration
  let a1 be 1-sorted;
  cluster strict NetStr over a1;
end;

:: WAYBEL_0:aggrnot 1 => WAYBEL_0:aggr 1
definition
  let a1 be 1-sorted;
  let a2 be set;
  let a3 be Relation of a2,a2;
  let a4 be Function-like quasi_total Relation of a2,the carrier of a1;
  aggr NetStr(#a2,a3,a4#) -> strict NetStr over a1;
end;

:: WAYBEL_0:selnot 1 => WAYBEL_0:sel 1
definition
  let a1 be 1-sorted;
  let a2 be NetStr over a1;
  sel the mapping of a2 -> Function-like quasi_total Relation of the carrier of a2,the carrier of a1;
end;

:: WAYBEL_0:funcreg 6
registration
  let a1 be 1-sorted;
  let a2 be non empty set;
  let a3 be Relation of a2,a2;
  let a4 be Function-like quasi_total Relation of a2,the carrier of a1;
  cluster NetStr(#a2,a3,a4#) -> non empty strict;
end;

:: WAYBEL_0:attrnot 7 => WAYBEL_0:attr 7
definition
  let a1 be RelStr;
  attr a1 is directed means
    [#] a1 is directed(a1);
end;

:: WAYBEL_0:dfs 6
definiens
  let a1 be RelStr;
To prove
     a1 is directed
it is sufficient to prove
  thus [#] a1 is directed(a1);

:: WAYBEL_0:def 6
theorem
for b1 being RelStr holds
      b1 is directed
   iff
      [#] b1 is directed(b1);

:: WAYBEL_0:exreg 5
registration
  let a1 be 1-sorted;
  cluster non empty reflexive transitive antisymmetric strict directed NetStr over a1;
end;

:: WAYBEL_0:modenot 1
definition
  let a1 be 1-sorted;
  mode prenet of a1 is non empty directed NetStr over a1;
end;

:: WAYBEL_0:modenot 2
definition
  let a1 be 1-sorted;
  mode net of a1 is non empty transitive directed NetStr over a1;
end;

:: WAYBEL_0:funcnot 1 => WAYBEL_0:func 1
definition
  let a1 be non empty 1-sorted;
  let a2 be non empty NetStr over a1;
  func netmap(A2,A1) -> Function-like quasi_total Relation of the carrier of a2,the carrier of a1 equals
    the mapping of a2;
end;

:: WAYBEL_0:def 7
theorem
for b1 being non empty 1-sorted
for b2 being non empty NetStr over b1 holds
   netmap(b2,b1) = the mapping of b2;

:: WAYBEL_0:funcnot 2 => WAYBEL_0:func 2
definition
  let a1 be non empty 1-sorted;
  let a2 be non empty NetStr over a1;
  let a3 be Element of the carrier of a2;
  func A2 . A3 -> Element of the carrier of a1 equals
    (the mapping of a2) . a3;
end;

:: WAYBEL_0:def 8
theorem
for b1 being non empty 1-sorted
for b2 being non empty NetStr over b1
for b3 being Element of the carrier of b2 holds
   b2 . b3 = (the mapping of b2) . b3;

:: WAYBEL_0:attrnot 8 => WAYBEL_0:attr 8
definition
  let a1 be non empty RelStr;
  let a2 be non empty NetStr over a1;
  attr a2 is monotone means
    netmap(a2,a1) is monotone(a2, a1);
end;

:: WAYBEL_0:dfs 9
definiens
  let a1 be non empty RelStr;
  let a2 be non empty NetStr over a1;
To prove
     a2 is monotone
it is sufficient to prove
  thus netmap(a2,a1) is monotone(a2, a1);

:: WAYBEL_0:def 9
theorem
for b1 being non empty RelStr
for b2 being non empty NetStr over b1 holds
      b2 is monotone(b1)
   iff
      netmap(b2,b1) is monotone(b2, b1);

:: WAYBEL_0:attrnot 9 => WAYBEL_0:attr 9
definition
  let a1 be non empty RelStr;
  let a2 be non empty NetStr over a1;
  attr a2 is antitone means
    netmap(a2,a1) is antitone(a2, a1);
end;

:: WAYBEL_0:dfs 10
definiens
  let a1 be non empty RelStr;
  let a2 be non empty NetStr over a1;
To prove
     a2 is antitone
it is sufficient to prove
  thus netmap(a2,a1) is antitone(a2, a1);

:: WAYBEL_0:def 10
theorem
for b1 being non empty RelStr
for b2 being non empty NetStr over b1 holds
      b2 is antitone(b1)
   iff
      netmap(b2,b1) is antitone(b2, b1);

:: WAYBEL_0:prednot 1 => WAYBEL_0:pred 1
definition
  let a1 be non empty 1-sorted;
  let a2 be non empty NetStr over a1;
  let a3 be set;
  pred A2 is_eventually_in A3 means
    ex b1 being Element of the carrier of a2 st
       for b2 being Element of the carrier of a2
             st b1 <= b2
          holds a2 . b2 in a3;
end;

:: WAYBEL_0:dfs 11
definiens
  let a1 be non empty 1-sorted;
  let a2 be non empty NetStr over a1;
  let a3 be set;
To prove
     a2 is_eventually_in a3
it is sufficient to prove
  thus ex b1 being Element of the carrier of a2 st
       for b2 being Element of the carrier of a2
             st b1 <= b2
          holds a2 . b2 in a3;

:: WAYBEL_0:def 11
theorem
for b1 being non empty 1-sorted
for b2 being non empty NetStr over b1
for b3 being set holds
      b2 is_eventually_in b3
   iff
      ex b4 being Element of the carrier of b2 st
         for b5 being Element of the carrier of b2
               st b4 <= b5
            holds b2 . b5 in b3;

:: WAYBEL_0:prednot 2 => WAYBEL_0:pred 2
definition
  let a1 be non empty 1-sorted;
  let a2 be non empty NetStr over a1;
  let a3 be set;
  pred A2 is_often_in A3 means
    for b1 being Element of the carrier of a2 holds
       ex b2 being Element of the carrier of a2 st
          b1 <= b2 & a2 . b2 in a3;
end;

:: WAYBEL_0:dfs 12
definiens
  let a1 be non empty 1-sorted;
  let a2 be non empty NetStr over a1;
  let a3 be set;
To prove
     a2 is_often_in a3
it is sufficient to prove
  thus for b1 being Element of the carrier of a2 holds
       ex b2 being Element of the carrier of a2 st
          b1 <= b2 & a2 . b2 in a3;

:: WAYBEL_0:def 12
theorem
for b1 being non empty 1-sorted
for b2 being non empty NetStr over b1
for b3 being set holds
      b2 is_often_in b3
   iff
      for b4 being Element of the carrier of b2 holds
         ex b5 being Element of the carrier of b2 st
            b4 <= b5 & b2 . b5 in b3;

:: WAYBEL_0:th 8
theorem
for b1 being non empty 1-sorted
for b2 being non empty NetStr over b1
for b3, b4 being set
      st b3 c= b4
   holds (b2 is_eventually_in b3 implies b2 is_eventually_in b4) & (b2 is_often_in b3 implies b2 is_often_in b4);

:: WAYBEL_0:th 9
theorem
for b1 being non empty 1-sorted
for b2 being non empty NetStr over b1
for b3 being set holds
      b2 is_eventually_in b3
   iff
      not b2 is_often_in (the carrier of b1) \ b3;

:: WAYBEL_0:th 10
theorem
for b1 being non empty 1-sorted
for b2 being non empty NetStr over b1
for b3 being set holds
      b2 is_often_in b3
   iff
      not b2 is_eventually_in (the carrier of b1) \ b3;

:: WAYBEL_0:sch 1
scheme WAYBEL_0:sch 1
{F1 -> non empty RelStr,
  F2 -> non empty NetStr over F1()}:
   (F2() is_eventually_in {F2() . b1 where b1 is Element of the carrier of F2(): P1[F2() . b1]}
iff
   ex b1 being Element of the carrier of F2() st
      for b2 being Element of the carrier of F2()
            st b1 <= b2
         holds P1[F2() . b2])


:: WAYBEL_0:attrnot 10 => WAYBEL_0:attr 10
definition
  let a1 be non empty RelStr;
  let a2 be non empty NetStr over a1;
  attr a2 is eventually-directed means
    for b1 being Element of the carrier of a2 holds
       a2 is_eventually_in {a2 . b2 where b2 is Element of the carrier of a2: a2 . b1 <= a2 . b2};
end;

:: WAYBEL_0:dfs 13
definiens
  let a1 be non empty RelStr;
  let a2 be non empty NetStr over a1;
To prove
     a2 is eventually-directed
it is sufficient to prove
  thus for b1 being Element of the carrier of a2 holds
       a2 is_eventually_in {a2 . b2 where b2 is Element of the carrier of a2: a2 . b1 <= a2 . b2};

:: WAYBEL_0:def 13
theorem
for b1 being non empty RelStr
for b2 being non empty NetStr over b1 holds
      b2 is eventually-directed(b1)
   iff
      for b3 being Element of the carrier of b2 holds
         b2 is_eventually_in {b2 . b4 where b4 is Element of the carrier of b2: b2 . b3 <= b2 . b4};

:: WAYBEL_0:attrnot 11 => WAYBEL_0:attr 11
definition
  let a1 be non empty RelStr;
  let a2 be non empty NetStr over a1;
  attr a2 is eventually-filtered means
    for b1 being Element of the carrier of a2 holds
       a2 is_eventually_in {a2 . b2 where b2 is Element of the carrier of a2: a2 . b2 <= a2 . b1};
end;

:: WAYBEL_0:dfs 14
definiens
  let a1 be non empty RelStr;
  let a2 be non empty NetStr over a1;
To prove
     a2 is eventually-filtered
it is sufficient to prove
  thus for b1 being Element of the carrier of a2 holds
       a2 is_eventually_in {a2 . b2 where b2 is Element of the carrier of a2: a2 . b2 <= a2 . b1};

:: WAYBEL_0:def 14
theorem
for b1 being non empty RelStr
for b2 being non empty NetStr over b1 holds
      b2 is eventually-filtered(b1)
   iff
      for b3 being Element of the carrier of b2 holds
         b2 is_eventually_in {b2 . b4 where b4 is Element of the carrier of b2: b2 . b4 <= b2 . b3};

:: WAYBEL_0:th 11
theorem
for b1 being non empty RelStr
for b2 being non empty NetStr over b1 holds
      b2 is eventually-directed(b1)
   iff
      for b3 being Element of the carrier of b2 holds
         ex b4 being Element of the carrier of b2 st
            for b5 being Element of the carrier of b2
                  st b4 <= b5
               holds b2 . b3 <= b2 . b5;

:: WAYBEL_0:th 12
theorem
for b1 being non empty RelStr
for b2 being non empty NetStr over b1 holds
      b2 is eventually-filtered(b1)
   iff
      for b3 being Element of the carrier of b2 holds
         ex b4 being Element of the carrier of b2 st
            for b5 being Element of the carrier of b2
                  st b4 <= b5
               holds b2 . b5 <= b2 . b3;

:: WAYBEL_0:condreg 3
registration
  let a1 be non empty RelStr;
  cluster non empty directed monotone -> eventually-directed (NetStr over a1);
end;

:: WAYBEL_0:condreg 4
registration
  let a1 be non empty RelStr;
  cluster non empty directed antitone -> eventually-filtered (NetStr over a1);
end;

:: WAYBEL_0:exreg 6
registration
  let a1 be non empty reflexive RelStr;
  cluster non empty strict directed monotone antitone NetStr over a1;
end;

:: WAYBEL_0:funcnot 3 => WAYBEL_0:func 3
definition
  let a1 be RelStr;
  let a2 be Element of bool the carrier of a1;
  func downarrow A2 -> Element of bool the carrier of a1 means
    for b1 being Element of the carrier of a1 holds
          b1 in it
       iff
          ex b2 being Element of the carrier of a1 st
             b1 <= b2 & b2 in a2;
end;

:: WAYBEL_0:def 15
theorem
for b1 being RelStr
for b2, b3 being Element of bool the carrier of b1 holds
   b3 = downarrow b2
iff
   for b4 being Element of the carrier of b1 holds
         b4 in b3
      iff
         ex b5 being Element of the carrier of b1 st
            b4 <= b5 & b5 in b2;

:: WAYBEL_0:funcnot 4 => WAYBEL_0:func 4
definition
  let a1 be RelStr;
  let a2 be Element of bool the carrier of a1;
  func uparrow A2 -> Element of bool the carrier of a1 means
    for b1 being Element of the carrier of a1 holds
          b1 in it
       iff
          ex b2 being Element of the carrier of a1 st
             b2 <= b1 & b2 in a2;
end;

:: WAYBEL_0:def 16
theorem
for b1 being RelStr
for b2, b3 being Element of bool the carrier of b1 holds
   b3 = uparrow b2
iff
   for b4 being Element of the carrier of b1 holds
         b4 in b3
      iff
         ex b5 being Element of the carrier of b1 st
            b5 <= b4 & b5 in b2;

:: WAYBEL_0:th 13
theorem
for b1, b2 being RelStr
   st RelStr(#the carrier of b1,the InternalRel of b1#) = RelStr(#the carrier of b2,the InternalRel of b2#)
for b3 being Element of bool the carrier of b1
for b4 being Element of bool the carrier of b2
      st b3 = b4
   holds downarrow b3 = downarrow b4 & uparrow b3 = uparrow b4;

:: WAYBEL_0:th 14
theorem
for b1 being non empty RelStr
for b2 being Element of bool the carrier of b1 holds
   downarrow b2 = {b3 where b3 is Element of the carrier of b1: ex b4 being Element of the carrier of b1 st
      b3 <= b4 & b4 in b2};

:: WAYBEL_0:th 15
theorem
for b1 being non empty RelStr
for b2 being Element of bool the carrier of b1 holds
   uparrow b2 = {b3 where b3 is Element of the carrier of b1: ex b4 being Element of the carrier of b1 st
      b4 <= b3 & b4 in b2};

:: WAYBEL_0:funcreg 7
registration
  let a1 be non empty reflexive RelStr;
  let a2 be non empty Element of bool the carrier of a1;
  cluster downarrow a2 -> non empty;
end;

:: WAYBEL_0:funcreg 8
registration
  let a1 be non empty reflexive RelStr;
  let a2 be non empty Element of bool the carrier of a1;
  cluster uparrow a2 -> non empty;
end;

:: WAYBEL_0:th 16
theorem
for b1 being reflexive RelStr
for b2 being Element of bool the carrier of b1 holds
   b2 c= downarrow b2 & b2 c= uparrow b2;

:: WAYBEL_0:funcnot 5 => WAYBEL_0:func 5
definition
  let a1 be non empty RelStr;
  let a2 be Element of the carrier of a1;
  func downarrow A2 -> Element of bool the carrier of a1 equals
    downarrow {a2};
end;

:: WAYBEL_0:def 17
theorem
for b1 being non empty RelStr
for b2 being Element of the carrier of b1 holds
   downarrow b2 = downarrow {b2};

:: WAYBEL_0:funcnot 6 => WAYBEL_0:func 6
definition
  let a1 be non empty RelStr;
  let a2 be Element of the carrier of a1;
  func uparrow A2 -> Element of bool the carrier of a1 equals
    uparrow {a2};
end;

:: WAYBEL_0:def 18
theorem
for b1 being non empty RelStr
for b2 being Element of the carrier of b1 holds
   uparrow b2 = uparrow {b2};

:: WAYBEL_0:th 17
theorem
for b1 being non empty RelStr
for b2, b3 being Element of the carrier of b1 holds
   b3 in downarrow b2
iff
   b3 <= b2;

:: WAYBEL_0:th 18
theorem
for b1 being non empty RelStr
for b2, b3 being Element of the carrier of b1 holds
   b3 in uparrow b2
iff
   b2 <= b3;

:: WAYBEL_0:th 19
theorem
for b1 being non empty reflexive antisymmetric RelStr
for b2, b3 being Element of the carrier of b1
      st downarrow b2 = downarrow b3
   holds b2 = b3;

:: WAYBEL_0:th 20
theorem
for b1 being non empty reflexive antisymmetric RelStr
for b2, b3 being Element of the carrier of b1
      st uparrow b2 = uparrow b3
   holds b2 = b3;

:: WAYBEL_0:th 21
theorem
for b1 being non empty transitive RelStr
for b2, b3 being Element of the carrier of b1
      st b2 <= b3
   holds downarrow b2 c= downarrow b3;

:: WAYBEL_0:th 22
theorem
for b1 being non empty transitive RelStr
for b2, b3 being Element of the carrier of b1
      st b2 <= b3
   holds uparrow b3 c= uparrow b2;

:: WAYBEL_0:funcreg 9
registration
  let a1 be non empty reflexive RelStr;
  let a2 be Element of the carrier of a1;
  cluster downarrow a2 -> non empty directed;
end;

:: WAYBEL_0:funcreg 10
registration
  let a1 be non empty reflexive RelStr;
  let a2 be Element of the carrier of a1;
  cluster uparrow a2 -> non empty filtered;
end;

:: WAYBEL_0:attrnot 12 => 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 Element of the carrier of a1
          st b1 in a2 & b2 <= b1
       holds b2 in a2;
end;

:: WAYBEL_0:dfs 19
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 Element of the carrier of a1
          st b1 in a2 & b2 <= b1
       holds b2 in a2;

:: WAYBEL_0:def 19
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 Element of the carrier of b1
            st b3 in b2 & b4 <= b3
         holds b4 in b2;

:: WAYBEL_0:attrnot 13 => WAYBEL_0:attr 13
definition
  let a1 be RelStr;
  let a2 be Element of bool the carrier of a1;
  attr a2 is upper means
    for b1, b2 being Element of the carrier of a1
          st b1 in a2 & b1 <= b2
       holds b2 in a2;
end;

:: WAYBEL_0:dfs 20
definiens
  let a1 be RelStr;
  let a2 be Element of bool the carrier of a1;
To prove
     a2 is upper
it is sufficient to prove
  thus for b1, b2 being Element of the carrier of a1
          st b1 in a2 & b1 <= b2
       holds b2 in a2;

:: WAYBEL_0:def 20
theorem
for b1 being RelStr
for b2 being Element of bool the carrier of b1 holds
      b2 is upper(b1)
   iff
      for b3, b4 being Element of the carrier of b1
            st b3 in b2 & b3 <= b4
         holds b4 in b2;

:: WAYBEL_0:exreg 7
registration
  let a1 be RelStr;
  cluster lower upper Element of bool the carrier of a1;
end;

:: WAYBEL_0:th 23
theorem
for b1 being RelStr
for b2 being Element of bool the carrier of b1 holds
      b2 is lower(b1)
   iff
      downarrow b2 c= b2;

:: WAYBEL_0:th 24
theorem
for b1 being RelStr
for b2 being Element of bool the carrier of b1 holds
      b2 is upper(b1)
   iff
      uparrow b2 c= b2;

:: WAYBEL_0:th 25
theorem
for b1, b2 being RelStr
   st RelStr(#the carrier of b1,the InternalRel of b1#) = RelStr(#the carrier of b2,the InternalRel of b2#)
for b3 being Element of bool the carrier of b1
for b4 being Element of bool the carrier of b2
      st b3 = b4
   holds (b3 is lower(b1) implies b4 is lower(b2)) & (b3 is upper(b1) implies b4 is upper(b2));

:: WAYBEL_0:th 26
theorem
for b1 being RelStr
for b2 being Element of bool bool the carrier of b1
      st for b3 being Element of bool the carrier of b1
              st b3 in b2
           holds b3 is lower(b1)
   holds union b2 is lower Element of bool the carrier of b1;

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

:: WAYBEL_0:th 28
theorem
for b1 being RelStr
for b2 being Element of bool bool the carrier of b1
      st for b3 being Element of bool the carrier of b1
              st b3 in b2
           holds b3 is upper(b1)
   holds union b2 is upper Element of bool the carrier of b1;

:: WAYBEL_0:th 29
theorem
for b1 being RelStr
for b2, b3 being Element of bool the carrier of b1
      st b2 is upper(b1) & b3 is upper(b1)
   holds b2 /\ b3 is upper(b1) & b2 \/ b3 is upper(b1);

:: WAYBEL_0:funcreg 11
registration
  let a1 be non empty transitive RelStr;
  let a2 be Element of bool the carrier of a1;
  cluster downarrow a2 -> lower;
end;

:: WAYBEL_0:funcreg 12
registration
  let a1 be non empty transitive RelStr;
  let a2 be Element of bool the carrier of a1;
  cluster uparrow a2 -> upper;
end;

:: WAYBEL_0:funcreg 13
registration
  let a1 be non empty transitive RelStr;
  let a2 be Element of the carrier of a1;
  cluster downarrow a2 -> lower;
end;

:: WAYBEL_0:funcreg 14
registration
  let a1 be non empty transitive RelStr;
  let a2 be Element of the carrier of a1;
  cluster uparrow a2 -> upper;
end;

:: WAYBEL_0:funcreg 15
registration
  let a1 be non empty RelStr;
  cluster [#] a1 -> lower upper;
end;

:: WAYBEL_0:exreg 8
registration
  let a1 be non empty RelStr;
  cluster non empty lower upper Element of bool the carrier of a1;
end;

:: WAYBEL_0:exreg 9
registration
  let a1 be non empty reflexive transitive RelStr;
  cluster non empty directed lower Element of bool the carrier of a1;
end;

:: WAYBEL_0:exreg 10
registration
  let a1 be non empty reflexive transitive RelStr;
  cluster non empty filtered upper Element of bool the carrier of a1;
end;

:: WAYBEL_0:exreg 11
registration
  let a1 be reflexive transitive antisymmetric with_suprema with_infima RelStr;
  cluster non empty directed filtered lower upper Element of bool the carrier of a1;
end;

:: WAYBEL_0:th 30
theorem
for b1 being non empty reflexive transitive RelStr
for b2 being Element of bool the carrier of b1 holds
      b2 is directed(b1)
   iff
      downarrow b2 is directed(b1);

:: WAYBEL_0:funcreg 16
registration
  let a1 be non empty reflexive transitive RelStr;
  let a2 be directed Element of bool the carrier of a1;
  cluster downarrow a2 -> directed;
end;

:: WAYBEL_0:th 31
theorem
for b1 being non empty reflexive transitive RelStr
for b2 being Element of bool the carrier of b1
for b3 being Element of the carrier of b1 holds
      b2 is_<=_than b3
   iff
      downarrow b2 is_<=_than b3;

:: WAYBEL_0:th 32
theorem
for b1 being non empty reflexive transitive RelStr
for b2 being Element of bool the carrier of b1 holds
      ex_sup_of b2,b1
   iff
      ex_sup_of downarrow b2,b1;

:: WAYBEL_0:th 33
theorem
for b1 being non empty reflexive transitive RelStr
for b2 being Element of bool the carrier of b1
      st ex_sup_of b2,b1
   holds "\/"(b2,b1) = "\/"(downarrow b2,b1);

:: WAYBEL_0:th 34
theorem
for b1 being non empty reflexive transitive antisymmetric RelStr
for b2 being Element of the carrier of b1 holds
   ex_sup_of downarrow b2,b1 & "\/"(downarrow b2,b1) = b2;

:: WAYBEL_0:th 35
theorem
for b1 being non empty reflexive transitive RelStr
for b2 being Element of bool the carrier of b1 holds
      b2 is filtered(b1)
   iff
      uparrow b2 is filtered(b1);

:: WAYBEL_0:funcreg 17
registration
  let a1 be non empty reflexive transitive RelStr;
  let a2 be filtered Element of bool the carrier of a1;
  cluster uparrow a2 -> filtered;
end;

:: WAYBEL_0:th 36
theorem
for b1 being non empty reflexive transitive RelStr
for b2 being Element of bool the carrier of b1
for b3 being Element of the carrier of b1 holds
      b3 is_<=_than b2
   iff
      b3 is_<=_than uparrow b2;

:: WAYBEL_0:th 37
theorem
for b1 being non empty reflexive transitive RelStr
for b2 being Element of bool the carrier of b1 holds
      ex_inf_of b2,b1
   iff
      ex_inf_of uparrow b2,b1;

:: WAYBEL_0:th 38
theorem
for b1 being non empty reflexive transitive RelStr
for b2 being Element of bool the carrier of b1
      st ex_inf_of b2,b1
   holds "/\"(b2,b1) = "/\"(uparrow b2,b1);

:: WAYBEL_0:th 39
theorem
for b1 being non empty reflexive transitive antisymmetric RelStr
for b2 being Element of the carrier of b1 holds
   ex_inf_of uparrow b2,b1 & "/\"(uparrow b2,b1) = b2;

:: WAYBEL_0:modenot 3
definition
  let a1 be non empty reflexive transitive RelStr;
  mode Ideal of a1 is non empty directed lower Element of bool the carrier of a1;
end;

:: WAYBEL_0:modenot 4
definition
  let a1 be non empty reflexive transitive RelStr;
  mode Filter of a1 is non empty filtered upper Element of bool the carrier of a1;
end;

:: WAYBEL_0:th 40
theorem
for b1 being antisymmetric with_suprema RelStr
for b2 being lower Element of bool the carrier of b1 holds
      b2 is directed(b1)
   iff
      for b3, b4 being Element of the carrier of b1
            st b3 in b2 & b4 in b2
         holds b3 "\/" b4 in b2;

:: WAYBEL_0:th 41
theorem
for b1 being antisymmetric with_infima RelStr
for b2 being upper Element of bool the carrier of b1 holds
      b2 is filtered(b1)
   iff
      for b3, b4 being Element of the carrier of b1
            st b3 in b2 & b4 in b2
         holds b3 "/\" b4 in b2;

:: WAYBEL_0:th 42
theorem
for b1 being reflexive transitive antisymmetric with_suprema RelStr
for b2 being non empty lower Element of bool the carrier of b1 holds
      b2 is directed(b1)
   iff
      for b3 being finite Element of bool b2
            st b3 <> {}
         holds "\/"(b3,b1) in b2;

:: WAYBEL_0:th 43
theorem
for b1 being reflexive transitive antisymmetric with_infima RelStr
for b2 being non empty upper Element of bool the carrier of b1 holds
      b2 is filtered(b1)
   iff
      for b3 being finite Element of bool b2
            st b3 <> {}
         holds "/\"(b3,b1) in b2;

:: WAYBEL_0:th 44
theorem
for b1 being non empty antisymmetric RelStr
   st (b1 is with_suprema or b1 is with_infima)
for b2, b3 being Element of bool the carrier of b1
      st b2 is lower(b1) & b2 is directed(b1) & b3 is lower(b1) & b3 is directed(b1)
   holds b2 /\ b3 is directed(b1);

:: WAYBEL_0:th 45
theorem
for b1 being non empty antisymmetric RelStr
   st (b1 is with_suprema or b1 is with_infima)
for b2, b3 being Element of bool the carrier of b1
      st b2 is upper(b1) & b2 is filtered(b1) & b3 is upper(b1) & b3 is filtered(b1)
   holds b2 /\ b3 is filtered(b1);

:: WAYBEL_0:th 46
theorem
for b1 being RelStr
for b2 being Element of bool bool the carrier of b1
   st (for b3 being Element of bool the carrier of b1
            st b3 in b2
         holds b3 is directed(b1)) &
      (for b3, b4 being Element of bool the carrier of b1
            st b3 in b2 & b4 in b2
         holds ex b5 being Element of bool the carrier of b1 st
            b5 in b2 & b3 \/ b4 c= b5)
for b3 being Element of bool the carrier of b1
      st b3 = union b2
   holds b3 is directed(b1);

:: WAYBEL_0:th 47
theorem
for b1 being RelStr
for b2 being Element of bool bool the carrier of b1
   st (for b3 being Element of bool the carrier of b1
            st b3 in b2
         holds b3 is filtered(b1)) &
      (for b3, b4 being Element of bool the carrier of b1
            st b3 in b2 & b4 in b2
         holds ex b5 being Element of bool the carrier of b1 st
            b5 in b2 & b3 \/ b4 c= b5)
for b3 being Element of bool the carrier of b1
      st b3 = union b2
   holds b3 is filtered(b1);

:: WAYBEL_0:attrnot 14 => WAYBEL_0:attr 14
definition
  let a1 be non empty reflexive transitive RelStr;
  let a2 be non empty directed lower Element of bool the carrier of a1;
  attr a2 is principal means
    ex b1 being Element of the carrier of a1 st
       b1 in a2 & a2 is_<=_than b1;
end;

:: WAYBEL_0:dfs 21
definiens
  let a1 be non empty reflexive transitive RelStr;
  let a2 be non empty directed lower Element of bool the carrier of a1;
To prove
     a2 is principal
it is sufficient to prove
  thus ex b1 being Element of the carrier of a1 st
       b1 in a2 & a2 is_<=_than b1;

:: WAYBEL_0:def 21
theorem
for b1 being non empty reflexive transitive RelStr
for b2 being non empty directed lower Element of bool the carrier of b1 holds
      b2 is principal(b1)
   iff
      ex b3 being Element of the carrier of b1 st
         b3 in b2 & b2 is_<=_than b3;

:: WAYBEL_0:attrnot 15 => WAYBEL_0:attr 15
definition
  let a1 be non empty reflexive transitive RelStr;
  let a2 be non empty filtered upper Element of bool the carrier of a1;
  attr a2 is principal means
    ex b1 being Element of the carrier of a1 st
       b1 in a2 & b1 is_<=_than a2;
end;

:: WAYBEL_0:dfs 22
definiens
  let a1 be non empty reflexive transitive RelStr;
  let a2 be non empty filtered upper Element of bool the carrier of a1;
To prove
     a2 is principal
it is sufficient to prove
  thus ex b1 being Element of the carrier of a1 st
       b1 in a2 & b1 is_<=_than a2;

:: WAYBEL_0:def 22
theorem
for b1 being non empty reflexive transitive RelStr
for b2 being non empty filtered upper Element of bool the carrier of b1 holds
      b2 is principal(b1)
   iff
      ex b3 being Element of the carrier of b1 st
         b3 in b2 & b3 is_<=_than b2;

:: WAYBEL_0:th 48
theorem
for b1 being non empty reflexive transitive RelStr
for b2 being non empty directed lower Element of bool the carrier of b1 holds
      b2 is principal(b1)
   iff
      ex b3 being Element of the carrier of b1 st
         b2 = downarrow b3;

:: WAYBEL_0:th 49
theorem
for b1 being non empty reflexive transitive RelStr
for b2 being non empty filtered upper Element of bool the carrier of b1 holds
      b2 is principal(b1)
   iff
      ex b3 being Element of the carrier of b1 st
         b2 = uparrow b3;

:: WAYBEL_0:funcnot 7 => WAYBEL_0:func 7
definition
  let a1 be non empty reflexive transitive RelStr;
  func Ids A1 -> set equals
    {b1 where b1 is non empty directed lower Element of bool the carrier of a1: TRUE};
end;

:: WAYBEL_0:def 23
theorem
for b1 being non empty reflexive transitive RelStr holds
   Ids b1 = {b2 where b2 is non empty directed lower Element of bool the carrier of b1: TRUE};

:: WAYBEL_0:funcnot 8 => WAYBEL_0:func 8
definition
  let a1 be non empty reflexive transitive RelStr;
  func Filt A1 -> set equals
    {b1 where b1 is non empty filtered upper Element of bool the carrier of a1: TRUE};
end;

:: WAYBEL_0:def 24
theorem
for b1 being non empty reflexive transitive RelStr holds
   Filt b1 = {b2 where b2 is non empty filtered upper Element of bool the carrier of b1: TRUE};

:: WAYBEL_0:funcnot 9 => WAYBEL_0:func 9
definition
  let a1 be non empty reflexive transitive RelStr;
  func Ids_0 A1 -> set equals
    (Ids a1) \/ {{}};
end;

:: WAYBEL_0:def 25
theorem
for b1 being non empty reflexive transitive RelStr holds
   Ids_0 b1 = (Ids b1) \/ {{}};

:: WAYBEL_0:funcnot 10 => WAYBEL_0:func 10
definition
  let a1 be non empty reflexive transitive RelStr;
  func Filt_0 A1 -> set equals
    (Filt a1) \/ {{}};
end;

:: WAYBEL_0:def 26
theorem
for b1 being non empty reflexive transitive RelStr holds
   Filt_0 b1 = (Filt b1) \/ {{}};

:: WAYBEL_0:funcnot 11 => WAYBEL_0:func 11
definition
  let a1 be non empty RelStr;
  let a2 be Element of bool the carrier of a1;
  func finsups A2 -> Element of bool the carrier of a1 equals
    {"\/"(b1,a1) where b1 is finite Element of bool a2: ex_sup_of b1,a1};
end;

:: WAYBEL_0:def 27
theorem
for b1 being non empty RelStr
for b2 being Element of bool the carrier of b1 holds
   finsups b2 = {"\/"(b3,b1) where b3 is finite Element of bool b2: ex_sup_of b3,b1};

:: WAYBEL_0:funcnot 12 => WAYBEL_0:func 12
definition
  let a1 be non empty RelStr;
  let a2 be Element of bool the carrier of a1;
  func fininfs A2 -> Element of bool the carrier of a1 equals
    {"/\"(b1,a1) where b1 is finite Element of bool a2: ex_inf_of b1,a1};
end;

:: WAYBEL_0:def 28
theorem
for b1 being non empty RelStr
for b2 being Element of bool the carrier of b1 holds
   fininfs b2 = {"/\"(b3,b1) where b3 is finite Element of bool b2: ex_inf_of b3,b1};

:: WAYBEL_0:funcreg 18
registration
  let a1 be non empty antisymmetric lower-bounded RelStr;
  let a2 be Element of bool the carrier of a1;
  cluster finsups a2 -> non empty;
end;

:: WAYBEL_0:funcreg 19
registration
  let a1 be non empty antisymmetric upper-bounded RelStr;
  let a2 be Element of bool the carrier of a1;
  cluster fininfs a2 -> non empty;
end;

:: WAYBEL_0:funcreg 20
registration
  let a1 be non empty reflexive antisymmetric RelStr;
  let a2 be non empty Element of bool the carrier of a1;
  cluster finsups a2 -> non empty;
end;

:: WAYBEL_0:funcreg 21
registration
  let a1 be non empty reflexive antisymmetric RelStr;
  let a2 be non empty Element of bool the carrier of a1;
  cluster fininfs a2 -> non empty;
end;

:: WAYBEL_0:th 50
theorem
for b1 being non empty reflexive antisymmetric RelStr
for b2 being Element of bool the carrier of b1 holds
   b2 c= finsups b2 & b2 c= fininfs b2;

:: WAYBEL_0:th 51
theorem
for b1 being non empty transitive RelStr
for b2, b3 being Element of bool the carrier of b1
      st (for b4 being finite Element of bool b2
               st b4 <> {}
            holds ex_sup_of b4,b1) &
         (for b4 being Element of the carrier of b1
               st b4 in b3
            holds ex b5 being finite Element of bool b2 st
               ex_sup_of b5,b1 & b4 = "\/"(b5,b1)) &
         (for b4 being finite Element of bool b2
               st b4 <> {}
            holds "\/"(b4,b1) in b3)
   holds b3 is directed(b1);

:: WAYBEL_0:funcreg 22
registration
  let a1 be reflexive transitive antisymmetric with_suprema RelStr;
  let a2 be Element of bool the carrier of a1;
  cluster finsups a2 -> directed;
end;

:: WAYBEL_0:th 52
theorem
for b1 being non empty reflexive transitive RelStr
for b2, b3 being Element of bool the carrier of b1
   st (for b4 being finite Element of bool b2
            st b4 <> {}
         holds ex_sup_of b4,b1) &
      (for b4 being Element of the carrier of b1
            st b4 in b3
         holds ex b5 being finite Element of bool b2 st
            ex_sup_of b5,b1 & b4 = "\/"(b5,b1)) &
      (for b4 being finite Element of bool b2
            st b4 <> {}
         holds "\/"(b4,b1) in b3)
for b4 being Element of the carrier of b1 holds
      b2 is_<=_than b4
   iff
      b3 is_<=_than b4;

:: WAYBEL_0:th 53
theorem
for b1 being non empty reflexive transitive RelStr
for b2, b3 being Element of bool the carrier of b1
      st (for b4 being finite Element of bool b2
               st b4 <> {}
            holds ex_sup_of b4,b1) &
         (for b4 being Element of the carrier of b1
               st b4 in b3
            holds ex b5 being finite Element of bool b2 st
               ex_sup_of b5,b1 & b4 = "\/"(b5,b1)) &
         (for b4 being finite Element of bool b2
               st b4 <> {}
            holds "\/"(b4,b1) in b3)
   holds    ex_sup_of b2,b1
   iff
      ex_sup_of b3,b1;

:: WAYBEL_0:th 54
theorem
for b1 being non empty reflexive transitive RelStr
for b2, b3 being Element of bool the carrier of b1
      st (for b4 being finite Element of bool b2
               st b4 <> {}
            holds ex_sup_of b4,b1) &
         (for b4 being Element of the carrier of b1
               st b4 in b3
            holds ex b5 being finite Element of bool b2 st
               ex_sup_of b5,b1 & b4 = "\/"(b5,b1)) &
         (for b4 being finite Element of bool b2
               st b4 <> {}
            holds "\/"(b4,b1) in b3) &
         ex_sup_of b2,b1
   holds "\/"(b3,b1) = "\/"(b2,b1);

:: WAYBEL_0:th 55
theorem
for b1 being reflexive transitive antisymmetric with_suprema RelStr
for b2 being Element of bool the carrier of b1
      st (ex_sup_of b2,b1 or b1 is complete)
   holds "\/"(b2,b1) = "\/"(finsups b2,b1);

:: WAYBEL_0:th 56
theorem
for b1 being non empty transitive RelStr
for b2, b3 being Element of bool the carrier of b1
      st (for b4 being finite Element of bool b2
               st b4 <> {}
            holds ex_inf_of b4,b1) &
         (for b4 being Element of the carrier of b1
               st b4 in b3
            holds ex b5 being finite Element of bool b2 st
               ex_inf_of b5,b1 & b4 = "/\"(b5,b1)) &
         (for b4 being finite Element of bool b2
               st b4 <> {}
            holds "/\"(b4,b1) in b3)
   holds b3 is filtered(b1);

:: WAYBEL_0:funcreg 23
registration
  let a1 be reflexive transitive antisymmetric with_infima RelStr;
  let a2 be Element of bool the carrier of a1;
  cluster fininfs a2 -> filtered;
end;

:: WAYBEL_0:th 57
theorem
for b1 being non empty reflexive transitive RelStr
for b2, b3 being Element of bool the carrier of b1
   st (for b4 being finite Element of bool b2
            st b4 <> {}
         holds ex_inf_of b4,b1) &
      (for b4 being Element of the carrier of b1
            st b4 in b3
         holds ex b5 being finite Element of bool b2 st
            ex_inf_of b5,b1 & b4 = "/\"(b5,b1)) &
      (for b4 being finite Element of bool b2
            st b4 <> {}
         holds "/\"(b4,b1) in b3)
for b4 being Element of the carrier of b1 holds
      b4 is_<=_than b2
   iff
      b4 is_<=_than b3;

:: WAYBEL_0:th 58
theorem
for b1 being non empty reflexive transitive RelStr
for b2, b3 being Element of bool the carrier of b1
      st (for b4 being finite Element of bool b2
               st b4 <> {}
            holds ex_inf_of b4,b1) &
         (for b4 being Element of the carrier of b1
               st b4 in b3
            holds ex b5 being finite Element of bool b2 st
               ex_inf_of b5,b1 & b4 = "/\"(b5,b1)) &
         (for b4 being finite Element of bool b2
               st b4 <> {}
            holds "/\"(b4,b1) in b3)
   holds    ex_inf_of b2,b1
   iff
      ex_inf_of b3,b1;

:: WAYBEL_0:th 59
theorem
for b1 being non empty reflexive transitive RelStr
for b2, b3 being Element of bool the carrier of b1
      st (for b4 being finite Element of bool b2
               st b4 <> {}
            holds ex_inf_of b4,b1) &
         (for b4 being Element of the carrier of b1
               st b4 in b3
            holds ex b5 being finite Element of bool b2 st
               ex_inf_of b5,b1 & b4 = "/\"(b5,b1)) &
         (for b4 being finite Element of bool b2
               st b4 <> {}
            holds "/\"(b4,b1) in b3) &
         ex_inf_of b2,b1
   holds "/\"(b3,b1) = "/\"(b2,b1);

:: WAYBEL_0:th 60
theorem
for b1 being reflexive transitive antisymmetric with_infima RelStr
for b2 being Element of bool the carrier of b1
      st (ex_inf_of b2,b1 or b1 is complete)
   holds "/\"(b2,b1) = "/\"(fininfs b2,b1);

:: WAYBEL_0:th 61
theorem
for b1 being reflexive transitive antisymmetric with_suprema RelStr
for b2 being Element of bool the carrier of b1 holds
   b2 c= downarrow finsups b2 &
    (for b3 being non empty directed lower Element of bool the carrier of b1
          st b2 c= b3
       holds downarrow finsups b2 c= b3);

:: WAYBEL_0:th 62
theorem
for b1 being reflexive transitive antisymmetric with_infima RelStr
for b2 being Element of bool the carrier of b1 holds
   b2 c= uparrow fininfs b2 &
    (for b3 being non empty filtered upper Element of bool the carrier of b1
          st b2 c= b3
       holds uparrow fininfs b2 c= b3);

:: WAYBEL_0:attrnot 16 => WAYBEL_0:attr 16
definition
  let a1 be non empty RelStr;
  attr a1 is connected means
    for b1, b2 being Element of the carrier of a1
          st not b1 <= b2
       holds b2 <= b1;
end;

:: WAYBEL_0:dfs 29
definiens
  let a1 be non empty RelStr;
To prove
     a1 is connected
it is sufficient to prove
  thus for b1, b2 being Element of the carrier of a1
          st not b1 <= b2
       holds b2 <= b1;

:: WAYBEL_0:def 29
theorem
for b1 being non empty RelStr holds
      b1 is connected
   iff
      for b2, b3 being Element of the carrier of b1
            st not b2 <= b3
         holds b3 <= b2;

:: WAYBEL_0:condreg 5
registration
  cluster non empty trivial reflexive -> connected (RelStr);
end;

:: WAYBEL_0:exreg 12
registration
  cluster non empty total reflexive transitive antisymmetric connected RelStr;
end;

:: WAYBEL_0:modenot 5
definition
  mode Chain is non empty reflexive transitive antisymmetric connected RelStr;
end;

:: WAYBEL_0:funcreg 24
registration
  let a1 be non empty reflexive transitive antisymmetric connected RelStr;
  cluster a1 ~ -> strict connected;
end;

:: WAYBEL_0:modenot 6
definition
  mode Semilattice is reflexive transitive antisymmetric with_infima RelStr;
end;

:: WAYBEL_0:modenot 7
definition
  mode sup-Semilattice is reflexive transitive antisymmetric with_suprema RelStr;
end;

:: WAYBEL_0:modenot 8
definition
  mode LATTICE is reflexive transitive antisymmetric with_suprema with_infima RelStr;
end;

:: WAYBEL_0:th 63
theorem
for b1 being reflexive transitive antisymmetric with_infima RelStr
for b2 being non empty upper Element of bool the carrier of b1 holds
      b2 is non empty filtered upper Element of bool the carrier of b1
   iff
      subrelstr b2 is meet-inheriting(b1);

:: WAYBEL_0:th 64
theorem
for b1 being reflexive transitive antisymmetric with_suprema RelStr
for b2 being non empty lower Element of bool the carrier of b1 holds
      b2 is non empty directed lower Element of bool the carrier of b1
   iff
      subrelstr b2 is join-inheriting(b1);

:: WAYBEL_0:prednot 3 => WAYBEL_0:pred 3
definition
  let a1, a2 be non empty RelStr;
  let a3 be Function-like quasi_total Relation of the carrier of a1,the carrier of a2;
  let a4 be Element of bool the carrier of a1;
  pred A3 preserves_inf_of A4 means
    (ex_inf_of a4,a1) implies ex_inf_of a3 .: a4,a2 &
     "/\"(a3 .: a4,a2) = a3 . "/\"(a4,a1);
end;

:: WAYBEL_0:dfs 30
definiens
  let a1, a2 be non empty RelStr;
  let a3 be Function-like quasi_total Relation of the carrier of a1,the carrier of a2;
  let a4 be Element of bool the carrier of a1;
To prove
     a3 preserves_inf_of a4
it is sufficient to prove
  thus (ex_inf_of a4,a1) implies ex_inf_of a3 .: a4,a2 &
     "/\"(a3 .: a4,a2) = a3 . "/\"(a4,a1);

:: WAYBEL_0:def 30
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
for b4 being Element of bool the carrier of b1 holds
      b3 preserves_inf_of b4
   iff
      (ex_inf_of b4,b1 implies ex_inf_of b3 .: b4,b2 &
       "/\"(b3 .: b4,b2) = b3 . "/\"(b4,b1));

:: WAYBEL_0:prednot 4 => WAYBEL_0:pred 4
definition
  let a1, a2 be non empty RelStr;
  let a3 be Function-like quasi_total Relation of the carrier of a1,the carrier of a2;
  let a4 be Element of bool the carrier of a1;
  pred A3 preserves_sup_of A4 means
    (ex_sup_of a4,a1) implies ex_sup_of a3 .: a4,a2 &
     "\/"(a3 .: a4,a2) = a3 . "\/"(a4,a1);
end;

:: WAYBEL_0:dfs 31
definiens
  let a1, a2 be non empty RelStr;
  let a3 be Function-like quasi_total Relation of the carrier of a1,the carrier of a2;
  let a4 be Element of bool the carrier of a1;
To prove
     a3 preserves_sup_of a4
it is sufficient to prove
  thus (ex_sup_of a4,a1) implies ex_sup_of a3 .: a4,a2 &
     "\/"(a3 .: a4,a2) = a3 . "\/"(a4,a1);

:: WAYBEL_0:def 31
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
for b4 being Element of bool the carrier of b1 holds
      b3 preserves_sup_of b4
   iff
      (ex_sup_of b4,b1 implies ex_sup_of b3 .: b4,b2 &
       "\/"(b3 .: b4,b2) = b3 . "\/"(b4,b1));

:: WAYBEL_0:th 65
theorem
for b1, b2, b3, b4 being non empty RelStr
   st RelStr(#the carrier of b1,the InternalRel of b1#) = RelStr(#the carrier of b3,the InternalRel of b3#) &
      RelStr(#the carrier of b2,the InternalRel of b2#) = RelStr(#the carrier of b4,the InternalRel of b4#)
for b5 being Function-like quasi_total Relation of the carrier of b1,the carrier of b2
for b6 being Function-like quasi_total Relation of the carrier of b3,the carrier of b4
   st b5 = b6
for b7 being Element of bool the carrier of b1
for b8 being Element of bool the carrier of b3
      st b7 = b8
   holds (b5 preserves_sup_of b7 implies b6 preserves_sup_of b8) & (b5 preserves_inf_of b7 implies b6 preserves_inf_of b8);

:: WAYBEL_0:attrnot 17 => WAYBEL_0:attr 17
definition
  let a1, a2 be non empty RelStr;
  let a3 be Function-like quasi_total Relation of the carrier of a1,the carrier of a2;
  attr a3 is infs-preserving means
    for b1 being Element of bool the carrier of a1 holds
       a3 preserves_inf_of b1;
end;

:: WAYBEL_0:dfs 32
definiens
  let a1, a2 be non empty RelStr;
  let a3 be Function-like quasi_total Relation of the carrier of a1,the carrier of a2;
To prove
     a3 is infs-preserving
it is sufficient to prove
  thus for b1 being Element of bool the carrier of a1 holds
       a3 preserves_inf_of b1;

:: WAYBEL_0:def 32
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 holds
      b3 is infs-preserving(b1, b2)
   iff
      for b4 being Element of bool the carrier of b1 holds
         b3 preserves_inf_of b4;

:: WAYBEL_0:attrnot 18 => WAYBEL_0:attr 18
definition
  let a1, a2 be non empty RelStr;
  let a3 be Function-like quasi_total Relation of the carrier of a1,the carrier of a2;
  attr a3 is sups-preserving means
    for b1 being Element of bool the carrier of a1 holds
       a3 preserves_sup_of b1;
end;

:: WAYBEL_0:dfs 33
definiens
  let a1, a2 be non empty RelStr;
  let a3 be Function-like quasi_total Relation of the carrier of a1,the carrier of a2;
To prove
     a3 is sups-preserving
it is sufficient to prove
  thus for b1 being Element of bool the carrier of a1 holds
       a3 preserves_sup_of b1;

:: WAYBEL_0:def 33
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 holds
      b3 is sups-preserving(b1, b2)
   iff
      for b4 being Element of bool the carrier of b1 holds
         b3 preserves_sup_of b4;

:: WAYBEL_0:attrnot 19 => WAYBEL_0:attr 19
definition
  let a1, a2 be non empty RelStr;
  let a3 be Function-like quasi_total Relation of the carrier of a1,the carrier of a2;
  attr a3 is meet-preserving means
    for b1, b2 being Element of the carrier of a1 holds
    a3 preserves_inf_of {b1,b2};
end;

:: WAYBEL_0:dfs 34
definiens
  let a1, a2 be non empty RelStr;
  let a3 be Function-like quasi_total Relation of the carrier of a1,the carrier of a2;
To prove
     a3 is meet-preserving
it is sufficient to prove
  thus for b1, b2 being Element of the carrier of a1 holds
    a3 preserves_inf_of {b1,b2};

:: WAYBEL_0:def 34
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 holds
      b3 is meet-preserving(b1, b2)
   iff
      for b4, b5 being Element of the carrier of b1 holds
      b3 preserves_inf_of {b4,b5};

:: WAYBEL_0:attrnot 20 => WAYBEL_0:attr 20
definition
  let a1, a2 be non empty RelStr;
  let a3 be Function-like quasi_total Relation of the carrier of a1,the carrier of a2;
  attr a3 is join-preserving means
    for b1, b2 being Element of the carrier of a1 holds
    a3 preserves_sup_of {b1,b2};
end;

:: WAYBEL_0:dfs 35
definiens
  let a1, a2 be non empty RelStr;
  let a3 be Function-like quasi_total Relation of the carrier of a1,the carrier of a2;
To prove
     a3 is join-preserving
it is sufficient to prove
  thus for b1, b2 being Element of the carrier of a1 holds
    a3 preserves_sup_of {b1,b2};

:: WAYBEL_0:def 35
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 holds
      b3 is join-preserving(b1, b2)
   iff
      for b4, b5 being Element of the carrier of b1 holds
      b3 preserves_sup_of {b4,b5};

:: WAYBEL_0:attrnot 21 => WAYBEL_0:attr 21
definition
  let a1, a2 be non empty RelStr;
  let a3 be Function-like quasi_total Relation of the carrier of a1,the carrier of a2;
  attr a3 is filtered-infs-preserving means
    for b1 being Element of bool the carrier of a1
          st b1 is not empty & b1 is filtered(a1)
       holds a3 preserves_inf_of b1;
end;

:: WAYBEL_0:dfs 36
definiens
  let a1, a2 be non empty RelStr;
  let a3 be Function-like quasi_total Relation of the carrier of a1,the carrier of a2;
To prove
     a3 is filtered-infs-preserving
it is sufficient to prove
  thus for b1 being Element of bool the carrier of a1
          st b1 is not empty & b1 is filtered(a1)
       holds a3 preserves_inf_of b1;

:: WAYBEL_0:def 36
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 holds
      b3 is filtered-infs-preserving(b1, b2)
   iff
      for b4 being Element of bool the carrier of b1
            st b4 is not empty & b4 is filtered(b1)
         holds b3 preserves_inf_of b4;

:: WAYBEL_0:attrnot 22 => WAYBEL_0:attr 22
definition
  let a1, a2 be non empty RelStr;
  let a3 be Function-like quasi_total Relation of the carrier of a1,the carrier of a2;
  attr a3 is directed-sups-preserving means
    for b1 being Element of bool the carrier of a1
          st b1 is not empty & b1 is directed(a1)
       holds a3 preserves_sup_of b1;
end;

:: WAYBEL_0:dfs 37
definiens
  let a1, a2 be non empty RelStr;
  let a3 be Function-like quasi_total Relation of the carrier of a1,the carrier of a2;
To prove
     a3 is directed-sups-preserving
it is sufficient to prove
  thus for b1 being Element of bool the carrier of a1
          st b1 is not empty & b1 is directed(a1)
       holds a3 preserves_sup_of b1;

:: WAYBEL_0:def 37
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 holds
      b3 is directed-sups-preserving(b1, b2)
   iff
      for b4 being Element of bool the carrier of b1
            st b4 is not empty & b4 is directed(b1)
         holds b3 preserves_sup_of b4;

:: WAYBEL_0:condreg 6
registration
  let a1, a2 be non empty RelStr;
  cluster Function-like quasi_total infs-preserving -> meet-preserving filtered-infs-preserving (Relation of the carrier of a1,the carrier of a2);
end;

:: WAYBEL_0:condreg 7
registration
  let a1, a2 be non empty RelStr;
  cluster Function-like quasi_total sups-preserving -> join-preserving directed-sups-preserving (Relation of the carrier of a1,the carrier of a2);
end;

:: WAYBEL_0:attrnot 23 => WAYBEL_0:attr 23
definition
  let a1, a2 be RelStr;
  let a3 be Function-like quasi_total Relation of the carrier of a1,the carrier of a2;
  attr a3 is isomorphic means
    a3 is one-to-one &
     a3 is monotone(a1, a2) &
     (ex b1 being Function-like quasi_total Relation of the carrier of a2,the carrier of a1 st
        b1 = a3 " & b1 is monotone(a2, a1))
    if a1 is not empty & a2 is not empty
    otherwise a1 is empty & a2 is empty;
end;

:: WAYBEL_0:dfs 38
definiens
  let a1, a2 be RelStr;
  let a3 be Function-like quasi_total Relation of the carrier of a1,the carrier of a2;
To prove
     a3 is isomorphic
it is sufficient to prove
  per cases;
  case a1 is not empty & a2 is not empty;
    thus a3 is one-to-one &
     a3 is monotone(a1, a2) &
     (ex b1 being Function-like quasi_total Relation of the carrier of a2,the carrier of a1 st
        b1 = a3 " & b1 is monotone(a2, a1));
  end;
  case (a1 is empty or a2 is empty);
    thus a1 is empty & a2 is empty;
  end;

:: WAYBEL_0:def 38
theorem
for b1, b2 being RelStr
for b3 being Function-like quasi_total Relation of the carrier of b1,the carrier of b2 holds
   (b1 is not empty & b2 is not empty implies    (b3 is isomorphic(b1, b2)
    iff
       b3 is one-to-one &
        b3 is monotone(b1, b2) &
        (ex b4 being Function-like quasi_total Relation of the carrier of b2,the carrier of b1 st
           b4 = b3 " & b4 is monotone(b2, b1)))) &
    (b1 is not empty & b2 is not empty or    (b3 is isomorphic(b1, b2)
    iff
       b1 is empty & b2 is empty));

:: WAYBEL_0:th 66
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 holds
      b3 is isomorphic(b1, b2)
   iff
      b3 is one-to-one &
       rng b3 = the carrier of b2 &
       (for b4, b5 being Element of the carrier of b1 holds
          b4 <= b5
       iff
          b3 . b4 <= b3 . b5);

:: WAYBEL_0:condreg 8
registration
  let a1, a2 be non empty RelStr;
  cluster Function-like quasi_total isomorphic -> one-to-one monotone (Relation of the carrier of a1,the carrier of a2);
end;

:: WAYBEL_0:th 67
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 b3 is isomorphic(b1, b2)
   holds b3 " is Function-like quasi_total Relation of the carrier of b2,the carrier of b1 &
    proj2 (b3 ") = the carrier of b1;

:: WAYBEL_0:th 68
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 b3 is isomorphic(b1, b2)
for b4 being Function-like quasi_total Relation of the carrier of b2,the carrier of b1
      st b4 = b3 "
   holds b4 is isomorphic(b2, b1);

:: WAYBEL_0:th 69
theorem
for b1, b2 being non empty reflexive transitive antisymmetric RelStr
for b3 being Function-like quasi_total Relation of the carrier of b1,the carrier of b2
      st for b4 being non empty filtered upper Element of bool the carrier of b1 holds
           b3 preserves_inf_of b4
   holds b3 is monotone(b1, b2);

:: WAYBEL_0:th 70
theorem
for b1, b2 being non empty reflexive transitive antisymmetric RelStr
for b3 being Function-like quasi_total Relation of the carrier of b1,the carrier of b2
      st for b4 being non empty filtered upper Element of bool the carrier of b1 holds
           b3 preserves_inf_of b4
   holds b3 is filtered-infs-preserving(b1, b2);

:: WAYBEL_0:th 71
theorem
for b1 being reflexive transitive antisymmetric with_infima RelStr
for b2 being non empty reflexive transitive antisymmetric RelStr
for b3 being Function-like quasi_total Relation of the carrier of b1,the carrier of b2
      st (for b4 being finite Element of bool the carrier of b1 holds
            b3 preserves_inf_of b4) &
         (for b4 being non empty filtered Element of bool the carrier of b1 holds
            b3 preserves_inf_of b4)
   holds b3 is infs-preserving(b1, b2);

:: WAYBEL_0:th 72
theorem
for b1, b2 being non empty reflexive transitive antisymmetric RelStr
for b3 being Function-like quasi_total Relation of the carrier of b1,the carrier of b2
      st for b4 being non empty directed lower Element of bool the carrier of b1 holds
           b3 preserves_sup_of b4
   holds b3 is monotone(b1, b2);

:: WAYBEL_0:th 73
theorem
for b1, b2 being non empty reflexive transitive antisymmetric RelStr
for b3 being Function-like quasi_total Relation of the carrier of b1,the carrier of b2
      st for b4 being non empty directed lower Element of bool the carrier of b1 holds
           b3 preserves_sup_of b4
   holds b3 is directed-sups-preserving(b1, b2);

:: WAYBEL_0:th 74
theorem
for b1 being reflexive transitive antisymmetric with_suprema RelStr
for b2 being non empty reflexive transitive antisymmetric RelStr
for b3 being Function-like quasi_total Relation of the carrier of b1,the carrier of b2
      st (for b4 being finite Element of bool the carrier of b1 holds
            b3 preserves_sup_of b4) &
         (for b4 being non empty directed Element of bool the carrier of b1 holds
            b3 preserves_sup_of b4)
   holds b3 is sups-preserving(b1, b2);

:: WAYBEL_0:attrnot 24 => WAYBEL_0:attr 24
definition
  let a1 be non empty reflexive RelStr;
  attr a1 is up-complete means
    for b1 being non empty directed Element of bool the carrier of a1 holds
       ex b2 being Element of the carrier of a1 st
          b1 is_<=_than b2 &
           (for b3 being Element of the carrier of a1
                 st b1 is_<=_than b3
              holds b2 <= b3);
end;

:: WAYBEL_0:dfs 39
definiens
  let a1 be non empty reflexive RelStr;
To prove
     a1 is up-complete
it is sufficient to prove
  thus for b1 being non empty directed Element of bool the carrier of a1 holds
       ex b2 being Element of the carrier of a1 st
          b1 is_<=_than b2 &
           (for b3 being Element of the carrier of a1
                 st b1 is_<=_than b3
              holds b2 <= b3);

:: WAYBEL_0:def 39
theorem
for b1 being non empty reflexive RelStr holds
      b1 is up-complete
   iff
      for b2 being non empty directed Element of bool the carrier of b1 holds
         ex b3 being Element of the carrier of b1 st
            b2 is_<=_than b3 &
             (for b4 being Element of the carrier of b1
                   st b2 is_<=_than b4
                holds b3 <= b4);

:: WAYBEL_0:condreg 9
registration
  cluster reflexive with_suprema up-complete -> upper-bounded (RelStr);
end;

:: WAYBEL_0:th 75
theorem
for b1 being non empty reflexive antisymmetric RelStr holds
      b1 is up-complete
   iff
      for b2 being non empty directed Element of bool the carrier of b1 holds
         ex_sup_of b2,b1;

:: WAYBEL_0:attrnot 25 => WAYBEL_0:attr 25
definition
  let a1 be non empty reflexive RelStr;
  attr a1 is /\-complete means
    for b1 being non empty Element of bool the carrier of a1 holds
       ex b2 being Element of the carrier of a1 st
          b2 is_<=_than b1 &
           (for b3 being Element of the carrier of a1
                 st b3 is_<=_than b1
              holds b3 <= b2);
end;

:: WAYBEL_0:dfs 40
definiens
  let a1 be non empty reflexive RelStr;
To prove
     a1 is /\-complete
it is sufficient to prove
  thus for b1 being non empty Element of bool the carrier of a1 holds
       ex b2 being Element of the carrier of a1 st
          b2 is_<=_than b1 &
           (for b3 being Element of the carrier of a1
                 st b3 is_<=_than b1
              holds b3 <= b2);

:: WAYBEL_0:def 40
theorem
for b1 being non empty reflexive RelStr holds
      b1 is /\-complete
   iff
      for b2 being non empty Element of bool the carrier of b1 holds
         ex b3 being Element of the carrier of b1 st
            b3 is_<=_than b2 &
             (for b4 being Element of the carrier of b1
                   st b4 is_<=_than b2
                holds b4 <= b3);

:: WAYBEL_0:th 76
theorem
for b1 being non empty reflexive antisymmetric RelStr holds
      b1 is /\-complete
   iff
      for b2 being non empty Element of bool the carrier of b1 holds
         ex_inf_of b2,b1;

:: WAYBEL_0:condreg 10
registration
  cluster non empty reflexive complete -> up-complete /\-complete (RelStr);
end;

:: WAYBEL_0:condreg 11
registration
  cluster non empty reflexive /\-complete -> lower-bounded (RelStr);
end;

:: WAYBEL_0:condreg 12
registration
  cluster non empty reflexive transitive antisymmetric with_suprema lower-bounded up-complete -> complete (RelStr);
end;

:: WAYBEL_0:condreg 13
registration
  cluster non empty reflexive antisymmetric /\-complete -> with_infima (RelStr);
end;

:: WAYBEL_0:condreg 14
registration
  cluster non empty reflexive antisymmetric upper-bounded /\-complete -> with_suprema (RelStr);
end;

:: WAYBEL_0:exreg 13
registration
  cluster non empty strict total reflexive transitive antisymmetric with_suprema with_infima complete RelStr;
end;