Article HEYTING3, MML version 4.99.1005

:: HEYTING3:exreg 1
registration
  cluster natural odd set;
end;

:: HEYTING3:exreg 2
registration
  cluster natural even set;
end;

:: HEYTING3:sch 1
scheme HEYTING3:sch 1
{F1 -> RelStr}:
for b1, b2 being Element of bool the carrier of F1()
      st (for b3 being set holds
               b3 in b1
            iff
               P1[b3]) &
         (for b3 being set holds
               b3 in b2
            iff
               P1[b3])
   holds b1 = b2


:: HEYTING3:funcreg 1
registration
  let a1, a2 be set;
  cluster [:a1,{a2}:] -> Function-like;
end;

:: HEYTING3:th 1
theorem
for b1 being natural odd set holds
   1 <= b1;

:: HEYTING3:th 3
theorem
for b1 being non empty finite Element of bool NAT holds
   ex b2 being Element of NAT st
      b1 c= (Seg b2) \/ {0};

:: HEYTING3:th 4
theorem
for b1 being finite Element of bool NAT holds
   ex b2 being odd Element of NAT st
      not b2 in b1;

:: HEYTING3:th 5
theorem
for b1 being Element of NAT
for b2 being non empty finite Element of bool [:NAT,{b1}:] holds
   ex b3 being non empty Element of NAT st
      b2 c= [:(Seg b3) \/ {0},{b1}:];

:: HEYTING3:th 6
theorem
for b1 being Element of NAT
for b2 being non empty finite Element of bool [:NAT,{b1}:] holds
   ex b3 being non empty Element of NAT st
      not [(2 * b3) + 1,b1] in b2;

:: HEYTING3:th 7
theorem
for b1 being Element of NAT
for b2 being finite Element of bool [:NAT,{b1}:] holds
   ex b3 being Element of NAT st
      for b4 being Element of NAT
            st b3 <= b4
         holds not [b4,b1] in b2;

:: HEYTING3:th 8
theorem
for b1 being non empty Lattice-like upper-bounded LattStr holds
   Top b1 = Top LattPOSet b1;

:: HEYTING3:th 9
theorem
for b1 being non empty Lattice-like lower-bounded LattStr holds
   Bottom b1 = Bottom LattPOSet b1;

:: HEYTING3:th 11
theorem
for b1 being set
for b2 being finite set
for b3, b4 being Element of Fin PFuncs(b1,b2)
      st b3 = {} & b4 <> {}
   holds b4 =>> b3 = {};

:: HEYTING3:th 12
theorem
for b1, b2, b3, b4 being set
      st b1 c= b2 & b3 c= b4
   holds SubstitutionSet(b1,b3) c= SubstitutionSet(b2,b4);

:: HEYTING3:th 13
theorem
for b1, b2, b3, b4 being set
for b5 being Element of Fin PFuncs(b1,b3)
for b6 being Element of Fin PFuncs(b2,b4)
      st b1 c= b2 & b3 c= b4 & b5 = b6
   holds mi b5 = mi b6;

:: HEYTING3:th 14
theorem
for b1, b2, b3, b4 being set
      st b1 c= b2 & b3 c= b4
   holds the L_join of SubstLatt(b1,b3) = (the L_join of SubstLatt(b2,b4)) || the carrier of SubstLatt(b1,b3);

:: HEYTING3:funcnot 1 => HEYTING3:func 1
definition
  let a1, a2 be set;
  func SubstPoset(A1,A2) -> RelStr equals
    LattPOSet SubstLatt(a1,a2);
end;

:: HEYTING3:def 1
theorem
for b1, b2 being set holds
SubstPoset(b1,b2) = LattPOSet SubstLatt(b1,b2);

:: HEYTING3:funcreg 2
registration
  let a1, a2 be set;
  cluster SubstPoset(a1,a2) -> with_suprema with_infima;
end;

:: HEYTING3:funcreg 3
registration
  let a1, a2 be set;
  cluster SubstPoset(a1,a2) -> reflexive transitive antisymmetric;
end;

:: HEYTING3:th 15
theorem
for b1, b2 being set
for b3, b4 being Element of the carrier of SubstPoset(b1,b2) holds
   b3 <= b4
iff
   for b5 being set
         st b5 in b3
      holds ex b6 being set st
         b6 in b4 & b6 c= b5;

:: HEYTING3:th 16
theorem
for b1, b2, b3, b4 being set
      st b1 c= b2 & b3 c= b4
   holds SubstPoset(b1,b3) is full SubRelStr of SubstPoset(b2,b4);

:: HEYTING3:funcnot 2 => HEYTING3:func 2
definition
  let a1, a2 be Element of NAT;
  func PFArt(A1,A2) -> Element of PFuncs(NAT,{a2}) means
    for b1 being set holds
          b1 in it
       iff
          (for b2 being odd Element of NAT
                st b2 <= 2 * a1
             holds [b2,a2] <> b1 implies [2 * a1,a2] = b1);
