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(ZeroStrOneStr) 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;