Article MODAL_1, MML version 4.99.1005

:: MODAL_1:funcnot 1 => MODAL_1:func 1
definition
  let a1 be non empty Tree-like set;
  func Root A1 -> Element of a1 equals
    {};
end;

:: MODAL_1:def 1
theorem
for b1 being non empty Tree-like set holds
   Root b1 = {};

:: MODAL_1:funcnot 2 => MODAL_1:func 2
definition
  let a1 be non empty set;
  let a2 be Function-like DecoratedTree-like ParametrizedSubset of a1;
  func Root A2 -> Element of a1 equals
    a2 . Root proj1 a2;
end;

:: MODAL_1:def 2
theorem
for b1 being non empty set
for b2 being Function-like DecoratedTree-like ParametrizedSubset of b1 holds
   Root b2 = b2 . Root proj1 b2;

:: MODAL_1:th 3
theorem
for b1, b2 being Element of NAT
for b3 being FinSequence of NAT
      st b1 <> b2
   holds not <*b1*>,<*b2*> ^ b3 are_c=-comparable;

:: MODAL_1:th 4
theorem
for b1 being FinSequence of NAT
      st b1 <> {}
   holds ex b2 being FinSequence of NAT st
      ex b3 being natural set st
         b1 = <*b3*> ^ b2;

:: MODAL_1:th 5
theorem
for b1, b2 being Element of NAT
for b3 being FinSequence of NAT
      st b1 <> b2
   holds not <*b1*> c< <*b2*> ^ b3;

:: MODAL_1:th 6
theorem
for b1, b2 being Element of NAT
for b3 being FinSequence of NAT
      st b1 <> b2
   holds not <*b1*> c= <*b2*> ^ b3;

:: MODAL_1:th 7
theorem
for b1, b2 being Element of NAT holds
not <*b1*> c< <*b2*>;

:: MODAL_1:th 9
theorem
elementary_tree 1 = {{},<*0*>};

:: MODAL_1:th 10
theorem
elementary_tree 2 = {{},<*0*>,<*1*>};

:: MODAL_1:th 11
theorem
for b1 being non empty Tree-like set
for b2, b3 being Element of NAT
      st b2 <= b3 & <*b3*> in b1
   holds <*b2*> in b1;

:: MODAL_1:th 12
theorem
for b1, b2, b3 being FinSequence of NAT
      st b1 ^ b2 c< b1 ^ b3
   holds b2 c< b3;

:: MODAL_1:th 13
theorem
for b1 being Function-like DecoratedTree-like ParametrizedSubset of [:NAT,NAT:] holds
   b1 in PFuncs(NAT *,[:NAT,NAT:]);

:: MODAL_1:th 15
theorem
for b1, b2, b3 being non empty Tree-like set
for b4 being Element of b1
      st b1 with-replacement(b4,b2) = b1 with-replacement(b4,b3)
   holds b2 = b3;

:: MODAL_1:th 16
theorem
for b1 being non empty set
for b2, b3, b4 being Function-like DecoratedTree-like ParametrizedSubset of b1
for b5 being Element of proj1 b2
      st b2 with-replacement(b5,b3) = b2 with-replacement(b5,b4)
   holds b3 = b4;

:: MODAL_1:th 17
theorem
for b1, b2 being non empty Tree-like set
for b3 being FinSequence of NAT
   st b3 in b1
for b4 being Element of b1 with-replacement(b3,b2)
for b5 being Element of b1
      st b4 = b5 & b5 c< b3
   holds succ b4 = succ b5;

:: MODAL_1:th 18
theorem
for b1, b2 being non empty Tree-like set
for b3 being FinSequence of NAT
   st b3 in b1
for b4 being Element of b1 with-replacement(b3,b2)
for b5 being Element of b1
      st b4 = b5 & not b3,b5 are_c=-comparable
   holds succ b4 = succ b5;

:: MODAL_1:th 19
theorem
for b1, b2 being non empty Tree-like set
for b3 being FinSequence of NAT
   st b3 in b1
for b4 being Element of b1 with-replacement(b3,b2)
for b5 being Element of b2
      st b4 = b3 ^ b5
   holds succ b4,succ b5 are_equipotent;