end;

:: HEYTING3:def 2
theorem
for b1, b2 being Element of NAT
for b3 being Element of PFuncs(NAT,{b2}) holds
      b3 = PFArt(b1,b2)
   iff
      for b4 being set holds
            b4 in b3
         iff
            (for b5 being odd Element of NAT
                  st b5 <= 2 * b1
               holds [b5,b2] <> b4 implies [2 * b1,b2] = b4);

:: HEYTING3:funcreg 4
registration
  let a1, a2 be Element of NAT;
  cluster PFArt(a1,a2) -> finite;
end;

:: HEYTING3:funcnot 3 => HEYTING3:func 3
definition
  let a1, a2 be Element of NAT;
  func PFCrt(A1,A2) -> Element of PFuncs(NAT,{a2}) means
    for b1 being set holds
          b1 in it
       iff
          ex b2 being odd Element of NAT st
             b2 <= (2 * a1) + 1 & [b2,a2] = b1;
end;

:: HEYTING3:def 3
theorem
for b1, b2 being Element of NAT
for b3 being Element of PFuncs(NAT,{b2}) holds
      b3 = PFCrt(b1,b2)
   iff
      for b4 being set holds
            b4 in b3
         iff
            ex b5 being odd Element of NAT st
               b5 <= (2 * b1) + 1 & [b5,b2] = b4;

:: HEYTING3:funcreg 5
registration
  let a1, a2 be Element of NAT;
  cluster PFCrt(a1,a2) -> finite;
end;

:: HEYTING3:th 17
theorem
for b1, b2 being Element of NAT holds
[(2 * b1) + 1,b2] in PFCrt(b1,b2);

:: HEYTING3:th 18
theorem
for b1, b2 being Element of NAT holds
PFCrt(b1,b2) misses {[(2 * b1) + 3,b2]};

:: HEYTING3:th 19
theorem
for b1, b2 being Element of NAT holds
PFCrt(b1 + 1,b2) = (PFCrt(b1,b2)) \/ {[(2 * b1) + 3,b2]};

:: HEYTING3:th 20
theorem
for b1, b2 being Element of NAT holds
PFCrt(b1,b2) c< PFCrt(b1 + 1,b2);

:: HEYTING3:funcreg 6
registration
  let a1, a2 be Element of NAT;
  cluster PFArt(a1,a2) -> non empty;
end;

:: HEYTING3:th 21
theorem
for b1, b2, b3 being Element of NAT holds
not PFArt(b1,b2) c= PFCrt(b3,b2);

:: HEYTING3:th 22
theorem
for b1, b2, b3 being Element of NAT
      st b1 <= b3
   holds PFCrt(b1,b2) c= PFCrt(b3,b2);

:: HEYTING3:th 23
theorem
for b1 being Element of NAT holds
   PFArt(1,b1) = {[1,b1],[2,b1]};

:: HEYTING3:funcnot 4 => HEYTING3:func 4
definition
  let a1, a2 be Element of NAT;
  func PFBrt(A1,A2) -> Element of Fin PFuncs(NAT,{a2}) means
    for b1 being set holds
          b1 in it
       iff
          (for b2 being non empty Element of NAT
                st b2 <= a1
             holds b1 <> PFArt(b2,a2) implies b1 = PFCrt(a1,a2));
end;

:: HEYTING3:def 4
theorem
for b1, b2 being Element of NAT
for b3 being Element of Fin PFuncs(NAT,{b2}) holds
      b3 = PFBrt(b1,b2)
   iff
      for b4 being set holds
            b4 in b3
         iff
            (for b5 being non empty Element of NAT
                  st b5 <= b1
               holds b4 <> PFArt(b5,b2) implies b4 = PFCrt(b1,b2));

:: HEYTING3:th 24
theorem
for b1, b2 being Element of NAT
for b3 being set
      st b3 in PFBrt(b1 + 1,b2)
   holds ex b4 being set st
      b4 in PFBrt(b1,b2) & b4 c= b3;

:: HEYTING3:th 25
theorem
for b1, b2 being Element of NAT holds
not PFCrt(b1,b2) in PFBrt(b1 + 1,b2);

:: HEYTING3:th 26
theorem
for b1, b2, b3 being Element of NAT
      st PFArt(b1,b2) c= PFArt(b3,b2)
   holds b1 = b3;

:: HEYTING3:th 27
theorem
for b1, b2, b3 being Element of NAT holds
   PFCrt(b1,b2) c= PFArt(b3,b2)
iff
   b1 < b3;

:: HEYTING3:th 28
theorem
for b1, b2 being Element of NAT holds
PFBrt(b1,b2) is Element of the carrier of SubstPoset(NAT,{b2});

