Article OSALG_1, MML version 4.99.1005

:: OSALG_1:funcreg 1
registration
  let a1 be set;
  let a2 be ManySortedSet of a1;
  let a3 be FinSequence of a1;
  cluster a3 * a2 -> Relation-like FinSequence-like;
end;

:: OSALG_1:modenot 1
definition
  let a1 be non empty ManySortedSign;
  mode SortSymbol of a1 is Element of the carrier of a1;
end;

:: OSALG_1:modenot 2
definition
  let a1 be non empty ManySortedSign;
  mode OperSymbol of a1 is Element of the OperSymbols of a1;
end;

:: OSALG_1:funcnot 1 => OSALG_1:func 1
definition
  let a1 be non empty non void ManySortedSign;
  let a2 be Element of the OperSymbols of a1;
  redefine func the_result_sort_of a2 -> Element of the carrier of a1;
end;

:: OSALG_1:structnot 1 => OSALG_1:struct 1
definition
  struct(ManySortedSign) OverloadedMSSign(#
    carrier -> set,
    OperSymbols -> set,
    Overloading -> symmetric transitive total Relation of the OperSymbols of it,the OperSymbols of it,
    Arity -> Function-like quasi_total Relation of the OperSymbols of it,(the carrier of it) *,
    ResultSort -> Function-like quasi_total Relation of the OperSymbols of it,the carrier of it
  #);
end;

:: OSALG_1:attrnot 1 => OSALG_1:attr 1
definition
  let a1 be OverloadedMSSign;
  attr a1 is strict;
end;

:: OSALG_1:exreg 1
registration
  cluster strict OverloadedMSSign;
end;

:: OSALG_1:aggrnot 1 => OSALG_1:aggr 1
definition
  let a1, a2 be set;
  let a3 be symmetric transitive total Relation of a2,a2;
  let a4 be Function-like quasi_total Relation of a2,a1 *;
  let a5 be Function-like quasi_total Relation of a2,a1;
  aggr OverloadedMSSign(#a1,a2,a3,a4,a5#) -> strict OverloadedMSSign;
end;

:: OSALG_1:selnot 1 => OSALG_1:sel 1
definition
  let a1 be OverloadedMSSign;
  sel the Overloading of a1 -> symmetric transitive total Relation of the OperSymbols of a1,the OperSymbols of a1;
end;

:: OSALG_1:structnot 2 => OSALG_1:struct 2
definition
  struct(ManySortedSignRelStr) RelSortedSign(#
    carrier -> set,
    InternalRel -> Relation of the carrier of it,the carrier of it,
    OperSymbols -> set,
    Arity -> Function-like quasi_total Relation of the OperSymbols of it,(the carrier of it) *,
    ResultSort -> Function-like quasi_total Relation of the OperSymbols of it,the carrier of it
  #);
end;

:: OSALG_1:attrnot 2 => OSALG_1:attr 2
definition
  let a1 be RelSortedSign;
  attr a1 is strict;
end;

:: OSALG_1:exreg 2
registration
  cluster strict RelSortedSign;
end;

:: OSALG_1:aggrnot 2 => OSALG_1:aggr 2
definition
  let a1 be set;
  let a2 be Relation of a1,a1;
  let a3 be set;
  let a4 be Function-like quasi_total Relation of a3,a1 *;
  let a5 be Function-like quasi_total Relation of a3,a1;
  aggr RelSortedSign(#a1,a2,a3,a4,a5#) -> strict RelSortedSign;
end;

:: OSALG_1:structnot 3 => OSALG_1:struct 3
definition
  struct(OverloadedMSSignRelSortedSign) OverloadedRSSign(#
    carrier -> set,
    InternalRel -> Relation of the carrier of it,the carrier of it,
    OperSymbols -> set,
    Overloading -> symmetric transitive total Relation of the OperSymbols of it,the OperSymbols of it,
    Arity -> Function-like quasi_total Relation of the OperSymbols of it,(the carrier of it) *,
    ResultSort -> Function-like quasi_total Relation of the OperSymbols of it,the carrier of it
  #);
end;

:: OSALG_1:attrnot 3 => OSALG_1:attr 3
definition
  let a1 be OverloadedRSSign;
  attr a1 is strict;
end;

:: OSALG_1:exreg 3
registration
  cluster strict OverloadedRSSign;
end;

:: OSALG_1:aggrnot 3 => OSALG_1:aggr 3
definition
  let a1 be set;
  let a2 be Relation of a1,a1;
  let a3 be set;
  let a4 be symmetric transitive total Relation of a3,a3;
  let a5 be Function-like quasi_total Relation of a3,a1 *;
  let a6 be Function-like quasi_total Relation of a3,a1;
  aggr OverloadedRSSign(#a1,a2,a3,a4,a5,a6#) -> strict OverloadedRSSign;
end;

:: OSALG_1:th 1
theorem
for b1, b2 being non empty set
for b3 being reflexive antisymmetric transitive total Relation of b1,b1
for b4 being symmetric transitive total Relation of b2,b2
for b5 being Function-like quasi_total Relation of b2,b1 *
for b6 being Function-like quasi_total Relation of b2,b1 holds
   OverloadedRSSign(#b1,b3,b2,b4,b5,b6#) is not empty & OverloadedRSSign(#b1,b3,b2,b4,b5,b6#) is not void & OverloadedRSSign(#b1,b3,b2,b4,b5,b6#) is reflexive & OverloadedRSSign(#b1,b3,b2,b4,b5,b6#) is transitive & OverloadedRSSign(#b1,b3,b2,b4,b5,b6#) is antisymmetric;

:: OSALG_1:funcreg 2
registration
  let a1 be non empty set;
  let a2 be reflexive antisymmetric transitive total Relation of a1,a1;
  let a3 be non empty set;
  let a4 be symmetric transitive total Relation of a3,a3;
  let a5 be Function-like quasi_total Relation of a3,a1 *;
  let a6 be Function-like quasi_total Relation of a3,a1;
  cluster OverloadedRSSign(#a1,a2,a3,a4,a5,a6#) -> non empty reflexive transitive antisymmetric strict;
end;

:: OSALG_1:attrnot 4 => OSALG_1:attr 4
definition
  let a1 be OverloadedRSSign;
  attr a1 is order-sorted means
    a1 is reflexive & a1 is transitive & a1 is antisymmetric;
end;

:: OSALG_1:dfs 1
definiens
  let a1 be OverloadedRSSign;
To prove
     a1 is order-sorted
it is sufficient to prove
  thus a1 is reflexive & a1 is transitive & a1 is antisymmetric;

:: OSALG_1:def 2
theorem
for b1 being OverloadedRSSign holds
      b1 is order-sorted
   iff
      b1 is reflexive & b1 is transitive & b1 is antisymmetric;

:: OSALG_1:condreg 1
registration
  cluster order-sorted -> reflexive transitive antisymmetric (OverloadedRSSign);
end;

:: OSALG_1:exreg 4
registration
  cluster non empty non void strict order-sorted OverloadedRSSign;
end;

:: OSALG_1:exreg 5
registration
  cluster non empty non void OverloadedMSSign;
end;

:: OSALG_1:prednot 1 => OSALG_1:pred 1
definition
  let a1 be non empty non void OverloadedMSSign;
  let a2, a3 be Element of the OperSymbols of a1;
  pred A2 ~= A3 means
    [a2,a3] in the Overloading of a1;
  symmetry;
::  for a1 being non empty non void OverloadedMSSign
::  for a2, a3 being Element of the OperSymbols of a1
::        st a2 ~= a3
::     holds a3 ~= a2;
  reflexivity;
::  for a1 being non empty non void OverloadedMSSign
::  for a2 being Element of the OperSymbols of a1 holds
::     a2 ~= a2;
end;

:: OSALG_1:dfs 2
definiens
  let a1 be non empty non void OverloadedMSSign;
  let a2, a3 be Element of the OperSymbols of a1;
To prove
     a2 ~= a3
it is sufficient to prove
  thus [a2,a3] in the Overloading of a1;

:: OSALG_1:def 3
theorem
for b1 being non empty non void OverloadedMSSign
for b2, b3 being Element of the OperSymbols of b1 holds
   b2 ~= b3
iff
   [b2,b3] in the Overloading of b1;

:: OSALG_1:th 2
theorem
for b1 being non empty non void OverloadedMSSign
for b2, b3, b4 being Element of the OperSymbols of b1
      st b2 ~= b3 & b3 ~= b4
   holds b2 ~= b4;

:: OSALG_1:attrnot 5 => OSALG_1:attr 5
definition
  let a1 be non empty non void OverloadedMSSign;
  attr a1 is discernable means
    for b1, b2 being Element of the OperSymbols of a1
          st b1 ~= b2 & the_arity_of b1 = the_arity_of b2 & the_result_sort_of b1 = the_result_sort_of b2
       holds b1 = b2;
end;

:: OSALG_1:dfs 3
definiens
  let a1 be non empty non void OverloadedMSSign;
To prove
     a1 is discernable
it is sufficient to prove
  thus for b1, b2 being Element of the OperSymbols of a1
          st b1 ~= b2 & the_arity_of b1 = the_arity_of b2 & the_result_sort_of b1 = the_result_sort_of b2
       holds b1 = b2;

:: OSALG_1:def 4
theorem
for b1 being non empty non void OverloadedMSSign holds
      b1 is discernable
   iff
      for b2, b3 being Element of the OperSymbols of b1
            st b2 ~= b3 & the_arity_of b2 = the_arity_of b3 & the_result_sort_of b2 = the_result_sort_of b3
         holds b2 = b3;

:: OSALG_1:attrnot 6 => OSALG_1:attr 6
definition
  let a1 be non empty non void OverloadedMSSign;
  attr a1 is op-discrete means
    the Overloading of a1 = id the OperSymbols of a1;
end;

:: OSALG_1:dfs 4
definiens
  let a1 be non empty non void OverloadedMSSign;
To prove
     a1 is op-discrete
it is sufficient to prove
  thus the Overloading of a1 = id the OperSymbols of a1;

:: OSALG_1:def 5
theorem
for b1 being non empty non void OverloadedMSSign holds
      b1 is op-discrete
   iff
      the Overloading of b1 = id the OperSymbols of b1;

:: OSALG_1:th 3
theorem
for b1 being non empty non void OverloadedMSSign holds
      b1 is op-discrete
   iff
      for b2, b3 being Element of the OperSymbols of b1
            st b2 ~= b3
         holds b2 = b3;

:: OSALG_1:th 4
theorem
for b1 being non empty non void OverloadedMSSign
      st b1 is op-discrete
   holds b1 is discernable;

:: OSALG_1:funcnot 2 => OSALG_1:func 2
definition
  let a1 be non empty non void ManySortedSign;
  func OSSign A1 -> non empty non void strict order-sorted OverloadedRSSign means
    the carrier of a1 = the carrier of it & id the carrier of a1 = the InternalRel of it & the OperSymbols of a1 = the OperSymbols of it & id the OperSymbols of a1 = the Overloading of it & the Arity of a1 = the Arity of it & the ResultSort of a1 = the ResultSort of it;
end;

:: OSALG_1:def 6
theorem
for b1 being non empty non void ManySortedSign
for b2 being non empty non void strict order-sorted OverloadedRSSign holds
      b2 = OSSign b1
   iff
      the carrier of b1 = the carrier of b2 & id the carrier of b1 = the InternalRel of b2 & the OperSymbols of b1 = the OperSymbols of b2 & id the OperSymbols of b1 = the Overloading of b2 & the Arity of b1 = the Arity of b2 & the ResultSort of b1 = the ResultSort of b2;

:: OSALG_1:th 5
theorem
for b1 being non empty non void ManySortedSign holds
   OSSign b1 is discrete & OSSign b1 is op-discrete;

:: OSALG_1:exreg 6
registration
  cluster non empty non void reflexive transitive antisymmetric discrete strict order-sorted discernable op-discrete OverloadedRSSign;
end;

:: OSALG_1:condreg 2
registration
  cluster non empty non void op-discrete -> discernable (OverloadedRSSign);
end;

:: OSALG_1:funcreg 3
registration
  let a1 be non empty non void ManySortedSign;
  cluster OSSign a1 -> non empty non void discrete strict order-sorted op-discrete;
end;

:: OSALG_1:modenot 3
definition
  mode OrderSortedSign is non empty non void order-sorted discernable OverloadedRSSign;
end;

:: OSALG_1:prednot 2 => OSALG_1:pred 2
definition
  let a1 be non empty reflexive transitive antisymmetric RelStr;
  let a2, a3 be Element of (the carrier of a1) *;
  pred A2 <= A3 means
    len a2 = len a3 &
     (for b1 being set
        st b1 in dom a2
     for b2, b3 being Element of the carrier of a1
           st b2 = a2 . b1 & b3 = a3 . b1
        holds b2 <= b3);
  reflexivity;
::  for a1 being non empty reflexive transitive antisymmetric RelStr
::  for a2 being Element of (the carrier of a1) * holds
::     a2 <= a2;
end;

:: OSALG_1:dfs 6
definiens
  let a1 be non empty reflexive transitive antisymmetric RelStr;
  let a2, a3 be Element of (the carrier of a1) *;
To prove
     a2 <= a3
it is sufficient to prove
  thus len a2 = len a3 &
     (for b1 being set
        st b1 in dom a2
     for b2, b3 being Element of the carrier of a1
           st b2 = a2 . b1 & b3 = a3 . b1
        holds b2 <= b3);

:: OSALG_1:def 7
theorem
for b1 being non empty reflexive transitive antisymmetric RelStr
for b2, b3 being Element of (the carrier of b1) * holds
   b2 <= b3
iff
   len b2 = len b3 &
    (for b4 being set
       st b4 in dom b2
    for b5, b6 being Element of the carrier of b1
          st b5 = b2 . b4 & b6 = b3 . b4
       holds b5 <= b6);

:: OSALG_1:th 6
theorem
for b1 being non empty reflexive transitive antisymmetric RelStr
for b2, b3 being Element of (the carrier of b1) *
      st b2 <= b3 & b3 <= b2
   holds b2 = b3;

:: OSALG_1:th 7
theorem
for b1 being non empty reflexive transitive antisymmetric RelStr
for b2, b3 being Element of (the carrier of b1) *
      st b1 is discrete & b2 <= b3
   holds b2 = b3;

:: OSALG_1:th 8
theorem
for b1 being non empty non void order-sorted discernable OverloadedRSSign
for b2, b3 being Element of the OperSymbols of b1
      st b1 is discrete & b2 ~= b3 & the_arity_of b2 <= the_arity_of b3 & the_result_sort_of b2 <= the_result_sort_of b3
   holds b2 = b3;

:: OSALG_1:attrnot 7 => OSALG_1:attr 7
definition
  let a1 be non empty non void order-sorted discernable OverloadedRSSign;
  let a2 be Element of the OperSymbols of a1;
  attr a2 is monotone means
    for b1 being Element of the OperSymbols of a1
          st a2 ~= b1 & the_arity_of a2 <= the_arity_of b1
       holds the_result_sort_of a2 <= the_result_sort_of b1;
end;

:: OSALG_1:dfs 7
definiens
  let a1 be non empty non void order-sorted discernable OverloadedRSSign;
  let a2 be Element of the OperSymbols of a1;
To prove
     a2 is monotone
it is sufficient to prove
  thus for b1 being Element of the OperSymbols of a1
          st a2 ~= b1 & the_arity_of a2 <= the_arity_of b1
       holds the_result_sort_of a2 <= the_result_sort_of b1;

:: OSALG_1:def 8
theorem
for b1 being non empty non void order-sorted discernable OverloadedRSSign
for b2 being Element of the OperSymbols of b1 holds
      b2 is monotone(b1)
   iff
      for b3 being Element of the OperSymbols of b1
            st b2 ~= b3 & the_arity_of b2 <= the_arity_of b3
         holds the_result_sort_of b2 <= the_result_sort_of b3;

:: OSALG_1:attrnot 8 => OSALG_1:attr 8
definition
  let a1 be non empty non void order-sorted discernable OverloadedRSSign;
  attr a1 is monotone means
    for b1 being Element of the OperSymbols of a1 holds
       b1 is monotone(a1);
end;

:: OSALG_1:dfs 8
definiens
  let a1 be non empty non void order-sorted discernable OverloadedRSSign;
To prove
     a1 is monotone
it is sufficient to prove
  thus for b1 being Element of the OperSymbols of a1 holds
       b1 is monotone(a1);

:: OSALG_1:def 9
theorem
for b1 being non empty non void order-sorted discernable OverloadedRSSign holds
      b1 is monotone
   iff
      for b2 being Element of the OperSymbols of b1 holds
         b2 is monotone(b1);

:: OSALG_1:th 9
theorem
for b1 being non empty non void order-sorted discernable OverloadedRSSign
      st b1 is op-discrete
   holds b1 is monotone;

:: OSALG_1:exreg 7
registration
  cluster non empty non void reflexive transitive antisymmetric order-sorted discernable monotone OverloadedRSSign;
end;

:: OSALG_1:exreg 8
registration
  let a1 be non empty non void order-sorted discernable monotone OverloadedRSSign;
  cluster monotone Element of the OperSymbols of a1;
end;

:: OSALG_1:condreg 3
registration
  let a1 be non empty non void order-sorted discernable monotone OverloadedRSSign;
  cluster -> monotone (Element of the OperSymbols of a1);
end;

:: OSALG_1:condreg 4
registration
  cluster non empty non void order-sorted discernable op-discrete -> monotone (OverloadedRSSign);
end;

:: OSALG_1:th 10
theorem
for b1 being non empty non void order-sorted discernable OverloadedRSSign
for b2, b3 being Element of the OperSymbols of b1
      st b1 is monotone & the_arity_of b2 = {} & b2 ~= b3 & the_arity_of b3 = {}
   holds b2 = b3;

:: OSALG_1:prednot 3 => OSALG_1:pred 3
definition
  let a1 be non empty non void order-sorted discernable OverloadedRSSign;
  let a2, a3 be Element of the OperSymbols of a1;
  let a4 be Element of (the carrier of a1) *;
  pred A3 has_least_args_for A2,A4 means
    a2 ~= a3 &
     a4 <= the_arity_of a3 &
     (for b1 being Element of the OperSymbols of a1
           st a2 ~= b1 & a4 <= the_arity_of b1
        holds the_arity_of a3 <= the_arity_of b1);
end;

:: OSALG_1:dfs 9
definiens
  let a1 be non empty non void order-sorted discernable OverloadedRSSign;
  let a2, a3 be Element of the OperSymbols of a1;
  let a4 be Element of (the carrier of a1) *;
To prove
     a3 has_least_args_for a2,a4
it is sufficient to prove
  thus a2 ~= a3 &
     a4 <= the_arity_of a3 &
     (for b1 being Element of the OperSymbols of a1
           st a2 ~= b1 & a4 <= the_arity_of b1
        holds the_arity_of a3 <= the_arity_of b1);

:: OSALG_1:def 10
theorem
for b1 being non empty non void order-sorted discernable OverloadedRSSign
for b2, b3 being Element of the OperSymbols of b1
for b4 being Element of (the carrier of b1) * holds
      b3 has_least_args_for b2,b4
   iff
      b2 ~= b3 &
       b4 <= the_arity_of b3 &
       (for b5 being Element of the OperSymbols of b1
             st b2 ~= b5 & b4 <= the_arity_of b5
          holds the_arity_of b3 <= the_arity_of b5);

:: OSALG_1:prednot 4 => OSALG_1:pred 4
definition
  let a1 be non empty non void order-sorted discernable OverloadedRSSign;
  let a2, a3 be Element of the OperSymbols of a1;
  let a4 be Element of (the carrier of a1) *;
  pred A3 has_least_sort_for A2,A4 means
    a2 ~= a3 &
     a4 <= the_arity_of a3 &
     (for b1 being Element of the OperSymbols of a1
           st a2 ~= b1 & a4 <= the_arity_of b1
        holds the_result_sort_of a3 <= the_result_sort_of b1);
end;

:: OSALG_1:dfs 10
definiens
  let a1 be non empty non void order-sorted discernable OverloadedRSSign;
  let a2, a3 be Element of the OperSymbols of a1;
  let a4 be Element of (the carrier of a1) *;
To prove
     a3 has_least_sort_for a2,a4
it is sufficient to prove
  thus a2 ~= a3 &
     a4 <= the_arity_of a3 &
     (for b1 being Element of the OperSymbols of a1
           st a2 ~= b1 & a4 <= the_arity_of b1
        holds the_result_sort_of a3 <= the_result_sort_of b1);

:: OSALG_1:def 11
theorem
for b1 being non empty non void order-sorted discernable OverloadedRSSign
for b2, b3 being Element of the OperSymbols of b1
for b4 being Element of (the carrier of b1) * holds
      b3 has_least_sort_for b2,b4
   iff
      b2 ~= b3 &
       b4 <= the_arity_of b3 &
       (for b5 being Element of the OperSymbols of b1
             st b2 ~= b5 & b4 <= the_arity_of b5
          holds the_result_sort_of b3 <= the_result_sort_of b5);

:: OSALG_1:prednot 5 => OSALG_1:pred 5
definition
  let a1 be non empty non void order-sorted discernable OverloadedRSSign;
  let a2, a3 be Element of the OperSymbols of a1;
  let a4 be Element of (the carrier of a1) *;
  pred A3 has_least_rank_for A2,A4 means
    a3 has_least_args_for a2,a4 & a3 has_least_sort_for a2,a4;
end;

:: OSALG_1:dfs 11
definiens
  let a1 be non empty non void order-sorted discernable OverloadedRSSign;
  let a2, a3 be Element of the OperSymbols of a1;
  let a4 be Element of (the carrier of a1) *;
To prove
     a3 has_least_rank_for a2,a4
it is sufficient to prove
  thus a3 has_least_args_for a2,a4 & a3 has_least_sort_for a2,a4;

:: OSALG_1:def 12
theorem
for b1 being non empty non void order-sorted discernable OverloadedRSSign
for b2, b3 being Element of the OperSymbols of b1
for b4 being Element of (the carrier of b1) * holds
      b3 has_least_rank_for b2,b4
   iff
      b3 has_least_args_for b2,b4 & b3 has_least_sort_for b2,b4;

:: OSALG_1:attrnot 9 => OSALG_1:attr 9
definition
  let a1 be non empty non void order-sorted discernable OverloadedRSSign;
  let a2 be Element of the OperSymbols of a1;
  attr a2 is regular means
    a2 is monotone(a1) &
     (for b1 being Element of (the carrier of a1) *
           st b1 <= the_arity_of a2
        holds ex b2 being Element of the OperSymbols of a1 st
           b2 has_least_args_for a2,b1);
end;

:: OSALG_1:dfs 12
definiens
  let a1 be non empty non void order-sorted discernable OverloadedRSSign;
  let a2 be Element of the OperSymbols of a1;
To prove
     a2 is regular
it is sufficient to prove
  thus a2 is monotone(a1) &
     (for b1 being Element of (the carrier of a1) *
           st b1 <= the_arity_of a2
        holds ex b2 being Element of the OperSymbols of a1 st
           b2 has_least_args_for a2,b1);

:: OSALG_1:def 13
theorem
for b1 being non empty non void order-sorted discernable OverloadedRSSign
for b2 being Element of the OperSymbols of b1 holds
      b2 is regular(b1)
   iff
      b2 is monotone(b1) &
       (for b3 being Element of (the carrier of b1) *
             st b3 <= the_arity_of b2
          holds ex b4 being Element of the OperSymbols of b1 st
             b4 has_least_args_for b2,b3);

:: OSALG_1:attrnot 10 => OSALG_1:attr 10
definition
  let a1 be non empty non void order-sorted discernable monotone OverloadedRSSign;
  attr a1 is regular means
    for b1 being Element of the OperSymbols of a1 holds
       b1 is regular(a1);
end;

:: OSALG_1:dfs 13
definiens
  let a1 be non empty non void order-sorted discernable monotone OverloadedRSSign;
To prove
     a1 is regular
it is sufficient to prove
  thus for b1 being Element of the OperSymbols of a1 holds
       b1 is regular(a1);

:: OSALG_1:def 14
theorem
for b1 being non empty non void order-sorted discernable monotone OverloadedRSSign holds
      b1 is regular
   iff
      for b2 being Element of the OperSymbols of b1 holds
         b2 is regular(b1);

:: OSALG_1:th 11
theorem
for b1 being non empty non void order-sorted discernable monotone OverloadedRSSign holds
      b1 is regular
   iff
      for b2 being Element of the OperSymbols of b1
      for b3 being Element of (the carrier of b1) *
            st b3 <= the_arity_of b2
         holds ex b4 being Element of the OperSymbols of b1 st
            b4 has_least_rank_for b2,b3;

:: OSALG_1:th 12
theorem
for b1 being non empty non void order-sorted discernable monotone OverloadedRSSign
      st b1 is op-discrete
   holds b1 is regular;

:: OSALG_1:exreg 9
registration
  cluster non empty non void reflexive transitive antisymmetric order-sorted discernable monotone regular OverloadedRSSign;
end;

:: OSALG_1:condreg 5
registration
  cluster non empty non void order-sorted discernable op-discrete monotone -> regular (OverloadedRSSign);
end;

:: OSALG_1:condreg 6
registration
  let a1 be non empty non void order-sorted discernable monotone regular OverloadedRSSign;
  cluster -> regular (Element of the OperSymbols of a1);
end;

:: OSALG_1:th 13
theorem
for b1 being non empty non void order-sorted discernable monotone regular OverloadedRSSign
for b2, b3, b4 being Element of the OperSymbols of b1
for b5 being Element of (the carrier of b1) *
      st b5 <= the_arity_of b2 & b3 has_least_args_for b2,b5 & b4 has_least_args_for b2,b5
   holds b3 = b4;

:: OSALG_1:funcnot 3 => OSALG_1:func 3
definition
  let a1 be non empty non void order-sorted discernable monotone regular OverloadedRSSign;
  let a2 be Element of the OperSymbols of a1;
  let a3 be Element of (the carrier of a1) *;
  assume a3 <= the_arity_of a2;
  func LBound(A2,A3) -> Element of the OperSymbols of a1 means
    it has_least_args_for a2,a3;
end;

:: OSALG_1:def 15
theorem
for b1 being non empty non void order-sorted discernable monotone regular OverloadedRSSign
for b2 being Element of the OperSymbols of b1
for b3 being Element of (the carrier of b1) *
   st b3 <= the_arity_of b2
for b4 being Element of the OperSymbols of b1 holds
      b4 = LBound(b2,b3)
   iff
      b4 has_least_args_for b2,b3;

:: OSALG_1:th 14
theorem
for b1 being non empty non void order-sorted discernable monotone regular OverloadedRSSign
for b2 being Element of the OperSymbols of b1
for b3 being Element of (the carrier of b1) *
      st b3 <= the_arity_of b2
   holds LBound(b2,b3) has_least_rank_for b2,b3;

:: OSALG_1:funcnot 4 => OSALG_1:func 4
definition
  let a1 be non empty reflexive transitive antisymmetric RelStr;
  let a2 be non empty set;
  func ConstOSSet(A1,A2) -> ManySortedSet of the carrier of a1 equals
    (the carrier of a1) --> a2;
end;

:: OSALG_1:def 16
theorem
for b1 being non empty reflexive transitive antisymmetric RelStr
for b2 being non empty set holds
   ConstOSSet(b1,b2) = (the carrier of b1) --> b2;

:: OSALG_1:th 15
theorem
for b1 being non empty reflexive transitive antisymmetric RelStr
for b2 being non empty set holds
   ConstOSSet(b1,b2) is non-empty &
    (for b3, b4 being Element of the carrier of b1
          st b3 <= b4
       holds (ConstOSSet(b1,b2)) . b3 c= (ConstOSSet(b1,b2)) . b4);

:: OSALG_1:attrnot 11 => OSALG_1:attr 11
definition
  let a1 be non empty reflexive transitive antisymmetric RelStr;
  let a2 be ManySortedSet of the carrier of a1;
  attr a2 is order-sorted means
    for b1, b2 being Element of the carrier of a1
          st b1 <= b2
       holds a2 . b1 c= a2 . b2;
end;

:: OSALG_1:dfs 16
definiens
  let a1 be non empty reflexive transitive antisymmetric RelStr;
  let a2 be ManySortedSet of the carrier of a1;
To prove
     a2 is order-sorted
it is sufficient to prove
  thus for b1, b2 being Element of the carrier of a1
          st b1 <= b2
       holds a2 . b1 c= a2 . b2;

:: OSALG_1:def 18
theorem
for b1 being non empty reflexive transitive antisymmetric RelStr
for b2 being ManySortedSet of the carrier of b1 holds
      b2 is order-sorted(b1)
   iff
      for b3, b4 being Element of the carrier of b1
            st b3 <= b4
         holds b2 . b3 c= b2 . b4;

:: OSALG_1:th 16
theorem
for b1 being non empty reflexive transitive antisymmetric RelStr
for b2 being non empty set holds
   ConstOSSet(b1,b2) is order-sorted(b1);

:: OSALG_1:exreg 10
registration
  let a1 be non empty reflexive transitive antisymmetric RelStr;
  cluster Relation-like Function-like order-sorted ManySortedSet of the carrier of a1;
end;

:: OSALG_1:funcnot 5 => OSALG_1:func 5
definition
  let a1 be non empty reflexive transitive antisymmetric RelStr;
  let a2 be non empty set;
  redefine func ConstOSSet(a1,a2) -> order-sorted ManySortedSet of the carrier of a1;
end;

:: OSALG_1:modenot 4
definition
  let a1 be non empty reflexive transitive antisymmetric RelStr;
  mode OrderSortedSet of a1 is order-sorted ManySortedSet of the carrier of a1;
end;

:: OSALG_1:exreg 11
registration
  let a1 be non empty reflexive transitive antisymmetric RelStr;
  cluster Relation-like non-empty Function-like order-sorted ManySortedSet of the carrier of a1;
end;

:: OSALG_1:attrnot 12 => OSALG_1:attr 12
definition
  let a1 be non empty non void order-sorted discernable OverloadedRSSign;
  let a2 be MSAlgebra over a1;
  attr a2 is order-sorted means
    for b1, b2 being Element of the carrier of a1
          st b1 <= b2
       holds (the Sorts of a2) . b1 c= (the Sorts of a2) . b2;
end;

:: OSALG_1:dfs 17
definiens
  let a1 be non empty non void order-sorted discernable OverloadedRSSign;
  let a2 be MSAlgebra over a1;
To prove
     a2 is order-sorted
it is sufficient to prove
  thus for b1, b2 being Element of the carrier of a1
          st b1 <= b2
       holds (the Sorts of a2) . b1 c= (the Sorts of a2) . b2;

:: OSALG_1:def 19
theorem
for b1 being non empty non void order-sorted discernable OverloadedRSSign
for b2 being MSAlgebra over b1 holds
      b2 is order-sorted(b1)
   iff
      for b3, b4 being Element of the carrier of b1
            st b3 <= b4
         holds (the Sorts of b2) . b3 c= (the Sorts of b2) . b4;

:: OSALG_1:th 17
theorem
for b1 being non empty non void order-sorted discernable OverloadedRSSign
for b2 being MSAlgebra over b1 holds
      b2 is order-sorted(b1)
   iff
      the Sorts of b2 is order-sorted ManySortedSet of the carrier of b1;

:: OSALG_1:funcnot 6 => OSALG_1:func 6
definition
  let a1 be non empty non void order-sorted discernable OverloadedRSSign;
  let a2 be non empty set;
  let a3 be ManySortedFunction of (ConstOSSet(a1,a2)) # * the Arity of a1,(ConstOSSet(a1,a2)) * the ResultSort of a1;
  func ConstOSA(A1,A2,A3) -> strict non-empty MSAlgebra over a1 means
    the Sorts of it = ConstOSSet(a1,a2) & the Charact of it = a3;
end;

:: OSALG_1:def 20
theorem
for b1 being non empty non void order-sorted discernable OverloadedRSSign
for b2 being non empty set
for b3 being ManySortedFunction of (ConstOSSet(b1,b2)) # * the Arity of b1,(ConstOSSet(b1,b2)) * the ResultSort of b1
for b4 being strict non-empty MSAlgebra over b1 holds
      b4 = ConstOSA(b1,b2,b3)
   iff
      the Sorts of b4 = ConstOSSet(b1,b2) & the Charact of b4 = b3;

:: OSALG_1:th 18
theorem
for b1 being non empty non void order-sorted discernable OverloadedRSSign
for b2 being non empty set
for b3 being ManySortedFunction of (ConstOSSet(b1,b2)) # * the Arity of b1,(ConstOSSet(b1,b2)) * the ResultSort of b1 holds
   ConstOSA(b1,b2,b3) is order-sorted(b1);

:: OSALG_1:exreg 12
registration
  let a1 be non empty non void order-sorted discernable OverloadedRSSign;
  cluster strict non-empty order-sorted MSAlgebra over a1;
end;

:: OSALG_1:funcreg 4
registration
  let a1 be non empty non void order-sorted discernable OverloadedRSSign;
  let a2 be non empty set;
  let a3 be ManySortedFunction of (ConstOSSet(a1,a2)) # * the Arity of a1,(ConstOSSet(a1,a2)) * the ResultSort of a1;
  cluster ConstOSA(a1,a2,a3) -> strict non-empty order-sorted;
end;

:: OSALG_1:modenot 5
definition
  let a1 be non empty non void order-sorted discernable OverloadedRSSign;
  mode OSAlgebra of a1 is order-sorted MSAlgebra over a1;
end;

:: OSALG_1:th 19
theorem
for b1 being non empty non void discrete order-sorted discernable OverloadedRSSign
for b2 being MSAlgebra over b1 holds
   b2 is order-sorted(b1);

:: OSALG_1:condreg 7
registration
  let a1 be non empty non void discrete order-sorted discernable OverloadedRSSign;
  cluster -> order-sorted (MSAlgebra over a1);
end;

:: OSALG_1:th 20
theorem
for b1 being non empty non void order-sorted discernable OverloadedRSSign
for b2, b3 being Element of (the carrier of b1) *
for b4 being order-sorted MSAlgebra over b1
      st b2 <= b3
   holds (the Sorts of b4) # . b2 c= (the Sorts of b4) # . b3;

:: OSALG_1:funcnot 7 => OSALG_1:func 7
definition
  let a1 be non empty non void ManySortedSign;
  let a2 be MSAlgebra over a1;
  func OSAlg A2 -> strict order-sorted MSAlgebra over OSSign a1 means
    the Sorts of it = the Sorts of a2 & the Charact of it = the Charact of a2;
end;

:: OSALG_1:def 21
theorem
for b1 being non empty non void ManySortedSign
for b2 being MSAlgebra over b1
for b3 being strict order-sorted MSAlgebra over OSSign b1 holds
      b3 = OSAlg b2
   iff
      the Sorts of b3 = the Sorts of b2 & the Charact of b3 = the Charact of b2;

:: OSALG_1:th 21
theorem
for b1 being non empty non void order-sorted discernable OverloadedRSSign
for b2, b3, b4 being Element of (the carrier of b1) *
      st b2 <= b3 & b3 <= b4
   holds b2 <= b4;

:: OSALG_1:prednot 6 => OSALG_1:pred 6
definition
  let a1 be non empty non void order-sorted discernable OverloadedRSSign;
  let a2, a3 be Element of the OperSymbols of a1;
  pred A2 <= A3 means
    a2 ~= a3 & the_arity_of a2 <= the_arity_of a3 & the_result_sort_of a2 <= the_result_sort_of a3;
  reflexivity;
::  for a1 being non empty non void order-sorted discernable OverloadedRSSign
::  for a2 being Element of the OperSymbols of a1 holds
::     a2 <= a2;
end;

:: OSALG_1:dfs 20
definiens
  let a1 be non empty non void order-sorted discernable OverloadedRSSign;
  let a2, a3 be Element of the OperSymbols of a1;
To prove
     a2 <= a3
it is sufficient to prove
  thus a2 ~= a3 & the_arity_of a2 <= the_arity_of a3 & the_result_sort_of a2 <= the_result_sort_of a3;

:: OSALG_1:def 22
theorem
for b1 being non empty non void order-sorted discernable OverloadedRSSign
for b2, b3 being Element of the OperSymbols of b1 holds
   b2 <= b3
iff
   b2 ~= b3 & the_arity_of b2 <= the_arity_of b3 & the_result_sort_of b2 <= the_result_sort_of b3;

:: OSALG_1:th 22
theorem
for b1 being non empty non void order-sorted discernable OverloadedRSSign
for b2, b3 being Element of the OperSymbols of b1
      st b2 <= b3 & b3 <= b2
   holds b2 = b3;

:: OSALG_1:th 23
theorem
for b1 being non empty non void order-sorted discernable OverloadedRSSign
for b2, b3, b4 being Element of the OperSymbols of b1
      st b2 <= b3 & b3 <= b4
   holds b2 <= b4;

:: OSALG_1:th 24
theorem
for b1 being non empty non void order-sorted discernable OverloadedRSSign
for b2, b3 being Element of the OperSymbols of b1
for b4 being order-sorted MSAlgebra over b1
      st the_result_sort_of b2 <= the_result_sort_of b3
   holds Result(b2,b4) c= Result(b3,b4);

:: OSALG_1:th 25
theorem
for b1 being non empty non void order-sorted discernable OverloadedRSSign
for b2, b3 being Element of the OperSymbols of b1
for b4 being order-sorted MSAlgebra over b1
      st the_arity_of b2 <= the_arity_of b3
   holds Args(b2,b4) c= Args(b3,b4);

:: OSALG_1:th 26
theorem
for b1 being non empty non void order-sorted discernable OverloadedRSSign
for b2, b3 being Element of the OperSymbols of b1
for b4 being order-sorted MSAlgebra over b1
      st b2 <= b3
   holds Args(b2,b4) c= Args(b3,b4) & Result(b2,b4) c= Result(b3,b4);

:: OSALG_1:attrnot 13 => OSALG_1:attr 13
definition
  let a1 be non empty non void order-sorted discernable OverloadedRSSign;
  let a2 be order-sorted MSAlgebra over a1;
  attr a2 is monotone means
    for b1, b2 being Element of the OperSymbols of a1
          st b1 <= b2
       holds (Den(b2,a2)) | Args(b1,a2) = Den(b1,a2);
end;

:: OSALG_1:dfs 21
definiens
  let a1 be non empty non void order-sorted discernable OverloadedRSSign;
  let a2 be order-sorted MSAlgebra over a1;
To prove
     a2 is monotone
it is sufficient to prove
  thus for b1, b2 being Element of the OperSymbols of a1
          st b1 <= b2
       holds (Den(b2,a2)) | Args(b1,a2) = Den(b1,a2);

:: OSALG_1:def 23
theorem
for b1 being non empty non void order-sorted discernable OverloadedRSSign
for b2 being order-sorted MSAlgebra over b1 holds
      b2 is monotone(b1)
   iff
      for b3, b4 being Element of the OperSymbols of b1
            st b3 <= b4
         holds (Den(b4,b2)) | Args(b3,b2) = Den(b3,b2);

:: OSALG_1:th 27
theorem
for b1 being non empty non void order-sorted discernable OverloadedRSSign
for b2 being non-empty order-sorted MSAlgebra over b1 holds
      b2 is monotone(b1)
   iff
      for b3, b4 being Element of the OperSymbols of b1
            st b3 <= b4
         holds Den(b3,b2) c= Den(b4,b2);

:: OSALG_1:th 28
theorem
for b1 being non empty non void order-sorted discernable OverloadedRSSign
for b2 being order-sorted MSAlgebra over b1
      st (b1 is discrete or b1 is op-discrete)
   holds b2 is monotone(b1);

:: OSALG_1:funcnot 8 => OSALG_1:func 8
definition
  let a1 be non empty non void order-sorted discernable OverloadedRSSign;
  let a2 be non empty set;
  let a3 be Element of a2;
  func TrivialOSA(A1,A2,A3) -> strict order-sorted MSAlgebra over a1 means
    the Sorts of it = ConstOSSet(a1,a2) &
     (for b1 being Element of the OperSymbols of a1 holds
        Den(b1,it) = (Args(b1,it)) --> a3);
end;

:: OSALG_1:def 24
theorem
for b1 being non empty non void order-sorted discernable OverloadedRSSign
for b2 being non empty set
for b3 being Element of b2
for b4 being strict order-sorted MSAlgebra over b1 holds
      b4 = TrivialOSA(b1,b2,b3)
   iff
      the Sorts of b4 = ConstOSSet(b1,b2) &
       (for b5 being Element of the OperSymbols of b1 holds
          Den(b5,b4) = (Args(b5,b4)) --> b3);

:: OSALG_1:th 29
theorem
for b1 being non empty non void order-sorted discernable OverloadedRSSign
for b2 being non empty set
for b3 being Element of b2 holds
   TrivialOSA(b1,b2,b3) is non-empty(b1) & TrivialOSA(b1,b2,b3) is monotone(b1);

:: OSALG_1:exreg 13
registration
  let a1 be non empty non void order-sorted discernable OverloadedRSSign;
  cluster strict non-empty order-sorted monotone MSAlgebra over a1;
end;

:: OSALG_1:funcreg 5
registration
  let a1 be non empty non void order-sorted discernable OverloadedRSSign;
  let a2 be non empty set;
  let a3 be Element of a2;
  cluster TrivialOSA(a1,a2,a3) -> strict non-empty order-sorted monotone;
end;

:: OSALG_1:funcnot 9 => OSALG_1:func 9
definition
  let a1 be non empty non void order-sorted discernable OverloadedRSSign;
  func OperNames A1 -> non empty Element of bool bool the OperSymbols of a1 equals
    Class the Overloading of a1;
end;

:: OSALG_1:def 25
theorem
for b1 being non empty non void order-sorted discernable OverloadedRSSign holds
   OperNames b1 = Class the Overloading of b1;

:: OSALG_1:condreg 8
registration
  let a1 be non empty non void order-sorted discernable OverloadedRSSign;
  cluster -> non empty (Element of OperNames a1);
end;

:: OSALG_1:modenot 6
definition
  let a1 be non empty non void order-sorted discernable OverloadedRSSign;
  mode OperName of a1 is Element of OperNames a1;
end;

:: OSALG_1:funcnot 10 => OSALG_1:func 10
definition
  let a1 be non empty non void order-sorted discernable OverloadedRSSign;
  let a2 be Element of the OperSymbols of a1;
  func Name A2 -> Element of OperNames a1 equals
    Class(the Overloading of a1,a2);
end;

:: OSALG_1:def 26
theorem
for b1 being non empty non void order-sorted discernable OverloadedRSSign
for b2 being Element of the OperSymbols of b1 holds
   Name b2 = Class(the Overloading of b1,b2);

:: OSALG_1:th 30
theorem
for b1 being non empty non void order-sorted discernable OverloadedRSSign
for b2, b3 being Element of the OperSymbols of b1 holds
   b2 ~= b3
iff
   b3 in Class(the Overloading of b1,b2);

:: OSALG_1:th 31
theorem
for b1 being non empty non void order-sorted discernable OverloadedRSSign
for b2, b3 being Element of the OperSymbols of b1 holds
   b2 ~= b3
iff
   Name b2 = Name b3;

:: OSALG_1:th 32
theorem
for b1 being non empty non void order-sorted discernable OverloadedRSSign
for b2 being set holds
      b2 is Element of OperNames b1
   iff
      ex b3 being Element of the OperSymbols of b1 st
         b2 = Name b3;

:: OSALG_1:modenot 7 => OSALG_1:mode 1
definition
  let a1 be non empty non void order-sorted discernable OverloadedRSSign;
  let a2 be Element of OperNames a1;
  redefine mode Element of a2 -> Element of the OperSymbols of a1;
end;

:: OSALG_1:th 33
theorem
for b1 being non empty non void order-sorted discernable OverloadedRSSign
for b2 being Element of OperNames b1
for b3 being Element of the OperSymbols of b1 holds
      b3 is Element of b2
   iff
      Name b3 = b2;

:: OSALG_1:th 34
theorem
for b1 being non empty non void order-sorted discernable monotone regular OverloadedRSSign
for b2, b3 being Element of the OperSymbols of b1
for b4 being Element of (the carrier of b1) *
      st b2 ~= b3 & len the_arity_of b2 = len the_arity_of b3 & b4 <= the_arity_of b2 & b4 <= the_arity_of b3
   holds LBound(b2,b4) = LBound(b3,b4);

:: OSALG_1:funcnot 11 => OSALG_1:func 11
definition
  let a1 be non empty non void order-sorted discernable monotone regular OverloadedRSSign;
  let a2 be Element of OperNames a1;
  let a3 be Element of (the carrier of a1) *;
  assume ex b1 being Element of a2 st
       a3 <= the_arity_of b1;
  func LBound(A2,A3) -> Element of a2 means
    for b1 being Element of a2
          st a3 <= the_arity_of b1
       holds it = LBound(b1,a3);
end;

:: OSALG_1:def 27
theorem
for b1 being non empty non void order-sorted discernable monotone regular OverloadedRSSign
for b2 being Element of OperNames b1
for b3 being Element of (the carrier of b1) *
   st ex b4 being Element of b2 st
        b3 <= the_arity_of b4
for b4 being Element of b2 holds
      b4 = LBound(b2,b3)
   iff
      for b5 being Element of b2
            st b3 <= the_arity_of b5
         holds b4 = LBound(b5,b3);

:: OSALG_1:th 35
theorem
for b1 being non empty non void order-sorted discernable monotone regular OverloadedRSSign
for b2 being Element of the OperSymbols of b1
for b3 being Element of (the carrier of b1) *
      st b3 <= the_arity_of b2
   holds LBound(b2,b3) <= b2;