:: MODAL_1:th 20
theorem
for b1 being non empty Tree-like set
for b2 being FinSequence of NAT
   st b2 in b1
for b3 being Element of b1
for b4 being Element of b1 | b2
      st b3 = b2 ^ b4
   holds succ b3,succ b4 are_equipotent;

:: MODAL_1:th 22
theorem
for b1 being non empty finite Tree-like set
      st branchdeg Root b1 = 0
   holds card b1 = 1 & b1 = {{}};

:: MODAL_1:th 23
theorem
for b1 being non empty finite Tree-like set
      st branchdeg Root b1 = 1
   holds succ Root b1 = {<*0*>};

:: MODAL_1:th 24
theorem
for b1 being non empty finite Tree-like set
      st branchdeg Root b1 = 2
   holds succ Root b1 = {<*0*>,<*1*>};

:: MODAL_1:th 25
theorem
for b1 being non empty Tree-like set
for b2 being Element of b1
      st b2 <> Root b1
   holds b1 | b2,{b2 ^ b3 where b3 is Element of NAT *: b2 ^ b3 in b1} are_equipotent &
    not Root b1 in {b2 ^ b3 where b3 is Element of NAT *: b2 ^ b3 in b1};

:: MODAL_1:th 26
theorem
for b1 being non empty finite Tree-like set
for b2 being Element of b1
      st b2 <> Root b1
   holds card (b1 | b2) < card b1;

:: MODAL_1:th 27
theorem
for b1 being non empty finite Tree-like set
for b2 being Element of b1
      st succ Root b1 = {b2}
   holds b1 = (elementary_tree 1) with-replacement(<*0*>,b1 | b2);

:: MODAL_1:th 28
theorem
for b1 being non empty set
for b2 being Function-like finite DecoratedTree-like ParametrizedSubset of b1
for b3 being Element of proj1 b2
      st succ Root proj1 b2 = {b3} &
         proj1 b2 is finite
   holds b2 = ((elementary_tree 1) --> Root b2) with-replacement(<*0*>,b2 | b3);

:: MODAL_1:th 29
theorem
for b1 being non empty Tree-like set
for b2, b3 being Element of b1
      st b1 is finite & b2 = <*0*> & b3 = <*1*> & succ Root b1 = {b2,b3}
   holds b1 = ((elementary_tree 2) with-replacement(<*0*>,b1 | b2)) with-replacement(<*1*>,b1 | b3);

:: MODAL_1:th 30
theorem
for b1 being non empty set
for b2 being Function-like DecoratedTree-like ParametrizedSubset of b1
for b3, b4 being Element of proj1 b2
      st proj1 b2 is finite &
         b3 = <*0*> &
         b4 = <*1*> &
         succ Root proj1 b2 = {b3,b4}
   holds b2 = (((elementary_tree 2) --> Root b2) with-replacement(<*0*>,b2 | b3)) with-replacement(<*1*>,b2 | b4);

:: MODAL_1:funcnot 3 => MODAL_1:func 3
definition
  func MP-variables -> set equals
    [:{3},NAT:];
end;

:: MODAL_1:def 3
theorem
MP-variables = [:{3},NAT:];

:: MODAL_1:funcreg 1
registration
  cluster MP-variables -> non empty;
end;

:: MODAL_1:modenot 1
definition
  mode MP-variable is Element of MP-variables;
end;

:: MODAL_1:funcnot 4 => MODAL_1:func 4
definition
  func MP-conectives -> set equals
    [:{0,1,2},NAT:];
end;

:: MODAL_1:def 4
theorem
MP-conectives = [:{0,1,2},NAT:];

:: MODAL_1:funcreg 2
registration
  cluster MP-conectives -> non empty;
end;

:: MODAL_1:modenot 2
definition
  mode MP-conective is Element of MP-conectives;
end;

:: MODAL_1:th 31
theorem
MP-conectives misses MP-variables;

:: MODAL_1:funcnot 5 => MODAL_1:func 5
definition
  let a1 be non empty finite Tree-like set;
  let a2 be Element of a1;
  redefine func branchdeg a2 -> Element of NAT;
end;

