Article NAT_LAT, MML version 4.99.1005

:: NAT_LAT:funcnot 1 => NAT_LAT:func 1
definition
  func hcflat -> Function-like quasi_total Relation of [:NAT,NAT:],NAT means
    for b1, b2 being natural set holds
    it .(b1,b2) = b1 hcf b2;
end;

:: NAT_LAT:def 3
theorem
for b1 being Function-like quasi_total Relation of [:NAT,NAT:],NAT holds
      b1 = hcflat
   iff
      for b2, b3 being natural set holds
      b1 .(b2,b3) = b2 hcf b3;

:: NAT_LAT:funcnot 2 => NAT_LAT:func 2
definition
  func lcmlat -> Function-like quasi_total Relation of [:NAT,NAT:],NAT means
    for b1, b2 being natural set holds
    it .(b1,b2) = b1 lcm b2;
end;

:: NAT_LAT:def 4
theorem
for b1 being Function-like quasi_total Relation of [:NAT,NAT:],NAT holds
      b1 = lcmlat
   iff
      for b2, b3 being natural set holds
      b1 .(b2,b3) = b2 lcm b3;

:: NAT_LAT:funcnot 3 => NAT_LAT:func 3
definition
  func Nat_Lattice -> non empty strict LattStr equals
    LattStr(#NAT,lcmlat,hcflat#);
end;

:: NAT_LAT:def 5
theorem
Nat_Lattice = LattStr(#NAT,lcmlat,hcflat#);

:: NAT_LAT:condreg 1
registration
  cluster -> natural (Element of the carrier of Nat_Lattice);
end;

:: NAT_LAT:th 48
theorem
for b1, b2 being Element of the carrier of Nat_Lattice holds
b1 "\/" b2 = b1 lcm b2;

:: NAT_LAT:th 49
theorem
for b1, b2 being Element of the carrier of Nat_Lattice holds
b1 "/\" b2 = b1 hcf b2;

:: NAT_LAT:th 52
theorem
for b1, b2 being Element of the carrier of Nat_Lattice
      st b1 [= b2
   holds b1 divides b2;

:: NAT_LAT:funcnot 4 => NAT_LAT:func 4
definition
  func 0_NN -> Element of the carrier of Nat_Lattice equals
    1;
end;

:: NAT_LAT:def 6
theorem
0_NN = 1;

:: NAT_LAT:funcnot 5 => NAT_LAT:func 5
definition
  func 1_NN -> Element of the carrier of Nat_Lattice equals
    0;
end;

:: NAT_LAT:def 7
theorem
1_NN = 0;

:: NAT_LAT:th 55
theorem
0_NN = 1;

:: NAT_LAT:funcreg 1
registration
  cluster Nat_Lattice -> non empty strict Lattice-like;
end;

:: NAT_LAT:funcreg 2
registration
  cluster Nat_Lattice -> non empty strict;
end;

:: NAT_LAT:funcreg 3
registration
  cluster Nat_Lattice -> non empty strict lower-bounded;
end;

:: NAT_LAT:th 61
theorem
for b1, b2 being Element of the carrier of Nat_Lattice holds
lcmlat .(b1,b2) = lcmlat .(b2,b1);

:: NAT_LAT:th 62
theorem
for b1, b2 being Element of the carrier of Nat_Lattice holds
hcflat .(b1,b2) = hcflat .(b2,b1);

:: NAT_LAT:th 63
theorem
for b1, b2, b3 being Element of the carrier of Nat_Lattice holds
lcmlat .(b1,lcmlat .(b2,b3)) = lcmlat .(lcmlat .(b1,b2),b3);

:: NAT_LAT:th 64
theorem
for b1, b2, b3 being Element of the carrier of Nat_Lattice holds
lcmlat .(b1,lcmlat .(b2,b3)) = lcmlat .(lcmlat .(b2,b1),b3) &
 lcmlat .(b1,lcmlat .(b2,b3)) = lcmlat .(lcmlat .(b1,b3),b2) &
 lcmlat .(b1,lcmlat .(b2,b3)) = lcmlat .(lcmlat .(b3,b2),b1) &
 lcmlat .(b1,lcmlat .(b2,b3)) = lcmlat .(lcmlat .(b3,b1),b2);

:: NAT_LAT:th 65
theorem
for b1, b2, b3 being Element of the carrier of Nat_Lattice holds
hcflat .(b1,hcflat .(b2,b3)) = hcflat .(hcflat .(b1,b2),b3);

:: NAT_LAT:th 66
theorem
for b1, b2, b3 being Element of the carrier of Nat_Lattice holds
hcflat .(b1,hcflat .(b2,b3)) = hcflat .(hcflat .(b2,b1),b3) &
 hcflat .(b1,hcflat .(b2,b3)) = hcflat .(hcflat .(b1,b3),b2) &
 hcflat .(b1,hcflat .(b2,b3)) = hcflat .(hcflat .(b3,b2),b1) &
 hcflat .(b1,hcflat .(b2,b3)) = hcflat .(hcflat .(b3,b1),b2);

:: NAT_LAT:th 67
theorem
for b1, b2 being Element of the carrier of Nat_Lattice holds
hcflat .(b1,lcmlat .(b1,b2)) = b1 & hcflat .(lcmlat .(b2,b1),b1) = b1 & hcflat .(b1,lcmlat .(b2,b1)) = b1 & hcflat .(lcmlat .(b1,b2),b1) = b1;

:: NAT_LAT:th 68
theorem
for b1, b2 being Element of the carrier of Nat_Lattice holds
lcmlat .(b1,hcflat .(b1,b2)) = b1 & lcmlat .(hcflat .(b2,b1),b1) = b1 & lcmlat .(b1,hcflat .(b2,b1)) = b1 & lcmlat .(hcflat .(b1,b2),b1) = b1;

:: NAT_LAT:funcnot 6 => NAT_LAT:func 6
definition
  func NATPLUS -> Element of bool NAT means
    for b1 being natural set holds
          b1 in it
       iff
          0 < b1;
end;

:: NAT_LAT:def 9
theorem
for b1 being Element of bool NAT holds
      b1 = NATPLUS
   iff
      for b2 being natural set holds
            b2 in b1
         iff
            0 < b2;

:: NAT_LAT:funcreg 4
registration
  cluster NATPLUS -> non empty;
end;

:: NAT_LAT:modenot 1 => NAT_LAT:mode 1
definition
  let a1 be non empty set;
  let a2 be non empty Element of bool a1;
  let a3 be non empty Element of bool a2;
  redefine mode Element of a3 -> Element of a2;
end;

:: NAT_LAT:condreg 2
registration
  let a1 be Element of bool REAL;
  cluster -> real (Element of a1);
end;

:: NAT_LAT:condreg 3
registration
  let a1 be Element of bool NAT;
  cluster -> real (Element of a1);
end;

:: NAT_LAT:modenot 2
definition
  mode NatPlus is Element of NATPLUS;
end;

:: NAT_LAT:funcnot 7 => NAT_LAT:func 7
definition
  let a1 be natural set;
  assume 0 < a1;
  func @ A1 -> Element of NATPLUS equals
    a1;
end;

:: NAT_LAT:def 10
theorem
for b1 being natural set
      st 0 < b1
   holds @ b1 = b1;

:: NAT_LAT:funcnot 8 => NAT_LAT:func 8
definition
  let a1 be Element of NATPLUS;
  func @ A1 -> Element of NATPLUS equals
    a1;
end;

:: NAT_LAT:def 11
theorem
for b1 being Element of NATPLUS holds
   @ b1 = b1;

:: NAT_LAT:condreg 4
registration
  cluster -> non empty natural (Element of NATPLUS);
end;

:: NAT_LAT:funcnot 9 => NAT_LAT:func 9
definition
  func hcflatplus -> Function-like quasi_total Relation of [:NATPLUS,NATPLUS:],NATPLUS means
    for b1, b2 being Element of NATPLUS holds
    it .(b1,b2) = b1 hcf b2;
end;

:: NAT_LAT:def 12
theorem
for b1 being Function-like quasi_total Relation of [:NATPLUS,NATPLUS:],NATPLUS holds
      b1 = hcflatplus
   iff
      for b2, b3 being Element of NATPLUS holds
      b1 .(b2,b3) = b2 hcf b3;

:: NAT_LAT:funcnot 10 => NAT_LAT:func 10
definition
  func lcmlatplus -> Function-like quasi_total Relation of [:NATPLUS,NATPLUS:],NATPLUS means
    for b1, b2 being Element of NATPLUS holds
    it .(b1,b2) = b1 lcm b2;
end;

:: NAT_LAT:def 13
theorem
for b1 being Function-like quasi_total Relation of [:NATPLUS,NATPLUS:],NATPLUS holds
      b1 = lcmlatplus
   iff
      for b2, b3 being Element of NATPLUS holds
      b1 .(b2,b3) = b2 lcm b3;

:: NAT_LAT:funcnot 11 => NAT_LAT:func 11
definition
  func NatPlus_Lattice -> strict LattStr equals
    LattStr(#NATPLUS,lcmlatplus,hcflatplus#);
end;

:: NAT_LAT:def 14
theorem
NatPlus_Lattice = LattStr(#NATPLUS,lcmlatplus,hcflatplus#);

:: NAT_LAT:funcreg 5
registration
  cluster NatPlus_Lattice -> non empty strict;
end;

:: NAT_LAT:funcnot 12 => NAT_LAT:func 12
definition
  let a1 be Element of the carrier of NatPlus_Lattice;
  func @ A1 -> Element of NATPLUS equals
    a1;
end;

:: NAT_LAT:def 15
theorem
for b1 being Element of the carrier of NatPlus_Lattice holds
   @ b1 = b1;

:: NAT_LAT:condreg 5
registration
  cluster -> non empty natural (Element of the carrier of NatPlus_Lattice);
end;

:: NAT_LAT:th 69
theorem
for b1, b2 being Element of the carrier of NatPlus_Lattice holds
b1 "\/" b2 = (@ b1) lcm @ b2;

:: NAT_LAT:th 70
theorem
for b1, b2 being Element of the carrier of NatPlus_Lattice holds
b1 "/\" b2 = (@ b1) hcf @ b2;

:: NAT_LAT:funcreg 6
registration
  cluster NatPlus_Lattice -> strict join-commutative join-associative meet-commutative meet-associative meet-absorbing join-absorbing;
end;

:: NAT_LAT:modenot 3 => NAT_LAT:mode 2
definition
  let a1 be non empty Lattice-like LattStr;
  mode SubLattice of A1 -> non empty Lattice-like LattStr means
    the carrier of it c= the carrier of a1 & the L_join of it = (the L_join of a1) || the carrier of it & the L_meet of it = (the L_meet of a1) || the carrier of it;
end;

:: NAT_LAT:dfs 13
definiens
  let a1, a2 be non empty Lattice-like LattStr;
To prove
     a2 is SubLattice of a1
it is sufficient to prove
  thus the carrier of a2 c= the carrier of a1 &
     the L_join of a2 = (the L_join of a1) || the carrier of a2 &
     the L_meet of a2 = (the L_meet of a1) || the carrier of a2;

:: NAT_LAT:def 16
theorem
for b1, b2 being non empty Lattice-like LattStr holds
   b2 is SubLattice of b1
iff
   the carrier of b2 c= the carrier of b1 &
    the L_join of b2 = (the L_join of b1) || the carrier of b2 &
    the L_meet of b2 = (the L_meet of b1) || the carrier of b2;

:: NAT_LAT:exreg 1
registration
  let a1 be non empty Lattice-like LattStr;
  cluster non empty strict join-commutative join-associative meet-commutative meet-associative meet-absorbing join-absorbing Lattice-like SubLattice of a1;
end;

:: NAT_LAT:th 75
theorem
for b1 being non empty Lattice-like LattStr holds
   b1 is SubLattice of b1;

:: NAT_LAT:th 76
theorem
NatPlus_Lattice is SubLattice of Nat_Lattice;