Article STRUCT_0, MML version 4.99.1005
:: STRUCT_0:structnot 1 => STRUCT_0:struct 1
definition
struct() 1-sorted(#
carrier -> set
#);
end;
:: STRUCT_0:attrnot 1 => STRUCT_0:attr 1
definition
let a1 be 1-sorted;
attr a1 is strict;
end;
:: STRUCT_0:exreg 1
registration
cluster strict 1-sorted;
end;
:: STRUCT_0:aggrnot 1 => STRUCT_0:aggr 1
definition
let a1 be set;
aggr 1-sorted(#a1#) -> strict 1-sorted;
end;
:: STRUCT_0:selnot 1 => STRUCT_0:sel 1
definition
let a1 be 1-sorted;
sel the carrier of a1 -> set;
end;
:: STRUCT_0:attrnot 2 => STRUCT_0:attr 2
definition
let a1 be 1-sorted;
attr a1 is empty means
the carrier of a1 is empty;
end;
:: STRUCT_0:dfs 1
definiens
let a1 be 1-sorted;
To prove
a1 is empty
it is sufficient to prove
thus the carrier of a1 is empty;
:: STRUCT_0:def 1
theorem
for b1 being 1-sorted holds
b1 is empty
iff
the carrier of b1 is empty;
:: STRUCT_0:exreg 2
registration
cluster empty 1-sorted;
end;
:: STRUCT_0:exreg 3
registration
cluster non empty 1-sorted;
end;
:: STRUCT_0:funcreg 1
registration
let a1 be empty 1-sorted;
cluster the carrier of a1 -> empty;
end;
:: STRUCT_0:funcreg 2
registration
let a1 be non empty 1-sorted;
cluster the carrier of a1 -> non empty;
end;
:: STRUCT_0:modenot 1
definition
let a1 be 1-sorted;
mode Element of a1 is Element of the carrier of a1;
end;
:: STRUCT_0:modenot 2
definition
let a1 be 1-sorted;
mode Subset of a1 is Element of bool the carrier of a1;
end;
:: STRUCT_0:modenot 3
definition
let a1 be 1-sorted;
mode Subset-Family of a1 is Element of bool bool the carrier of a1;
end;
:: STRUCT_0:exreg 4
registration
let a1 be non empty 1-sorted;
cluster non empty Element of bool the carrier of a1;
end;
:: STRUCT_0:modenot 4
definition
let a1 be 1-sorted;
let a2 be set;
mode Function of a1,a2 is Function-like quasi_total Relation of the carrier of a1,a2;
end;
:: STRUCT_0:modenot 5
definition
let a1 be 1-sorted;
let a2 be set;
mode Function of a2,a1 is Function-like quasi_total Relation of a2,the carrier of a1;
end;
:: STRUCT_0:modenot 6
definition
let a1, a2 be 1-sorted;
mode Function of a1,a2 is Function-like quasi_total Relation of the carrier of a1,the carrier of a2;
end;
:: STRUCT_0:funcnot 1 => STRUCT_0:func 1
definition
let a1 be 1-sorted;
func {} A1 -> Element of bool the carrier of a1 equals
{};
end;
:: STRUCT_0:def 2
theorem
for b1 being 1-sorted holds
{} b1 = {};
:: STRUCT_0:funcnot 2 => STRUCT_0:func 2
definition
let a1 be 1-sorted;
func [#] A1 -> Element of bool the carrier of a1 equals
the carrier of a1;
end;
:: STRUCT_0:def 3
theorem
for b1 being 1-sorted holds
[#] b1 = the carrier of b1;
:: STRUCT_0:funcreg 3
registration
let a1 be 1-sorted;
cluster {} a1 -> empty;
end;
:: STRUCT_0:funcreg 4
registration
let a1 be empty 1-sorted;
cluster [#] a1 -> empty;
end;
:: STRUCT_0:funcreg 5
registration
let a1 be non empty 1-sorted;
cluster [#] a1 -> non empty;
end;
:: STRUCT_0:modenot 7
definition
let a1 be 1-sorted;
mode FinSequence of a1 is FinSequence of the carrier of a1;
end;
:: STRUCT_0:modenot 8
definition
let a1 be 1-sorted;
mode ManySortedSet of a1 is ManySortedSet of the carrier of a1;
end;
:: STRUCT_0:funcnot 3 => STRUCT_0:func 3
definition
let a1 be 1-sorted;
func id A1 -> Function-like quasi_total Relation of the carrier of a1,the carrier of a1 equals
id the carrier of a1;
end;
:: STRUCT_0:def 4
theorem
for b1 being 1-sorted holds
id b1 = id the carrier of b1;
:: STRUCT_0:modenot 9
definition
let a1 be 1-sorted;
mode sequence of a1 is Function-like quasi_total Relation of NAT,the carrier of a1;
end;
:: STRUCT_0:modenot 10
definition
let a1, a2 be 1-sorted;
mode PartFunc of a1,a2 is Function-like Relation of the carrier of a1,the carrier of a2;
end;
:: STRUCT_0:prednot 1 => STRUCT_0:pred 1
definition
let a1 be 1-sorted;
let a2 be set;
pred A2 in A1 means
a2 in the carrier of a1;
end;
:: STRUCT_0:dfs 5
definiens
let a1 be 1-sorted;
let a2 be set;
To prove
a2 in a1
it is sufficient to prove
thus a2 in the carrier of a1;
:: STRUCT_0:def 5
theorem
for b1 being 1-sorted
for b2 being set holds
b2 in b1
iff
b2 in the carrier of b1;
:: STRUCT_0:structnot 2 => STRUCT_0:struct 2
definition
struct(1-sorted) ZeroStr(#
carrier -> set,
ZeroF -> Element of the carrier of it
#);
end;
:: STRUCT_0:attrnot 3 => STRUCT_0:attr 3
definition
let a1 be ZeroStr;
attr a1 is strict;
end;
:: STRUCT_0:exreg 5
registration
cluster strict ZeroStr;
end;
:: STRUCT_0:aggrnot 2 => STRUCT_0:aggr 2
definition
let a1 be set;
let a2 be Element of a1;
aggr ZeroStr(#a1,a2#) -> strict ZeroStr;
end;
:: STRUCT_0:selnot 2 => STRUCT_0:sel 2
definition
let a1 be ZeroStr;
sel the ZeroF of a1 -> Element of the carrier of a1;
end;
:: STRUCT_0:exreg 6
registration
cluster non empty ZeroStr;
end;
:: STRUCT_0:structnot 3 => STRUCT_0:struct 3
definition
struct(1-sorted) OneStr(#
carrier -> set,
OneF -> Element of the carrier of it
#);
end;
:: STRUCT_0:attrnot 4 => STRUCT_0:attr 4
definition
let a1 be OneStr;
attr a1 is strict;
end;
:: STRUCT_0:exreg 7
registration
cluster strict OneStr;
end;
:: STRUCT_0:aggrnot 3 => STRUCT_0:aggr 3
definition
let a1 be set;
let a2 be Element of a1;
aggr OneStr(#a1,a2#) -> strict OneStr;
end;
:: STRUCT_0:selnot 3 => STRUCT_0:sel 3
definition
let a1 be OneStr;
sel the OneF of a1 -> Element of the carrier of a1;
end;
:: STRUCT_0:structnot 4 => STRUCT_0:struct 4
definition
struct(ZeroStr, OneStr) ZeroOneStr(#
carrier -> set,
ZeroF -> Element of the carrier of it,
OneF -> Element of the carrier of it
#);
end;
:: STRUCT_0:attrnot 5 => STRUCT_0:attr 5
definition
let a1 be ZeroOneStr;
attr a1 is strict;
end;
:: STRUCT_0:exreg 8
registration
cluster strict ZeroOneStr;
end;
:: STRUCT_0:aggrnot 4 => STRUCT_0:aggr 4
definition
let a1 be set;
let a2, a3 be Element of a1;
aggr ZeroOneStr(#a1,a2,a3#) -> strict ZeroOneStr;
end;
:: STRUCT_0:funcnot 4 => STRUCT_0:func 4
definition
let a1 be ZeroStr;
func 0. A1 -> Element of the carrier of a1 equals
the ZeroF of a1;
end;
:: STRUCT_0:def 6
theorem
for b1 being ZeroStr holds
0. b1 = the ZeroF of b1;
:: STRUCT_0:funcnot 5 => STRUCT_0:func 5
definition
let a1 be OneStr;
func 1. A1 -> Element of the carrier of a1 equals
the OneF of a1;
end;
:: STRUCT_0:def 7
theorem
for b1 being OneStr holds
1. b1 = the OneF of b1;
:: STRUCT_0:attrnot 6 => STRUCT_0:attr 6
definition
let a1 be ZeroOneStr;
attr a1 is degenerated means
0. a1 = 1. a1;
end;
:: STRUCT_0:dfs 8
definiens
let a1 be ZeroOneStr;
To prove
a1 is degenerated
it is sufficient to prove
thus 0. a1 = 1. a1;
:: STRUCT_0:def 8
theorem
for b1 being ZeroOneStr holds
b1 is degenerated
iff
0. b1 = 1. b1;
:: STRUCT_0:attrnot 7 => STRUCT_0:attr 7
definition
let a1 be 1-sorted;
attr a1 is trivial means
the carrier of a1 is trivial;
end;
:: STRUCT_0:dfs 9
definiens
let a1 be 1-sorted;
To prove
a1 is trivial
it is sufficient to prove
thus the carrier of a1 is trivial;
:: STRUCT_0:def 9
theorem
for b1 being 1-sorted holds
b1 is trivial
iff
the carrier of b1 is trivial;
:: STRUCT_0:condreg 1
registration
cluster empty -> trivial (1-sorted);
end;
:: STRUCT_0:condreg 2
registration
cluster non trivial -> non empty (1-sorted);
end;
:: STRUCT_0:attrnot 8 => STRUCT_0:attr 7
definition
let a1 be 1-sorted;
attr a1 is trivial means
for b1, b2 being Element of the carrier of a1 holds
b1 = b2;
end;
:: STRUCT_0:dfs 10
definiens
let a1 be 1-sorted;
To prove
a1 is trivial
it is sufficient to prove
thus for b1, b2 being Element of the carrier of a1 holds
b1 = b2;
:: STRUCT_0:def 10
theorem
for b1 being 1-sorted holds
b1 is trivial
iff
for b2, b3 being Element of the carrier of b1 holds
b2 = b3;
:: STRUCT_0:condreg 3
registration
cluster non degenerated -> non trivial (ZeroOneStr);
end;
:: STRUCT_0:exreg 9
registration
cluster non empty trivial 1-sorted;
end;
:: STRUCT_0:exreg 10
registration
cluster non empty non trivial 1-sorted;
end;
:: STRUCT_0:funcreg 6
registration
let a1 be non trivial 1-sorted;
cluster the carrier of a1 -> non trivial;
end;
:: STRUCT_0:funcreg 7
registration
let a1 be trivial 1-sorted;
cluster the carrier of a1 -> trivial;
end;
:: STRUCT_0:attrnot 9 => STRUCT_0:attr 8
definition
let a1 be 1-sorted;
attr a1 is finite means
the carrier of a1 is finite;
end;
:: STRUCT_0:dfs 11
definiens
let a1 be 1-sorted;
To prove
a1 is finite
it is sufficient to prove
thus the carrier of a1 is finite;
:: STRUCT_0:def 11
theorem
for b1 being 1-sorted holds
b1 is finite
iff
the carrier of b1 is finite;
:: STRUCT_0:exreg 11
registration
cluster non empty finite 1-sorted;
end;
:: STRUCT_0:funcreg 8
registration
let a1 be finite 1-sorted;
cluster the carrier of a1 -> finite;
end;
:: STRUCT_0:condreg 4
registration
cluster empty -> finite (1-sorted);
end;
:: STRUCT_0:attrnot 10 => STRUCT_0:attr 8
notation
let a1 be 1-sorted;
antonym infinite for finite;
end;
:: STRUCT_0:exreg 12
registration
cluster infinite 1-sorted;
end;
:: STRUCT_0:funcreg 9
registration
let a1 be infinite 1-sorted;
cluster the carrier of a1 -> infinite;
end;
:: STRUCT_0:condreg 5
registration
cluster infinite -> non empty (1-sorted);
end;
:: STRUCT_0:condreg 6
registration
cluster trivial -> finite (1-sorted);
end;
:: STRUCT_0:condreg 7
registration
cluster infinite -> non trivial (1-sorted);
end;
:: STRUCT_0:attrnot 11 => STRUCT_0:attr 9
definition
let a1 be ZeroStr;
let a2 be Element of the carrier of a1;
attr a2 is zero means
a2 = 0. a1;
end;
:: STRUCT_0:dfs 12
definiens
let a1 be ZeroStr;
let a2 be Element of the carrier of a1;
To prove
a2 is zero
it is sufficient to prove
thus a2 = 0. a1;
:: STRUCT_0:def 12
theorem
for b1 being ZeroStr
for b2 being Element of the carrier of b1 holds
b2 is zero(b1)
iff
b2 = 0. b1;
:: STRUCT_0:funcreg 10
registration
let a1 be ZeroStr;
cluster 0. a1 -> zero;
end;
:: STRUCT_0:exreg 13
registration
cluster non degenerated ZeroOneStr;
end;
:: STRUCT_0:funcreg 11
registration
let a1 be non degenerated ZeroOneStr;
cluster 1. a1 -> non zero;
end;