:: MODAL_1:modenot 3 => MODAL_1:mode 1
definition
  let a1 be non empty set;
  mode DOMAIN_DecoratedTree of A1 -> non empty set means
    for b1 being set
          st b1 in it
       holds b1 is Function-like DecoratedTree-like ParametrizedSubset of a1;
end;

:: MODAL_1:dfs 5
definiens
  let a1, a2 be non empty set;
To prove
     a2 is DOMAIN_DecoratedTree of a1
it is sufficient to prove
  thus for b1 being set
          st b1 in a2
       holds b1 is Function-like DecoratedTree-like ParametrizedSubset of a1;

:: MODAL_1:def 5
theorem
for b1, b2 being non empty set holds
   b2 is DOMAIN_DecoratedTree of b1
iff
   for b3 being set
         st b3 in b2
      holds b3 is Function-like DecoratedTree-like ParametrizedSubset of b1;

:: MODAL_1:modenot 4 => MODAL_1:mode 2
definition
  let a1 be non empty set;
  let a2 be DOMAIN_DecoratedTree of a1;
  redefine mode Element of a2 -> Function-like DecoratedTree-like ParametrizedSubset of a1;
end;

:: MODAL_1:funcnot 6 => MODAL_1:func 6
definition
  func MP-WFF -> DOMAIN_DecoratedTree of [:NAT,NAT:] means
    (for b1 being Function-like DecoratedTree-like ParametrizedSubset of [:NAT,NAT:]
           st b1 in it
        holds b1 is finite) &
     (for b1 being Function-like finite DecoratedTree-like ParametrizedSubset of [:NAT,NAT:] holds
           b1 in it
        iff
           for b2 being Element of proj1 b1 holds
              branchdeg b2 <= 2 &
               (branchdeg b2 = 0 &
                b1 . b2 <> [0,0] implies ex b3 being Element of NAT st
                  b1 . b2 = [3,b3]) &
               (branchdeg b2 = 1 & b1 . b2 <> [1,0] implies b1 . b2 = [1,1]) &
               (branchdeg b2 = 2 implies b1 . b2 = [2,0]));
end;

:: MODAL_1:def 6
theorem
for b1 being DOMAIN_DecoratedTree of [:NAT,NAT:] holds
      b1 = MP-WFF
   iff
      (for b2 being Function-like DecoratedTree-like ParametrizedSubset of [:NAT,NAT:]
             st b2 in b1
          holds b2 is finite) &
       (for b2 being Function-like finite DecoratedTree-like ParametrizedSubset of [:NAT,NAT:] holds
             b2 in b1
          iff
             for b3 being Element of proj1 b2 holds
                branchdeg b3 <= 2 &
                 (branchdeg b3 = 0 &
                  b2 . b3 <> [0,0] implies ex b4 being Element of NAT st
                    b2 . b3 = [3,b4]) &
                 (branchdeg b3 = 1 & b2 . b3 <> [1,0] implies b2 . b3 = [1,1]) &
                 (branchdeg b3 = 2 implies b2 . b3 = [2,0]));

:: MODAL_1:modenot 5
definition
  mode MP-wff is Element of MP-WFF;
end;

:: MODAL_1:condreg 1
registration
  cluster -> finite (Element of MP-WFF);
end;

:: MODAL_1:funcnot 7 => MODAL_1:func 7
definition
  let a1 be Element of MP-WFF;
  let a2 be Element of proj1 a1;
  redefine func a1 | a2 -> Element of MP-WFF;
end;

:: MODAL_1:funcnot 8 => MODAL_1:func 8
definition
  let a1 be Element of MP-conectives;
  func the_arity_of A1 -> Element of NAT equals
    a1 `1;
end;

:: MODAL_1:def 7
theorem
for b1 being Element of MP-conectives holds
   the_arity_of b1 = b1 `1;

:: MODAL_1:funcnot 9 => MODAL_1:func 9
definition
  let a1 be non empty set;
  let a2, a3 be Function-like DecoratedTree-like ParametrizedSubset of a1;
  let a4 be FinSequence of NAT;
  assume a4 in proj1 a2;
  func @(A2,A4,A3) -> Function-like DecoratedTree-like ParametrizedSubset of a1 equals
    a2 with-replacement(a4,a3);
end;

