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(ManySortedSign, RelStr) 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(OverloadedMSSign, RelSortedSign) 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;