:: HEYTING3:funcnot 5 => HEYTING3:func 5
definition
  let a1 be Element of NAT;
  func PFDrt A1 -> Element of bool the carrier of SubstPoset(NAT,{a1}) means
    for b1 being set holds
          b1 in it
       iff
          ex b2 being non empty Element of NAT st
             b1 = PFBrt(b2,a1);
end;

:: HEYTING3:def 5
theorem
for b1 being Element of NAT
for b2 being Element of bool the carrier of SubstPoset(NAT,{b1}) holds
      b2 = PFDrt b1
   iff
      for b3 being set holds
            b3 in b2
         iff
            ex b4 being non empty Element of NAT st
               b3 = PFBrt(b4,b1);

:: HEYTING3:th 29
theorem
for b1 being Element of NAT holds
   PFBrt(1,b1) = {PFArt(1,b1),PFCrt(1,b1)};

:: HEYTING3:th 30
theorem
for b1 being Element of NAT holds
   PFBrt(1,b1) <> {{}};

:: HEYTING3:funcreg 7
registration
  let a1 be Element of NAT;
  cluster PFBrt(1,a1) -> non empty;
end;

:: HEYTING3:th 31
theorem
for b1, b2 being Element of NAT holds
{PFArt(b1,b2)} is Element of the carrier of SubstPoset(NAT,{b2});

:: HEYTING3:th 32
theorem
for b1 being Element of NAT
for b2, b3 being set
for b4 being Element of the carrier of SubstPoset(b2,{b1})
      st b3 in b4
   holds b3 is finite Element of bool [:b2,{b1}:];

:: HEYTING3:th 33
theorem
for b1 being Element of NAT
for b2 being Element of the carrier of SubstPoset(NAT,{b1})
   st b2 is_<=_than PFDrt b1
for b3 being non empty set
      st b3 in b2
   holds ex b4 being Element of NAT st
      [b4,b1] in b3 & b4 is even;

:: HEYTING3:th 34
theorem
for b1 being Element of NAT
for b2, b3 being Element of the carrier of SubstPoset(NAT,{b1})
for b4 being Element of bool the carrier of SubstPoset(NAT,{b1})
      st b2 is_<=_than b4 & b3 is_<=_than b4
   holds b2 "\/" b3 is_<=_than b4;

:: HEYTING3:exreg 3
registration
  let a1 be Element of NAT;
  cluster non empty Element of the carrier of SubstPoset(NAT,{a1});
end;

:: HEYTING3:th 35
theorem
for b1 being Element of NAT
for b2 being Element of the carrier of SubstPoset(NAT,{b1})
      st {} in b2
   holds b2 = {{}};

:: HEYTING3:th 36
theorem
for b1 being Element of NAT
for b2 being non empty Element of the carrier of SubstPoset(NAT,{b1})
      st b2 <> {{}}
   holds ex b3 being Relation-like Function-like finite set st
      b3 in b2 & b3 <> {};

:: HEYTING3:th 37
theorem
for b1 being Element of NAT
for b2 being non empty Element of the carrier of SubstPoset(NAT,{b1})
for b3 being Element of Fin PFuncs(NAT,{b1})
      st b2 <> {{}} & b2 = b3
   holds Involved b3 is non empty finite Element of bool NAT;

:: HEYTING3:th 38
theorem
for b1 being Element of NAT
for b2 being Element of the carrier of SubstPoset(NAT,{b1})
for b3 being Element of Fin PFuncs(NAT,{b1})
for b4 being non empty finite Element of bool NAT
   st b4 = Involved b3 & b3 = b2
for b5 being set
   st b5 in b2
for b6 being Element of NAT
      st (max b4) + 1 < b6
   holds not [b6,b1] in b5;

:: HEYTING3:th 39
theorem
for b1 being Element of NAT holds
   Top SubstPoset(NAT,{b1}) = {{}};

:: HEYTING3:th 40
theorem
for b1 being Element of NAT holds
   Bottom SubstPoset(NAT,{b1}) = {};

:: HEYTING3:th 41
theorem
for b1 being Element of NAT
for b2, b3 being Element of the carrier of SubstPoset(NAT,{b1})
      st b2 <= b3 & b2 = {{}}
   holds b3 = {{}};

:: HEYTING3:th 42
theorem
for b1 being Element of NAT
for b2, b3 being Element of the carrier of SubstPoset(NAT,{b1})
      st b2 <= b3 & b3 = {}
   holds b2 = {};

:: HEYTING3:th 43
theorem
for b1 being Element of NAT
for b2 being Element of the carrier of SubstPoset(NAT,{b1})
      st b2 is_<=_than PFDrt b1
   holds b2 <> {{}};

:: HEYTING3:funcreg 8
registration
  let a1 be Element of NAT;
  cluster SubstPoset(NAT,{a1}) -> non complete;
end;

:: HEYTING3:funcreg 9
registration
  let a1 be Element of NAT;
  cluster SubstLatt(NAT,{a1}) -> strict non complete;
end;