:: MODAL_1:def 8
theorem
for b1 being non empty set
for b2, b3 being Function-like DecoratedTree-like ParametrizedSubset of b1
for b4 being FinSequence of NAT
      st b4 in proj1 b2
   holds @(b2,b4,b3) = b2 with-replacement(b4,b3);

:: MODAL_1:th 32
theorem
for b1 being Element of MP-WFF holds
   ((elementary_tree 1) --> [1,0]) with-replacement(<*0*>,b1) is Element of MP-WFF;

:: MODAL_1:th 33
theorem
for b1 being Element of MP-WFF holds
   ((elementary_tree 1) --> [1,1]) with-replacement(<*0*>,b1) is Element of MP-WFF;

:: MODAL_1:th 34
theorem
for b1, b2 being Element of MP-WFF holds
(((elementary_tree 2) --> [2,0]) with-replacement(<*0*>,b1)) with-replacement(<*1*>,b2) is Element of MP-WFF;

:: MODAL_1:funcnot 10 => MODAL_1:func 10
definition
  let a1 be Element of MP-WFF;
  func 'not' A1 -> Element of MP-WFF equals
    ((elementary_tree 1) --> [1,0]) with-replacement(<*0*>,a1);
end;

:: MODAL_1:def 9
theorem
for b1 being Element of MP-WFF holds
   'not' b1 = ((elementary_tree 1) --> [1,0]) with-replacement(<*0*>,b1);

:: MODAL_1:funcnot 11 => MODAL_1:func 11
definition
  let a1 be Element of MP-WFF;
  func (#) A1 -> Element of MP-WFF equals
    ((elementary_tree 1) --> [1,1]) with-replacement(<*0*>,a1);
end;

:: MODAL_1:def 10
theorem
for b1 being Element of MP-WFF holds
   (#) b1 = ((elementary_tree 1) --> [1,1]) with-replacement(<*0*>,b1);

:: MODAL_1:funcnot 12 => MODAL_1:func 12
definition
  let a1, a2 be Element of MP-WFF;
  func A1 '&' A2 -> Element of MP-WFF equals
    (((elementary_tree 2) --> [2,0]) with-replacement(<*0*>,a1)) with-replacement(<*1*>,a2);
end;

:: MODAL_1:def 11
theorem
for b1, b2 being Element of MP-WFF holds
b1 '&' b2 = (((elementary_tree 2) --> [2,0]) with-replacement(<*0*>,b1)) with-replacement(<*1*>,b2);

:: MODAL_1:funcnot 13 => MODAL_1:func 13
definition
  let a1 be Element of MP-WFF;
  func ? A1 -> Element of MP-WFF equals
    'not' (#) 'not' a1;
end;

:: MODAL_1:def 12
theorem
for b1 being Element of MP-WFF holds
   ? b1 = 'not' (#) 'not' b1;

:: MODAL_1:funcnot 14 => MODAL_1:func 14
definition
  let a1, a2 be Element of MP-WFF;
  func A1 'or' A2 -> Element of MP-WFF equals
    'not' (('not' a1) '&' 'not' a2);
end;

:: MODAL_1:def 13
theorem
for b1, b2 being Element of MP-WFF holds
b1 'or' b2 = 'not' (('not' b1) '&' 'not' b2);

:: MODAL_1:funcnot 15 => MODAL_1:func 15
definition
  let a1, a2 be Element of MP-WFF;
  func A1 => A2 -> Element of MP-WFF equals
    'not' (a1 '&' 'not' a2);
end;

:: MODAL_1:def 14
theorem
for b1, b2 being Element of MP-WFF holds
b1 => b2 = 'not' (b1 '&' 'not' b2);

:: MODAL_1:th 35
theorem
for b1 being Element of NAT holds
   (elementary_tree 0) --> [3,b1] is Element of MP-WFF;

:: MODAL_1:th 36
theorem
(elementary_tree 0) --> [0,0] is Element of MP-WFF;

:: MODAL_1:funcnot 16 => MODAL_1:func 16
definition
  let a1 be Element of MP-variables;
  func @ A1 -> Element of MP-WFF equals
    (elementary_tree 0) --> a1;
end;

:: MODAL_1:def 15
theorem
for b1 being Element of MP-variables holds
   @ b1 = (elementary_tree 0) --> b1;

:: MODAL_1:th 37
theorem
for b1, b2 being Element of MP-variables
      st @ b1 = @ b2
   holds b1 = b2;

:: MODAL_1:th 38
theorem
for b1, b2 being Element of MP-WFF
      st 'not' b1 = 'not' b2
   holds b1 = b2;

:: MODAL_1:th 39
theorem
for b1, b2 being Element of MP-WFF
      st (#) b1 = (#) b2
   holds b1 = b2;

:: MODAL_1:th 40
theorem
for b1, b2, b3, b4 being Element of MP-WFF
      st b1 '&' b2 = b3 '&' b4
   holds b1 = b3 & b2 = b4;

:: MODAL_1:funcnot 17 => MODAL_1:func 17
definition
  func VERUM -> Element of MP-WFF equals
    (elementary_tree 0) --> [0,0];
end;

:: MODAL_1:def 16
theorem
VERUM = (elementary_tree 0) --> [0,0];

:: MODAL_1:th 42
theorem
for b1 being Element of MP-WFF
      st card proj1 b1 = 1 & b1 <> VERUM
   holds ex b2 being Element of MP-variables st
      b1 = @ b2;

:: MODAL_1:th 43
theorem
for b1 being Element of MP-WFF
      st 2 <= card proj1 b1 &
         (for b2 being Element of MP-WFF holds
            b1 <> 'not' b2 & b1 <> (#) b2)
   holds ex b2, b3 being Element of MP-WFF st
      b1 = b2 '&' b3;

:: MODAL_1:th 44
theorem
for b1 being Element of MP-WFF holds
   card proj1 b1 < card proj1 'not' b1;

:: MODAL_1:th 45
theorem
for b1 being Element of MP-WFF holds
   card proj1 b1 < card proj1 (#) b1;

:: MODAL_1:th 46
theorem
for b1, b2 being Element of MP-WFF holds
card proj1 b1 < card proj1 (b1 '&' b2) &
 card proj1 b2 < card proj1 (b1 '&' b2);

:: MODAL_1:attrnot 1 => MODAL_1:attr 1
definition
  let a1 be Element of MP-WFF;
  attr a1 is atomic means
    ex b1 being Element of MP-variables st
       a1 = @ b1;
end;

:: MODAL_1:dfs 17
definiens
  let a1 be Element of MP-WFF;
To prove
     a1 is atomic
it is sufficient to prove
  thus ex b1 being Element of MP-variables st
       a1 = @ b1;

:: MODAL_1:def 17
theorem
for b1 being Element of MP-WFF holds
      b1 is atomic
   iff
      ex b2 being Element of MP-variables st
         b1 = @ b2;

:: MODAL_1:attrnot 2 => MODAL_1:attr 2
definition
  let a1 be Element of MP-WFF;
  attr a1 is negative means
    ex b1 being Element of MP-WFF st
       a1 = 'not' b1;
end;

:: MODAL_1:dfs 18
definiens
  let a1 be Element of MP-WFF;
To prove
     a1 is negative
it is sufficient to prove
  thus ex b1 being Element of MP-WFF st
       a1 = 'not' b1;

:: MODAL_1:def 18
theorem
for b1 being Element of MP-WFF holds
      b1 is negative
   iff
      ex b2 being Element of MP-WFF st
         b1 = 'not' b2;

:: MODAL_1:attrnot 3 => MODAL_1:attr 3
definition
  let a1 be Element of MP-WFF;
  attr a1 is necessitive means
    ex b1 being Element of MP-WFF st
       a1 = (#) b1;
end;

:: MODAL_1:dfs 19
definiens
  let a1 be Element of MP-WFF;
To prove
     a1 is necessitive
it is sufficient to prove
  thus ex b1 being Element of MP-WFF st
       a1 = (#) b1;

:: MODAL_1:def 19
theorem
for b1 being Element of MP-WFF holds
      b1 is necessitive
   iff
      ex b2 being Element of MP-WFF st
         b1 = (#) b2;

:: MODAL_1:attrnot 4 => MODAL_1:attr 4
definition
  let a1 be Element of MP-WFF;
  attr a1 is conjunctive means
    ex b1, b2 being Element of MP-WFF st
       a1 = b1 '&' b2;
end;

:: MODAL_1:dfs 20
definiens
  let a1 be Element of MP-WFF;
To prove
     a1 is conjunctive
it is sufficient to prove
  thus ex b1, b2 being Element of MP-WFF st
       a1 = b1 '&' b2;

:: MODAL_1:def 20
theorem
for b1 being Element of MP-WFF holds
      b1 is conjunctive
   iff
      ex b2, b3 being Element of MP-WFF st
         b1 = b2 '&' b3;

:: MODAL_1:exreg 1
registration
  cluster Relation-like Function-like finite DecoratedTree-like atomic Element of MP-WFF;
end;

:: MODAL_1:exreg 2
registration
  cluster Relation-like Function-like finite DecoratedTree-like negative Element of MP-WFF;
end;

:: MODAL_1:exreg 3
registration
  cluster Relation-like Function-like finite DecoratedTree-like necessitive Element of MP-WFF;
end;

:: MODAL_1:exreg 4
registration
  cluster Relation-like Function-like finite DecoratedTree-like conjunctive Element of MP-WFF;
end;

:: MODAL_1:sch 1
scheme MODAL_1:sch 1
for b1 being Element of MP-WFF holds
   P1[b1]
provided
   P1[VERUM]
and
   for b1 being Element of MP-variables holds
      P1[@ b1]
and
   for b1 being Element of MP-WFF
         st P1[b1]
      holds P1['not' b1]
and
   for b1 being Element of MP-WFF
         st P1[b1]
      holds P1[(#) b1]
and
   for b1, b2 being Element of MP-WFF
         st P1[b1] & P1[b2]
      holds P1[b1 '&' b2];


:: MODAL_1:th 47
theorem
for b1 being Element of MP-WFF
      st b1 <> VERUM & b1 is not atomic Element of MP-WFF & b1 is not negative Element of MP-WFF & b1 is not necessitive Element of MP-WFF
   holds b1 is conjunctive Element of MP-WFF;

:: MODAL_1:th 48
theorem
for b1 being Element of MP-WFF
      st b1 <> VERUM &
         (for b2 being Element of MP-variables holds
            b1 <> @ b2) &
         (for b2 being Element of MP-WFF holds
            b1 <> 'not' b2) &
         (for b2 being Element of MP-WFF holds
            b1 <> (#) b2)
   holds ex b2, b3 being Element of MP-WFF st
      b1 = b2 '&' b3;

:: MODAL_1:th 49
theorem
for b1 being Element of MP-variables
for b2, b3 being Element of MP-WFF holds
@ b1 <> 'not' b2 & @ b1 <> (#) b2 & @ b1 <> b2 '&' b3;

:: MODAL_1:th 50
theorem
for b1, b2, b3 being Element of MP-WFF holds
'not' b1 <> (#) b2 & 'not' b1 <> b2 '&' b3;

:: MODAL_1:th 51
theorem
for b1, b2, b3 being Element of MP-WFF holds
(#) b1 <> b2 '&' b3;

:: MODAL_1:th 52
theorem
for b1 being Element of MP-variables
for b2, b3 being Element of MP-WFF holds
VERUM <> @ b1 & VERUM <> 'not' b2 & VERUM <> (#) b2 & VERUM <> b2 '&' b3;

:: MODAL_1:sch 2
scheme MODAL_1:sch 2
{F1 -> non empty set,
  F2 -> Element of F1(),
  F3 -> Element of F1(),
  F4 -> Element of F1(),
  F5 -> Element of F1(),
  F6 -> Element of F1()}:
ex b1 being Function-like quasi_total Relation of MP-WFF,F1() st
   b1 . VERUM = F2() &
    (for b2 being Element of MP-variables holds
       b1 . @ b2 = F3(b2)) &
    (for b2 being Element of MP-WFF holds
       b1 . 'not' b2 = F4(b1 . b2)) &
    (for b2 being Element of MP-WFF holds
       b1 . (#) b2 = F5(b1 . b2)) &
    (for b2, b3 being Element of MP-WFF holds
    b1 . (b2 '&' b3) = F6(b1 . b2, b1 . b3))