Article MODELC_1, MML version 4.99.1005

:: MODELC_1:funcnot 1 => MODELC_1:func 1
definition
  let a1, a2 be set;
  let a3 be Element of a2;
  func k_id(A1,A2,A3) -> Element of a2 equals
    a1
    if a1 in a2
    otherwise a3;
end;

:: MODELC_1:def 1
theorem
for b1, b2 being set
for b3 being Element of b2 holds
   (b1 in b2 implies k_id(b1,b2,b3) = b1) & (b1 in b2 or k_id(b1,b2,b3) = b3);

:: MODELC_1:funcnot 2 => MODELC_1:func 2
definition
  let a1 be set;
  func k_nat A1 -> Element of NAT equals
    a1
    if a1 in NAT
    otherwise 0;
end;

:: MODELC_1:def 2
theorem
for b1 being set holds
   (b1 in NAT implies k_nat b1 = b1) & (b1 in NAT or k_nat b1 = 0);

:: MODELC_1:funcnot 3 => MODELC_1:func 3
definition
  let a1 be Relation-like Function-like set;
  let a2, a3 be set;
  func UnivF(A2,A1,A3) -> set equals
    a1 . a2
    if a2 in proj1 a1
    otherwise a3;
end;

:: MODELC_1:def 3
theorem
for b1 being Relation-like Function-like set
for b2, b3 being set holds
(b2 in proj1 b1 implies UnivF(b2,b1,b3) = b1 . b2) &
 (b2 in proj1 b1 or UnivF(b2,b1,b3) = b3);

:: MODELC_1:funcnot 4 => MODELC_1:func 4
definition
  let a1 be set;
  func Castboolean A1 -> boolean set equals
    a1
    if a1 is boolean set
    otherwise FALSE;
end;

:: MODELC_1:def 4
theorem
for b1 being set holds
   (b1 is boolean set implies Castboolean b1 = b1) & (b1 is boolean set or Castboolean b1 = FALSE);

:: MODELC_1:funcnot 5 => MODELC_1:func 5
definition
  let a1, a2 be set;
  func CastBool(A2,A1) -> Element of bool a1 equals
    a2
    if a2 c= a1
    otherwise {};
end;

:: MODELC_1:def 5
theorem
for b1, b2 being set holds
(b2 c= b1 implies CastBool(b2,b1) = b2) & (b2 c= b1 or CastBool(b2,b1) = {});

:: MODELC_1:funcnot 6 => MODELC_1:func 6
definition
  let a1 be Element of VAR;
  redefine func <*a1*> -> FinSequence of NAT;
end;

:: MODELC_1:funcnot 7 => MODELC_1:func 7
definition
  let a1 be Element of NAT;
  func atom. A1 -> FinSequence of NAT equals
    <*5 + a1*>;
end;

:: MODELC_1:def 6
theorem
for b1 being Element of NAT holds
   atom. b1 = <*5 + b1*>;

:: MODELC_1:funcnot 8 => MODELC_1:func 8
definition
  let a1 be FinSequence of NAT;
  func 'not' A1 -> FinSequence of NAT equals
    <*0*> ^ a1;
end;

:: MODELC_1:def 7
theorem
for b1 being FinSequence of NAT holds
   'not' b1 = <*0*> ^ b1;

:: MODELC_1:funcnot 9 => MODELC_1:func 9
definition
  let a1, a2 be FinSequence of NAT;
  func A1 '&' A2 -> FinSequence of NAT equals
    (<*1*> ^ a1) ^ a2;
end;

:: MODELC_1:def 8
theorem
for b1, b2 being FinSequence of NAT holds
b1 '&' b2 = (<*1*> ^ b1) ^ b2;

:: MODELC_1:funcnot 10 => MODELC_1:func 10
definition
  let a1 be FinSequence of NAT;
  func EX A1 -> FinSequence of NAT equals
    <*2*> ^ a1;
end;

:: MODELC_1:def 9
theorem
for b1 being FinSequence of NAT holds
   EX b1 = <*2*> ^ b1;

:: MODELC_1:funcnot 11 => MODELC_1:func 11
definition
  let a1 be FinSequence of NAT;
  func EG A1 -> FinSequence of NAT equals
    <*3*> ^ a1;
end;

:: MODELC_1:def 10
theorem
for b1 being FinSequence of NAT holds
   EG b1 = <*3*> ^ b1;

:: MODELC_1:funcnot 12 => MODELC_1:func 12
definition
  let a1, a2 be FinSequence of NAT;
  func A1 EU A2 -> FinSequence of NAT equals
    (<*4*> ^ a1) ^ a2;
end;

:: MODELC_1:def 11
theorem
for b1, b2 being FinSequence of NAT holds
b1 EU b2 = (<*4*> ^ b1) ^ b2;

:: MODELC_1:funcnot 13 => MODELC_1:func 13
definition
  func CTL_WFF -> non empty set means
    (for b1 being set
           st b1 in it
        holds b1 is FinSequence of NAT) &
     (for b1 being Element of NAT holds
        atom. b1 in it) &
     (for b1 being FinSequence of NAT
           st b1 in it
        holds 'not' b1 in it) &
     (for b1, b2 being FinSequence of NAT
           st b1 in it & b2 in it
        holds b1 '&' b2 in it) &
     (for b1 being FinSequence of NAT
           st b1 in it
        holds EX b1 in it) &
     (for b1 being FinSequence of NAT
           st b1 in it
        holds EG b1 in it) &
     (for b1, b2 being FinSequence of NAT
           st b1 in it & b2 in it
        holds b1 EU b2 in it) &
     (for b1 being non empty set
           st (for b2 being set
                    st b2 in b1
                 holds b2 is FinSequence of NAT) &
              (for b2 being Element of NAT holds
                 atom. b2 in b1) &
              (for b2 being FinSequence of NAT
                    st b2 in b1
                 holds 'not' b2 in b1) &
              (for b2, b3 being FinSequence of NAT
                    st b2 in b1 & b3 in b1
                 holds b2 '&' b3 in b1) &
              (for b2 being FinSequence of NAT
                    st b2 in b1
                 holds EX b2 in b1) &
              (for b2 being FinSequence of NAT
                    st b2 in b1
                 holds EG b2 in b1) &
              (for b2, b3 being FinSequence of NAT
                    st b2 in b1 & b3 in b1
                 holds b2 EU b3 in b1)
        holds it c= b1);
end;

:: MODELC_1:def 12
theorem
for b1 being non empty set holds
      b1 = CTL_WFF
   iff
      (for b2 being set
             st b2 in b1
          holds b2 is FinSequence of NAT) &
       (for b2 being Element of NAT holds
          atom. b2 in b1) &
       (for b2 being FinSequence of NAT
             st b2 in b1
          holds 'not' b2 in b1) &
       (for b2, b3 being FinSequence of NAT
             st b2 in b1 & b3 in b1
          holds b2 '&' b3 in b1) &
       (for b2 being FinSequence of NAT
             st b2 in b1
          holds EX b2 in b1) &
       (for b2 being FinSequence of NAT
             st b2 in b1
          holds EG b2 in b1) &
       (for b2, b3 being FinSequence of NAT
             st b2 in b1 & b3 in b1
          holds b2 EU b3 in b1) &
       (for b2 being non empty set
             st (for b3 being set
                      st b3 in b2
                   holds b3 is FinSequence of NAT) &
                (for b3 being Element of NAT holds
                   atom. b3 in b2) &
                (for b3 being FinSequence of NAT
                      st b3 in b2
                   holds 'not' b3 in b2) &
                (for b3, b4 being FinSequence of NAT
                      st b3 in b2 & b4 in b2
                   holds b3 '&' b4 in b2) &
                (for b3 being FinSequence of NAT
                      st b3 in b2
                   holds EX b3 in b2) &
                (for b3 being FinSequence of NAT
                      st b3 in b2
                   holds EG b3 in b2) &
                (for b3, b4 being FinSequence of NAT
                      st b3 in b2 & b4 in b2
                   holds b3 EU b4 in b2)
          holds b1 c= b2);

:: MODELC_1:attrnot 1 => MODELC_1:attr 1
definition
  let a1 be FinSequence of NAT;
  attr a1 is CTL-formula-like means
    a1 is Element of CTL_WFF;
end;

:: MODELC_1:dfs 13
definiens
  let a1 be FinSequence of NAT;
To prove
     a1 is CTL-formula-like
it is sufficient to prove
  thus a1 is Element of CTL_WFF;

:: MODELC_1:def 13
theorem
for b1 being FinSequence of NAT holds
      b1 is CTL-formula-like
   iff
      b1 is Element of CTL_WFF;

:: MODELC_1:exreg 1
registration
  cluster Relation-like Function-like FinSequence-like CTL-formula-like FinSequence of NAT;
end;

:: MODELC_1:modenot 1
definition
  mode CTL-formula is CTL-formula-like FinSequence of NAT;
end;

:: MODELC_1:th 1
theorem
for b1 being set holds
      b1 is CTL-formula-like FinSequence of NAT
   iff
      b1 in CTL_WFF;

:: MODELC_1:funcreg 1
registration
  let a1 be Element of NAT;
  cluster atom. a1 -> CTL-formula-like;
end;

:: MODELC_1:funcreg 2
registration
  let a1 be CTL-formula-like FinSequence of NAT;
  cluster 'not' a1 -> CTL-formula-like;
end;

:: MODELC_1:funcreg 3
registration
  let a1 be CTL-formula-like FinSequence of NAT;
  cluster EX a1 -> CTL-formula-like;
end;

:: MODELC_1:funcreg 4
registration
  let a1 be CTL-formula-like FinSequence of NAT;
  cluster EG a1 -> CTL-formula-like;
end;

:: MODELC_1:funcreg 5
registration
  let a1, a2 be CTL-formula-like FinSequence of NAT;
  cluster a1 '&' a2 -> CTL-formula-like;
end;

:: MODELC_1:funcreg 6
registration
  let a1, a2 be CTL-formula-like FinSequence of NAT;
  cluster a1 EU a2 -> CTL-formula-like;
end;

:: MODELC_1:attrnot 2 => MODELC_1:attr 2
definition
  let a1 be CTL-formula-like FinSequence of NAT;
  attr a1 is atomic means
    ex b1 being Element of NAT st
       a1 = atom. b1;
end;

:: MODELC_1:dfs 14
definiens
  let a1 be CTL-formula-like FinSequence of NAT;
To prove
     a1 is atomic
it is sufficient to prove
  thus ex b1 being Element of NAT st
       a1 = atom. b1;

:: MODELC_1:def 14
theorem
for b1 being CTL-formula-like FinSequence of NAT holds
      b1 is atomic
   iff
      ex b2 being Element of NAT st
         b1 = atom. b2;

:: MODELC_1:attrnot 3 => MODELC_1:attr 3
definition
  let a1 be CTL-formula-like FinSequence of NAT;
  attr a1 is negative means
    ex b1 being CTL-formula-like FinSequence of NAT st
       a1 = 'not' b1;
end;

:: MODELC_1:dfs 15
definiens
  let a1 be CTL-formula-like FinSequence of NAT;
To prove
     a1 is negative
it is sufficient to prove
  thus ex b1 being CTL-formula-like FinSequence of NAT st
       a1 = 'not' b1;

:: MODELC_1:def 15
theorem
for b1 being CTL-formula-like FinSequence of NAT holds
      b1 is negative
   iff
      ex b2 being CTL-formula-like FinSequence of NAT st
         b1 = 'not' b2;

:: MODELC_1:attrnot 4 => MODELC_1:attr 4
definition
  let a1 be CTL-formula-like FinSequence of NAT;
  attr a1 is conjunctive means
    ex b1, b2 being CTL-formula-like FinSequence of NAT st
       a1 = b1 '&' b2;
end;

:: MODELC_1:dfs 16
definiens
  let a1 be CTL-formula-like FinSequence of NAT;
To prove
     a1 is conjunctive
it is sufficient to prove
  thus ex b1, b2 being CTL-formula-like FinSequence of NAT st
       a1 = b1 '&' b2;

:: MODELC_1:def 16
theorem
for b1 being CTL-formula-like FinSequence of NAT holds
      b1 is conjunctive
   iff
      ex b2, b3 being CTL-formula-like FinSequence of NAT st
         b1 = b2 '&' b3;

:: MODELC_1:attrnot 5 => MODELC_1:attr 5
definition
  let a1 be CTL-formula-like FinSequence of NAT;
  attr a1 is ExistNext means
    ex b1 being CTL-formula-like FinSequence of NAT st
       a1 = EX b1;
end;

:: MODELC_1:dfs 17
definiens
  let a1 be CTL-formula-like FinSequence of NAT;
To prove
     a1 is ExistNext
it is sufficient to prove
  thus ex b1 being CTL-formula-like FinSequence of NAT st
       a1 = EX b1;

:: MODELC_1:def 17
theorem
for b1 being CTL-formula-like FinSequence of NAT holds
      b1 is ExistNext
   iff
      ex b2 being CTL-formula-like FinSequence of NAT st
         b1 = EX b2;

:: MODELC_1:attrnot 6 => MODELC_1:attr 6
definition
  let a1 be CTL-formula-like FinSequence of NAT;
  attr a1 is ExistGlobal means
    ex b1 being CTL-formula-like FinSequence of NAT st
       a1 = EG b1;
end;

:: MODELC_1:dfs 18
definiens
  let a1 be CTL-formula-like FinSequence of NAT;
To prove
     a1 is ExistGlobal
it is sufficient to prove
  thus ex b1 being CTL-formula-like FinSequence of NAT st
       a1 = EG b1;

:: MODELC_1:def 18
theorem
for b1 being CTL-formula-like FinSequence of NAT holds
      b1 is ExistGlobal
   iff
      ex b2 being CTL-formula-like FinSequence of NAT st
         b1 = EG b2;

:: MODELC_1:attrnot 7 => MODELC_1:attr 7
definition
  let a1 be CTL-formula-like FinSequence of NAT;
  attr a1 is ExistUntill means
    ex b1, b2 being CTL-formula-like FinSequence of NAT st
       a1 = b1 EU b2;
end;

:: MODELC_1:dfs 19
definiens
  let a1 be CTL-formula-like FinSequence of NAT;
To prove
     a1 is ExistUntill
it is sufficient to prove
  thus ex b1, b2 being CTL-formula-like FinSequence of NAT st
       a1 = b1 EU b2;

:: MODELC_1:def 19
theorem
for b1 being CTL-formula-like FinSequence of NAT holds
      b1 is ExistUntill
   iff
      ex b2, b3 being CTL-formula-like FinSequence of NAT st
         b1 = b2 EU b3;

:: MODELC_1:funcnot 14 => MODELC_1:func 14
definition
  let a1, a2 be CTL-formula-like FinSequence of NAT;
  func A1 'or' A2 -> CTL-formula-like FinSequence of NAT equals
    'not' (('not' a1) '&' 'not' a2);
end;

:: MODELC_1:def 20
theorem
for b1, b2 being CTL-formula-like FinSequence of NAT holds
b1 'or' b2 = 'not' (('not' b1) '&' 'not' b2);

:: MODELC_1:th 2
theorem
for b1 being CTL-formula-like FinSequence of NAT
      st b1 is not atomic & b1 is not negative & b1 is not conjunctive & b1 is not ExistNext & b1 is not ExistGlobal
   holds b1 is ExistUntill;

:: MODELC_1:funcnot 15 => MODELC_1:func 15
definition
  let a1 be CTL-formula-like FinSequence of NAT;
  assume (a1 is not negative & a1 is not ExistNext implies a1 is ExistGlobal);
  func the_argument_of A1 -> CTL-formula-like FinSequence of NAT means
    'not' it = a1
    if a1 is negative,
EX it = a1
    if a1 is ExistNext
    otherwise EG it = a1;
end;

:: MODELC_1:def 21
theorem
for b1 being CTL-formula-like FinSequence of NAT
   st (b1 is not negative & b1 is not ExistNext implies b1 is ExistGlobal)
for b2 being CTL-formula-like FinSequence of NAT holds
   (b1 is negative implies    (b2 = the_argument_of b1
    iff
       'not' b2 = b1)) &
    (b1 is ExistNext implies    (b2 = the_argument_of b1
    iff
       EX b2 = b1)) &
    (b1 is not negative & b1 is not ExistNext implies    (b2 = the_argument_of b1
    iff
       EG b2 = b1));

:: MODELC_1:funcnot 16 => MODELC_1:func 16
definition
  let a1 be CTL-formula-like FinSequence of NAT;
  assume (a1 is conjunctive or a1 is ExistUntill);
  func the_left_argument_of A1 -> CTL-formula-like FinSequence of NAT means
    ex b1 being CTL-formula-like FinSequence of NAT st
       it '&' b1 = a1
    if a1 is conjunctive
    otherwise ex b1 being CTL-formula-like FinSequence of NAT st
       it EU b1 = a1;
end;

:: MODELC_1:def 22
theorem
for b1 being CTL-formula-like FinSequence of NAT
   st (b1 is conjunctive or b1 is ExistUntill)
for b2 being CTL-formula-like FinSequence of NAT holds
   (b1 is conjunctive implies    (b2 = the_left_argument_of b1
    iff
       ex b3 being CTL-formula-like FinSequence of NAT st
          b2 '&' b3 = b1)) &
    (b1 is conjunctive or    (b2 = the_left_argument_of b1
    iff
       ex b3 being CTL-formula-like FinSequence of NAT st
          b2 EU b3 = b1));

:: MODELC_1:funcnot 17 => MODELC_1:func 17
definition
  let a1 be CTL-formula-like FinSequence of NAT;
  assume (a1 is conjunctive or a1 is ExistUntill);
  func the_right_argument_of A1 -> CTL-formula-like FinSequence of NAT means
    ex b1 being CTL-formula-like FinSequence of NAT st
       b1 '&' it = a1
    if a1 is conjunctive
    otherwise ex b1 being CTL-formula-like FinSequence of NAT st
       b1 EU it = a1;
end;

:: MODELC_1:def 23
theorem
for b1 being CTL-formula-like FinSequence of NAT
   st (b1 is conjunctive or b1 is ExistUntill)
for b2 being CTL-formula-like FinSequence of NAT holds
   (b1 is conjunctive implies    (b2 = the_right_argument_of b1
    iff
       ex b3 being CTL-formula-like FinSequence of NAT st
          b3 '&' b2 = b1)) &
    (b1 is conjunctive or    (b2 = the_right_argument_of b1
    iff
       ex b3 being CTL-formula-like FinSequence of NAT st
          b3 EU b2 = b1));

:: MODELC_1:funcnot 18 => MODELC_1:func 18
definition
  let a1 be set;
  func CastCTLformula A1 -> CTL-formula-like FinSequence of NAT equals
    a1
    if a1 in CTL_WFF
    otherwise atom. 0;
end;

:: MODELC_1:def 24
theorem
for b1 being set holds
   (b1 in CTL_WFF implies CastCTLformula b1 = b1) &
    (b1 in CTL_WFF or CastCTLformula b1 = atom. 0);

:: MODELC_1:structnot 1 => MODELC_1:struct 1
definition
  let a1 be set;
  struct() KripkeStr(#
    Worlds -> set,
    Starts -> Element of bool the Worlds of it,
    Possibles -> total Relation of the Worlds of it,the Worlds of it,
    Label -> Function-like quasi_total Relation of the Worlds of it,bool A1
  #);
end;

:: MODELC_1:attrnot 8 => MODELC_1:attr 8
definition
  let a1 be set;
  let a2 be KripkeStr over a1;
  attr a2 is strict;
end;

:: MODELC_1:exreg 2
registration
  let a1 be set;
  cluster strict KripkeStr over a1;
end;

:: MODELC_1:aggrnot 1 => MODELC_1:aggr 1
definition
  let a1, a2 be set;
  let a3 be Element of bool a2;
  let a4 be total Relation of a2,a2;
  let a5 be Function-like quasi_total Relation of a2,bool a1;
  aggr KripkeStr(#a2,a3,a4,a5#) -> strict KripkeStr over a1;
end;

:: MODELC_1:selnot 1 => MODELC_1:sel 1
definition
  let a1 be set;
  let a2 be KripkeStr over a1;
  sel the Worlds of a2 -> set;
end;

:: MODELC_1:selnot 2 => MODELC_1:sel 2
definition
  let a1 be set;
  let a2 be KripkeStr over a1;
  sel the Starts of a2 -> Element of bool the Worlds of a2;
end;

:: MODELC_1:selnot 3 => MODELC_1:sel 3
definition
  let a1 be set;
  let a2 be KripkeStr over a1;
  sel the Possibles of a2 -> total Relation of the Worlds of a2,the Worlds of a2;
end;

:: MODELC_1:selnot 4 => MODELC_1:sel 4
definition
  let a1 be set;
  let a2 be KripkeStr over a1;
  sel the Label of a2 -> Function-like quasi_total Relation of the Worlds of a2,bool a1;
end;

:: MODELC_1:structnot 2 => MODELC_1:struct 2
definition
  struct() CTLModelStr(#
    Assignations -> non empty set,
    BasicAssign -> non empty Element of bool the Assignations of it,
    And -> Function-like quasi_total Relation of [:the Assignations of it,the Assignations of it:],the Assignations of it,
    Not -> Function-like quasi_total Relation of the Assignations of it,the Assignations of it,
    EneXt -> Function-like quasi_total Relation of the Assignations of it,the Assignations of it,
    EGlobal -> Function-like quasi_total Relation of the Assignations of it,the Assignations of it,
    EUntill -> Function-like quasi_total Relation of [:the Assignations of it,the Assignations of it:],the Assignations of it
  #);
end;

:: MODELC_1:attrnot 9 => MODELC_1:attr 9
definition
  let a1 be CTLModelStr;
  attr a1 is strict;
end;

:: MODELC_1:exreg 3
registration
  cluster strict CTLModelStr;
end;

:: MODELC_1:aggrnot 2 => MODELC_1:aggr 2
definition
  let a1 be non empty set;
  let a2 be non empty Element of bool a1;
  let a3 be Function-like quasi_total Relation of [:a1,a1:],a1;
  let a4, a5, a6 be Function-like quasi_total Relation of a1,a1;
  let a7 be Function-like quasi_total Relation of [:a1,a1:],a1;
  aggr CTLModelStr(#a1,a2,a3,a4,a5,a6,a7#) -> strict CTLModelStr;
end;

:: MODELC_1:selnot 5 => MODELC_1:sel 5
definition
  let a1 be CTLModelStr;
  sel the Assignations of a1 -> non empty set;
end;

:: MODELC_1:selnot 6 => MODELC_1:sel 6
definition
  let a1 be CTLModelStr;
  sel the BasicAssign of a1 -> non empty Element of bool the Assignations of a1;
end;

:: MODELC_1:selnot 7 => MODELC_1:sel 7
definition
  let a1 be CTLModelStr;
  sel the And of a1 -> Function-like quasi_total Relation of [:the Assignations of a1,the Assignations of a1:],the Assignations of a1;
end;

:: MODELC_1:selnot 8 => MODELC_1:sel 8
definition
  let a1 be CTLModelStr;
  sel the Not of a1 -> Function-like quasi_total Relation of the Assignations of a1,the Assignations of a1;
end;

:: MODELC_1:selnot 9 => MODELC_1:sel 9
definition
  let a1 be CTLModelStr;
  sel the EneXt of a1 -> Function-like quasi_total Relation of the Assignations of a1,the Assignations of a1;
end;

:: MODELC_1:selnot 10 => MODELC_1:sel 10
definition
  let a1 be CTLModelStr;
  sel the EGlobal of a1 -> Function-like quasi_total Relation of the Assignations of a1,the Assignations of a1;
end;

:: MODELC_1:selnot 11 => MODELC_1:sel 11
definition
  let a1 be CTLModelStr;
  sel the EUntill of a1 -> Function-like quasi_total Relation of [:the Assignations of a1,the Assignations of a1:],the Assignations of a1;
end;

:: MODELC_1:modenot 2
definition
  let a1 be CTLModelStr;
  mode Assign of a1 is Element of the Assignations of a1;
end;

:: MODELC_1:funcnot 19 => MODELC_1:func 19
definition
  func atomic_WFF -> Element of bool CTL_WFF equals
    {b1 where b1 is CTL-formula-like FinSequence of NAT: b1 is atomic};
end;

:: MODELC_1:def 25
theorem
atomic_WFF = {b1 where b1 is CTL-formula-like FinSequence of NAT: b1 is atomic};

:: MODELC_1:prednot 1 => MODELC_1:pred 1
definition
  let a1 be CTLModelStr;
  let a2 be Function-like quasi_total Relation of atomic_WFF,the BasicAssign of a1;
  let a3 be Function-like quasi_total Relation of CTL_WFF,the Assignations of a1;
  pred A3 is-Evaluation-for A2 means
    for b1 being CTL-formula-like FinSequence of NAT holds
       (b1 is atomic implies a3 . b1 = a2 . b1) &
        (b1 is negative implies a3 . b1 = (the Not of a1) . (a3 . the_argument_of b1)) &
        (b1 is conjunctive implies a3 . b1 = (the And of a1) .(a3 . the_left_argument_of b1,a3 . the_right_argument_of b1)) &
        (b1 is ExistNext implies a3 . b1 = (the EneXt of a1) . (a3 . the_argument_of b1)) &
        (b1 is ExistGlobal implies a3 . b1 = (the EGlobal of a1) . (a3 . the_argument_of b1)) &
        (b1 is ExistUntill implies a3 . b1 = (the EUntill of a1) .(a3 . the_left_argument_of b1,a3 . the_right_argument_of b1));
end;

:: MODELC_1:dfs 26
definiens
  let a1 be CTLModelStr;
  let a2 be Function-like quasi_total Relation of atomic_WFF,the BasicAssign of a1;
  let a3 be Function-like quasi_total Relation of CTL_WFF,the Assignations of a1;
To prove
     a3 is-Evaluation-for a2
it is sufficient to prove
  thus for b1 being CTL-formula-like FinSequence of NAT holds
       (b1 is atomic implies a3 . b1 = a2 . b1) &
        (b1 is negative implies a3 . b1 = (the Not of a1) . (a3 . the_argument_of b1)) &
        (b1 is conjunctive implies a3 . b1 = (the And of a1) .(a3 . the_left_argument_of b1,a3 . the_right_argument_of b1)) &
        (b1 is ExistNext implies a3 . b1 = (the EneXt of a1) . (a3 . the_argument_of b1)) &
        (b1 is ExistGlobal implies a3 . b1 = (the EGlobal of a1) . (a3 . the_argument_of b1)) &
        (b1 is ExistUntill implies a3 . b1 = (the EUntill of a1) .(a3 . the_left_argument_of b1,a3 . the_right_argument_of b1));

:: MODELC_1:def 26
theorem
for b1 being CTLModelStr
for b2 being Function-like quasi_total Relation of atomic_WFF,the BasicAssign of b1
for b3 being Function-like quasi_total Relation of CTL_WFF,the Assignations of b1 holds
      b3 is-Evaluation-for b2
   iff
      for b4 being CTL-formula-like FinSequence of NAT holds
         (b4 is atomic implies b3 . b4 = b2 . b4) &
          (b4 is negative implies b3 . b4 = (the Not of b1) . (b3 . the_argument_of b4)) &
          (b4 is conjunctive implies b3 . b4 = (the And of b1) .(b3 . the_left_argument_of b4,b3 . the_right_argument_of b4)) &
          (b4 is ExistNext implies b3 . b4 = (the EneXt of b1) . (b3 . the_argument_of b4)) &
          (b4 is ExistGlobal implies b3 . b4 = (the EGlobal of b1) . (b3 . the_argument_of b4)) &
          (b4 is ExistUntill implies b3 . b4 = (the EUntill of b1) .(b3 . the_left_argument_of b4,b3 . the_right_argument_of b4));

:: MODELC_1:prednot 2 => MODELC_1:pred 2
definition
  let a1 be CTLModelStr;
  let a2 be Function-like quasi_total Relation of atomic_WFF,the BasicAssign of a1;
  let a3 be Function-like quasi_total Relation of CTL_WFF,the Assignations of a1;
  let a4 be Element of NAT;
  pred A3 is-PreEvaluation-for A4,A2 means
    for b1 being CTL-formula-like FinSequence of NAT
          st len b1 <= a4
       holds (b1 is atomic implies a3 . b1 = a2 . b1) &
        (b1 is negative implies a3 . b1 = (the Not of a1) . (a3 . the_argument_of b1)) &
        (b1 is conjunctive implies a3 . b1 = (the And of a1) .(a3 . the_left_argument_of b1,a3 . the_right_argument_of b1)) &
        (b1 is ExistNext implies a3 . b1 = (the EneXt of a1) . (a3 . the_argument_of b1)) &
        (b1 is ExistGlobal implies a3 . b1 = (the EGlobal of a1) . (a3 . the_argument_of b1)) &
        (b1 is ExistUntill implies a3 . b1 = (the EUntill of a1) .(a3 . the_left_argument_of b1,a3 . the_right_argument_of b1));
end;

:: MODELC_1:dfs 27
definiens
  let a1 be CTLModelStr;
  let a2 be Function-like quasi_total Relation of atomic_WFF,the BasicAssign of a1;
  let a3 be Function-like quasi_total Relation of CTL_WFF,the Assignations of a1;
  let a4 be Element of NAT;
To prove
     a3 is-PreEvaluation-for a4,a2
it is sufficient to prove
  thus for b1 being CTL-formula-like FinSequence of NAT
          st len b1 <= a4
       holds (b1 is atomic implies a3 . b1 = a2 . b1) &
        (b1 is negative implies a3 . b1 = (the Not of a1) . (a3 . the_argument_of b1)) &
        (b1 is conjunctive implies a3 . b1 = (the And of a1) .(a3 . the_left_argument_of b1,a3 . the_right_argument_of b1)) &
        (b1 is ExistNext implies a3 . b1 = (the EneXt of a1) . (a3 . the_argument_of b1)) &
        (b1 is ExistGlobal implies a3 . b1 = (the EGlobal of a1) . (a3 . the_argument_of b1)) &
        (b1 is ExistUntill implies a3 . b1 = (the EUntill of a1) .(a3 . the_left_argument_of b1,a3 . the_right_argument_of b1));

:: MODELC_1:def 27
theorem
for b1 being CTLModelStr
for b2 being Function-like quasi_total Relation of atomic_WFF,the BasicAssign of b1
for b3 being Function-like quasi_total Relation of CTL_WFF,the Assignations of b1
for b4 being Element of NAT holds
      b3 is-PreEvaluation-for b4,b2
   iff
      for b5 being CTL-formula-like FinSequence of NAT
            st len b5 <= b4
         holds (b5 is atomic implies b3 . b5 = b2 . b5) &
          (b5 is negative implies b3 . b5 = (the Not of b1) . (b3 . the_argument_of b5)) &
          (b5 is conjunctive implies b3 . b5 = (the And of b1) .(b3 . the_left_argument_of b5,b3 . the_right_argument_of b5)) &
          (b5 is ExistNext implies b3 . b5 = (the EneXt of b1) . (b3 . the_argument_of b5)) &
          (b5 is ExistGlobal implies b3 . b5 = (the EGlobal of b1) . (b3 . the_argument_of b5)) &
          (b5 is ExistUntill implies b3 . b5 = (the EUntill of b1) .(b3 . the_left_argument_of b5,b3 . the_right_argument_of b5));

:: MODELC_1:funcnot 20 => MODELC_1:func 20
definition
  let a1 be CTLModelStr;
  let a2 be Function-like quasi_total Relation of atomic_WFF,the BasicAssign of a1;
  let a3, a4 be Function-like quasi_total Relation of CTL_WFF,the Assignations of a1;
  let a5 be Element of NAT;
  let a6 be CTL-formula-like FinSequence of NAT;
  func GraftEval(A1,A2,A3,A4,A5,A6) -> set equals
    a3 . a6
    if a5 + 1 < len a6,
a2 . a6
    if len a6 = a5 + 1 & a6 is atomic,
(the Not of a1) . (a4 . the_argument_of a6)
    if len a6 = a5 + 1 & a6 is negative,
(the And of a1) .(a4 . the_left_argument_of a6,a4 . the_right_argument_of a6)
    if len a6 = a5 + 1 & a6 is conjunctive,
(the EneXt of a1) . (a4 . the_argument_of a6)
    if len a6 = a5 + 1 & a6 is ExistNext,
(the EGlobal of a1) . (a4 . the_argument_of a6)
    if len a6 = a5 + 1 & a6 is ExistGlobal,
(the EUntill of a1) .(a4 . the_left_argument_of a6,a4 . the_right_argument_of a6)
    if len a6 = a5 + 1 & a6 is ExistUntill,
a4 . a6
    if len a6 < a5 + 1
    otherwise {};
end;

:: MODELC_1:def 28
theorem
for b1 being CTLModelStr
for b2 being Function-like quasi_total Relation of atomic_WFF,the BasicAssign of b1
for b3, b4 being Function-like quasi_total Relation of CTL_WFF,the Assignations of b1
for b5 being Element of NAT
for b6 being CTL-formula-like FinSequence of NAT holds
   (len b6 <= b5 + 1 or GraftEval(b1,b2,b3,b4,b5,b6) = b3 . b6) &
    (len b6 = b5 + 1 & b6 is atomic implies GraftEval(b1,b2,b3,b4,b5,b6) = b2 . b6) &
    (len b6 = b5 + 1 & b6 is negative implies GraftEval(b1,b2,b3,b4,b5,b6) = (the Not of b1) . (b4 . the_argument_of b6)) &
    (len b6 = b5 + 1 & b6 is conjunctive implies GraftEval(b1,b2,b3,b4,b5,b6) = (the And of b1) .(b4 . the_left_argument_of b6,b4 . the_right_argument_of b6)) &
    (len b6 = b5 + 1 & b6 is ExistNext implies GraftEval(b1,b2,b3,b4,b5,b6) = (the EneXt of b1) . (b4 . the_argument_of b6)) &
    (len b6 = b5 + 1 & b6 is ExistGlobal implies GraftEval(b1,b2,b3,b4,b5,b6) = (the EGlobal of b1) . (b4 . the_argument_of b6)) &
    (len b6 = b5 + 1 & b6 is ExistUntill implies GraftEval(b1,b2,b3,b4,b5,b6) = (the EUntill of b1) .(b4 . the_left_argument_of b6,b4 . the_right_argument_of b6)) &
    (b5 + 1 <= len b6 or GraftEval(b1,b2,b3,b4,b5,b6) = b4 . b6) &
    (len b6 <= b5 + 1 & (len b6 = b5 + 1 implies b6 is not atomic) & (len b6 = b5 + 1 implies b6 is not negative) & (len b6 = b5 + 1 implies b6 is not conjunctive) & (len b6 = b5 + 1 implies b6 is not ExistNext) & (len b6 = b5 + 1 implies b6 is not ExistGlobal) & (len b6 = b5 + 1 implies b6 is not ExistUntill) & b5 + 1 <= len b6 implies GraftEval(b1,b2,b3,b4,b5,b6) = {});

:: MODELC_1:funcnot 21 => MODELC_1:func 21
definition
  let a1 be CTLModelStr;
  let a2 be Function-like quasi_total Relation of atomic_WFF,the BasicAssign of a1;
  let a3 be Element of NAT;
  func EvalSet(A1,A2,A3) -> non empty set equals
    {b1 where b1 is Function-like quasi_total Relation of CTL_WFF,the Assignations of a1: b1 is-PreEvaluation-for a3,a2};
end;

:: MODELC_1:def 29
theorem
for b1 being CTLModelStr
for b2 being Function-like quasi_total Relation of atomic_WFF,the BasicAssign of b1
for b3 being Element of NAT holds
   EvalSet(b1,b2,b3) = {b4 where b4 is Function-like quasi_total Relation of CTL_WFF,the Assignations of b1: b4 is-PreEvaluation-for b3,b2};

:: MODELC_1:funcnot 22 => MODELC_1:func 22
definition
  let a1 be CTLModelStr;
  let a2 be Element of the Assignations of a1;
  let a3 be set;
  func CastEval(A1,A3,A2) -> Function-like quasi_total Relation of CTL_WFF,the Assignations of a1 equals
    a3
    if a3 in Funcs(CTL_WFF,the Assignations of a1)
    otherwise CTL_WFF --> a2;
end;

:: MODELC_1:def 30
theorem
for b1 being CTLModelStr
for b2 being Element of the Assignations of b1
for b3 being set holds
   (b3 in Funcs(CTL_WFF,the Assignations of b1) implies CastEval(b1,b3,b2) = b3) &
    (b3 in Funcs(CTL_WFF,the Assignations of b1) or CastEval(b1,b3,b2) = CTL_WFF --> b2);

:: MODELC_1:funcnot 23 => MODELC_1:func 23
definition
  let a1 be CTLModelStr;
  let a2 be Function-like quasi_total Relation of atomic_WFF,the BasicAssign of a1;
  func EvalFamily(A1,A2) -> non empty set means
    for b1 being set holds
          b1 in it
       iff
          b1 in bool Funcs(CTL_WFF,the Assignations of a1) &
           (ex b2 being Element of NAT st
              b1 = EvalSet(a1,a2,b2));
end;

:: MODELC_1:def 31
theorem
for b1 being CTLModelStr
for b2 being Function-like quasi_total Relation of atomic_WFF,the BasicAssign of b1
for b3 being non empty set holds
      b3 = EvalFamily(b1,b2)
   iff
      for b4 being set holds
            b4 in b3
         iff
            b4 in bool Funcs(CTL_WFF,the Assignations of b1) &
             (ex b5 being Element of NAT st
                b4 = EvalSet(b1,b2,b5));

:: MODELC_1:th 3
theorem
for b1 being CTLModelStr
for b2 being Function-like quasi_total Relation of atomic_WFF,the BasicAssign of b1 holds
   ex b3 being Function-like quasi_total Relation of CTL_WFF,the Assignations of b1 st
      b3 is-Evaluation-for b2;

:: MODELC_1:th 4
theorem
for b1 being CTLModelStr
for b2 being Function-like quasi_total Relation of atomic_WFF,the BasicAssign of b1
for b3, b4 being Function-like quasi_total Relation of CTL_WFF,the Assignations of b1
      st b3 is-Evaluation-for b2 & b4 is-Evaluation-for b2
   holds b3 = b4;

:: MODELC_1:funcnot 24 => MODELC_1:func 24
definition
  let a1 be CTLModelStr;
  let a2 be Function-like quasi_total Relation of atomic_WFF,the BasicAssign of a1;
  let a3 be CTL-formula-like FinSequence of NAT;
  func Evaluate(A3,A2) -> Element of the Assignations of a1 means
    ex b1 being Function-like quasi_total Relation of CTL_WFF,the Assignations of a1 st
       b1 is-Evaluation-for a2 & it = b1 . a3;
end;

:: MODELC_1:def 32
theorem
for b1 being CTLModelStr
for b2 being Function-like quasi_total Relation of atomic_WFF,the BasicAssign of b1
for b3 being CTL-formula-like FinSequence of NAT
for b4 being Element of the Assignations of b1 holds
      b4 = Evaluate(b3,b2)
   iff
      ex b5 being Function-like quasi_total Relation of CTL_WFF,the Assignations of b1 st
         b5 is-Evaluation-for b2 & b4 = b5 . b3;

:: MODELC_1:funcnot 25 => MODELC_1:func 25
definition
  let a1 be CTLModelStr;
  let a2 be Element of the Assignations of a1;
  func 'not' A2 -> Element of the Assignations of a1 equals
    (the Not of a1) . a2;
end;

:: MODELC_1:def 33
theorem
for b1 being CTLModelStr
for b2 being Element of the Assignations of b1 holds
   'not' b2 = (the Not of b1) . b2;

:: MODELC_1:funcnot 26 => MODELC_1:func 26
definition
  let a1 be CTLModelStr;
  let a2, a3 be Element of the Assignations of a1;
  func A2 '&' A3 -> Element of the Assignations of a1 equals
    (the And of a1) .(a2,a3);
end;

:: MODELC_1:def 34
theorem
for b1 being CTLModelStr
for b2, b3 being Element of the Assignations of b1 holds
b2 '&' b3 = (the And of b1) .(b2,b3);

:: MODELC_1:funcnot 27 => MODELC_1:func 27
definition
  let a1 be CTLModelStr;
  let a2 be Element of the Assignations of a1;
  func EX A2 -> Element of the Assignations of a1 equals
    (the EneXt of a1) . a2;
end;

:: MODELC_1:def 35
theorem
for b1 being CTLModelStr
for b2 being Element of the Assignations of b1 holds
   EX b2 = (the EneXt of b1) . b2;

:: MODELC_1:funcnot 28 => MODELC_1:func 28
definition
  let a1 be CTLModelStr;
  let a2 be Element of the Assignations of a1;
  func EG A2 -> Element of the Assignations of a1 equals
    (the EGlobal of a1) . a2;
end;

:: MODELC_1:def 36
theorem
for b1 being CTLModelStr
for b2 being Element of the Assignations of b1 holds
   EG b2 = (the EGlobal of b1) . b2;

:: MODELC_1:funcnot 29 => MODELC_1:func 29
definition
  let a1 be CTLModelStr;
  let a2, a3 be Element of the Assignations of a1;
  func A2 EU A3 -> Element of the Assignations of a1 equals
    (the EUntill of a1) .(a2,a3);
end;

:: MODELC_1:def 37
theorem
for b1 being CTLModelStr
for b2, b3 being Element of the Assignations of b1 holds
b2 EU b3 = (the EUntill of b1) .(b2,b3);

:: MODELC_1:funcnot 30 => MODELC_1:func 30
definition
  let a1 be CTLModelStr;
  let a2, a3 be Element of the Assignations of a1;
  func A2 'or' A3 -> Element of the Assignations of a1 equals
    'not' (('not' a2) '&' 'not' a3);
end;

:: MODELC_1:def 38
theorem
for b1 being CTLModelStr
for b2, b3 being Element of the Assignations of b1 holds
b2 'or' b3 = 'not' (('not' b2) '&' 'not' b3);

:: MODELC_1:th 5
theorem
for b1 being CTL-formula-like FinSequence of NAT
for b2 being CTLModelStr
for b3 being Function-like quasi_total Relation of atomic_WFF,the BasicAssign of b2 holds
   Evaluate('not' b1,b3) = 'not' Evaluate(b1,b3);

:: MODELC_1:th 6
theorem
for b1, b2 being CTL-formula-like FinSequence of NAT
for b3 being CTLModelStr
for b4 being Function-like quasi_total Relation of atomic_WFF,the BasicAssign of b3 holds
   Evaluate(b1 '&' b2,b4) = (Evaluate(b1,b4)) '&' Evaluate(b2,b4);

:: MODELC_1:th 7
theorem
for b1 being CTL-formula-like FinSequence of NAT
for b2 being CTLModelStr
for b3 being Function-like quasi_total Relation of atomic_WFF,the BasicAssign of b2 holds
   Evaluate(EX b1,b3) = EX Evaluate(b1,b3);

:: MODELC_1:th 8
theorem
for b1 being CTL-formula-like FinSequence of NAT
for b2 being CTLModelStr
for b3 being Function-like quasi_total Relation of atomic_WFF,the BasicAssign of b2 holds
   Evaluate(EG b1,b3) = EG Evaluate(b1,b3);

:: MODELC_1:th 9
theorem
for b1, b2 being CTL-formula-like FinSequence of NAT
for b3 being CTLModelStr
for b4 being Function-like quasi_total Relation of atomic_WFF,the BasicAssign of b3 holds
   Evaluate(b1 EU b2,b4) = (Evaluate(b1,b4)) EU Evaluate(b2,b4);

:: MODELC_1:th 10
theorem
for b1, b2 being CTL-formula-like FinSequence of NAT
for b3 being CTLModelStr
for b4 being Function-like quasi_total Relation of atomic_WFF,the BasicAssign of b3 holds
   Evaluate(b1 'or' b2,b4) = (Evaluate(b1,b4)) 'or' Evaluate(b2,b4);

:: MODELC_1:funcnot 31 => FUNCT_7:func 9
notation
  let a1 be Relation-like Function-like set;
  let a2 be Element of NAT;
  synonym a1 |** a2 for iter(a1,a2);
end;

:: MODELC_1:funcnot 32 => MODELC_1:func 31
definition
  let a1 be set;
  let a2 be Function-like quasi_total Relation of a1,a1;
  let a3 be Element of NAT;
  redefine func a2 |** a3 -> Function-like quasi_total Relation of a1,a1;
end;

:: MODELC_1:sch 1
scheme MODELC_1:sch 1
{F1 -> non empty set,
  F2 -> total Relation of F1(),F1(),
  F3 -> Element of F1(),
  F4 -> set}:
ex b1 being Function-like quasi_total Relation of NAT,F1() st
   b1 . 0 = F3() &
    (for b2 being Element of NAT holds
       [b1 . b2,b1 . (b2 + 1)] in F2() &
        b1 . (b2 + 1) in F4(b1 . b2))
provided
   for b1 being Element of F1() holds
      (Im(F2(),b1)) /\ F4(b1) is non empty Element of bool F1();


:: MODELC_1:modenot 3 => MODELC_1:mode 1
definition
  let a1 be non empty set;
  let a2 be total Relation of a1,a1;
  mode inf_path of A2 -> Function-like quasi_total Relation of NAT,a1 means
    for b1 being Element of NAT holds
       [it . b1,it . (b1 + 1)] in a2;
end;

:: MODELC_1:dfs 39
definiens
  let a1 be non empty set;
  let a2 be total Relation of a1,a1;
  let a3 be Function-like quasi_total Relation of NAT,a1;
To prove
     a3 is inf_path of a2
it is sufficient to prove
  thus for b1 being Element of NAT holds
       [a3 . b1,a3 . (b1 + 1)] in a2;

:: MODELC_1:def 39
theorem
for b1 being non empty set
for b2 being total Relation of b1,b1
for b3 being Function-like quasi_total Relation of NAT,b1 holds
      b3 is inf_path of b2
   iff
      for b4 being Element of NAT holds
         [b3 . b4,b3 . (b4 + 1)] in b2;

:: MODELC_1:funcnot 33 => MODELC_1:func 32
definition
  let a1 be non empty set;
  func ModelSP A1 -> non empty set equals
    Funcs(a1,BOOLEAN);
end;

:: MODELC_1:def 40
theorem
for b1 being non empty set holds
   ModelSP b1 = Funcs(b1,BOOLEAN);

:: MODELC_1:funcreg 7
registration
  let a1 be non empty set;
  cluster ModelSP a1 -> non empty;
end;

:: MODELC_1:funcnot 34 => MODELC_1:func 33
definition
  let a1 be non empty set;
  let a2 be set;
  func Fid(A2,A1) -> Function-like quasi_total Relation of a1,BOOLEAN equals
    a2
    if a2 in ModelSP a1
    otherwise a1 --> FALSE;
end;

:: MODELC_1:def 41
theorem
for b1 being non empty set
for b2 being set holds
   (b2 in ModelSP b1 implies Fid(b2,b1) = b2) &
    (b2 in ModelSP b1 or Fid(b2,b1) = b1 --> FALSE);

:: MODELC_1:sch 2
scheme MODELC_1:sch 2
{F1 -> non empty set,
  F2 -> Function-like quasi_total Relation of F1(),BOOLEAN,
  F3 -> boolean set}:
ex b1 being set st
   b1 in ModelSP F1() &
    (for b2 being set
          st b2 in F1()
       holds    F3(b2, F2()) = TRUE
       iff
          (Fid(b1,F1())) . b2 = TRUE)


:: MODELC_1:sch 3
scheme MODELC_1:sch 3
{F1 -> non empty set,
  F2 -> Function-like quasi_total Relation of F1(),BOOLEAN,
  F3 -> boolean set}:
for b1, b2 being set
      st b1 in ModelSP F1() &
         (for b3 being set
               st b3 in F1()
            holds    F3(b3, F2()) = TRUE
            iff
               (Fid(b1,F1())) . b3 = TRUE) &
         b2 in ModelSP F1() &
         (for b3 being set
               st b3 in F1()
            holds    F3(b3, F2()) = TRUE
            iff
               (Fid(b2,F1())) . b3 = TRUE)
   holds b1 = b2


:: MODELC_1:sch 4
scheme MODELC_1:sch 4
{F1 -> non empty set,
  F2 -> Element of F1()}:
ex b1 being Function-like quasi_total Relation of F1(),F1() st
   for b2 being set
         st b2 in F1()
      holds b1 . b2 = F2(b2)


:: MODELC_1:sch 5
scheme MODELC_1:sch 5
{F1 -> non empty set,
  F2 -> non empty set,
  F3 -> Element of F2()}:
for b1, b2 being Function-like quasi_total Relation of F2(),F2()
      st (for b3 being set
               st b3 in F2()
            holds b1 . b3 = F3(b3)) &
         (for b3 being set
               st b3 in F2()
            holds b2 . b3 = F3(b3))
   holds b1 = b2


:: MODELC_1:sch 6
scheme MODELC_1:sch 6
{F1 -> non empty set,
  F2 -> Function-like quasi_total Relation of F1(),BOOLEAN,
  F3 -> Function-like quasi_total Relation of F1(),BOOLEAN,
  F4 -> boolean set}:
ex b1 being set st
   b1 in ModelSP F1() &
    (for b2 being set
          st b2 in F1()
       holds    F4(b2, F2(), F3()) = TRUE
       iff
          (Fid(b1,F1())) . b2 = TRUE)


:: MODELC_1:sch 7
scheme MODELC_1:sch 7
{F1 -> non empty set,
  F2 -> Function-like quasi_total Relation of F1(),BOOLEAN,
  F3 -> Function-like quasi_total Relation of F1(),BOOLEAN,
  F4 -> boolean set}:
for b1, b2 being set
      st b1 in ModelSP F1() &
         (for b3 being set
               st b3 in F1()
            holds    F4(b3, F2(), F3()) = TRUE
            iff
               (Fid(b1,F1())) . b3 = TRUE) &
         b2 in ModelSP F1() &
         (for b3 being set
               st b3 in F1()
            holds    F4(b3, F2(), F3()) = TRUE
            iff
               (Fid(b2,F1())) . b3 = TRUE)
   holds b1 = b2


:: MODELC_1:funcnot 35 => MODELC_1:func 34
definition
  let a1 be non empty set;
  let a2 be set;
  func Not_0(A2,A1) -> Element of ModelSP a1 means
    for b1 being set
          st b1 in a1
       holds    'not' Castboolean ((Fid(a2,a1)) . b1) = TRUE
       iff
          (Fid(it,a1)) . b1 = TRUE;
end;

:: MODELC_1:def 42
theorem
for b1 being non empty set
for b2 being set
for b3 being Element of ModelSP b1 holds
      b3 = Not_0(b2,b1)
   iff
      for b4 being set
            st b4 in b1
         holds    'not' Castboolean ((Fid(b2,b1)) . b4) = TRUE
         iff
            (Fid(b3,b1)) . b4 = TRUE;

:: MODELC_1:funcnot 36 => MODELC_1:func 35
definition
  let a1 be non empty set;
  func Not_ A1 -> Function-like quasi_total Relation of ModelSP a1,ModelSP a1 means
    for b1 being set
          st b1 in ModelSP a1
       holds it . b1 = Not_0(b1,a1);
end;

:: MODELC_1:def 43
theorem
for b1 being non empty set
for b2 being Function-like quasi_total Relation of ModelSP b1,ModelSP b1 holds
      b2 = Not_ b1
   iff
      for b3 being set
            st b3 in ModelSP b1
         holds b2 . b3 = Not_0(b3,b1);

:: MODELC_1:funcnot 37 => MODELC_1:func 36
definition
  let a1 be non empty set;
  let a2 be total Relation of a1,a1;
  let a3 be Function-like quasi_total Relation of a1,BOOLEAN;
  let a4 be set;
  func EneXt_univ(A4,A3,A2) -> Element of BOOLEAN equals
    TRUE
    if a4 in a1 &
     (ex b1 being inf_path of a2 st
        b1 . 0 = a4 & a3 . (b1 . 1) = TRUE)
    otherwise FALSE;
end;

:: MODELC_1:def 44
theorem
for b1 being non empty set
for b2 being total Relation of b1,b1
for b3 being Function-like quasi_total Relation of b1,BOOLEAN
for b4 being set holds
   (b4 in b1 &
     (ex b5 being inf_path of b2 st
        b5 . 0 = b4 & b3 . (b5 . 1) = TRUE) implies EneXt_univ(b4,b3,b2) = TRUE) &
    (b4 in b1 &
     (ex b5 being inf_path of b2 st
        b5 . 0 = b4 & b3 . (b5 . 1) = TRUE) or EneXt_univ(b4,b3,b2) = FALSE);

:: MODELC_1:funcnot 38 => MODELC_1:func 37
definition
  let a1 be non empty set;
  let a2 be total Relation of a1,a1;
  let a3 be set;
  func EneXt_0(A3,A2) -> Element of ModelSP a1 means
    for b1 being set
          st b1 in a1
       holds    EneXt_univ(b1,Fid(a3,a1),a2) = TRUE
       iff
          (Fid(it,a1)) . b1 = TRUE;
end;

:: MODELC_1:def 45
theorem
for b1 being non empty set
for b2 being total Relation of b1,b1
for b3 being set
for b4 being Element of ModelSP b1 holds
      b4 = EneXt_0(b3,b2)
   iff
      for b5 being set
            st b5 in b1
         holds    EneXt_univ(b5,Fid(b3,b1),b2) = TRUE
         iff
            (Fid(b4,b1)) . b5 = TRUE;

:: MODELC_1:funcnot 39 => MODELC_1:func 38
definition
  let a1 be non empty set;
  let a2 be total Relation of a1,a1;
  func EneXt_ A2 -> Function-like quasi_total Relation of ModelSP a1,ModelSP a1 means
    for b1 being set
          st b1 in ModelSP a1
       holds it . b1 = EneXt_0(b1,a2);
end;

:: MODELC_1:def 46
theorem
for b1 being non empty set
for b2 being total Relation of b1,b1
for b3 being Function-like quasi_total Relation of ModelSP b1,ModelSP b1 holds
      b3 = EneXt_ b2
   iff
      for b4 being set
            st b4 in ModelSP b1
         holds b3 . b4 = EneXt_0(b4,b2);

:: MODELC_1:funcnot 40 => MODELC_1:func 39
definition
  let a1 be non empty set;
  let a2 be total Relation of a1,a1;
  let a3 be Function-like quasi_total Relation of a1,BOOLEAN;
  let a4 be set;
  func EGlobal_univ(A4,A3,A2) -> Element of BOOLEAN equals
    TRUE
    if a4 in a1 &
     (ex b1 being inf_path of a2 st
        b1 . 0 = a4 &
         (for b2 being Element of NAT holds
            a3 . (b1 . b2) = TRUE))
    otherwise FALSE;
end;

:: MODELC_1:def 47
theorem
for b1 being non empty set
for b2 being total Relation of b1,b1
for b3 being Function-like quasi_total Relation of b1,BOOLEAN
for b4 being set holds
   (b4 in b1 &
     (ex b5 being inf_path of b2 st
        b5 . 0 = b4 &
         (for b6 being Element of NAT holds
            b3 . (b5 . b6) = TRUE)) implies EGlobal_univ(b4,b3,b2) = TRUE) &
    (b4 in b1 &
     (ex b5 being inf_path of b2 st
        b5 . 0 = b4 &
         (for b6 being Element of NAT holds
            b3 . (b5 . b6) = TRUE)) or EGlobal_univ(b4,b3,b2) = FALSE);

:: MODELC_1:funcnot 41 => MODELC_1:func 40
definition
  let a1 be non empty set;
  let a2 be total Relation of a1,a1;
  let a3 be set;
  func EGlobal_0(A3,A2) -> Element of ModelSP a1 means
    for b1 being set
          st b1 in a1
       holds    EGlobal_univ(b1,Fid(a3,a1),a2) = TRUE
       iff
          (Fid(it,a1)) . b1 = TRUE;
end;

:: MODELC_1:def 48
theorem
for b1 being non empty set
for b2 being total Relation of b1,b1
for b3 being set
for b4 being Element of ModelSP b1 holds
      b4 = EGlobal_0(b3,b2)
   iff
      for b5 being set
            st b5 in b1
         holds    EGlobal_univ(b5,Fid(b3,b1),b2) = TRUE
         iff
            (Fid(b4,b1)) . b5 = TRUE;

:: MODELC_1:funcnot 42 => MODELC_1:func 41
definition
  let a1 be non empty set;
  let a2 be total Relation of a1,a1;
  func EGlobal_ A2 -> Function-like quasi_total Relation of ModelSP a1,ModelSP a1 means
    for b1 being set
          st b1 in ModelSP a1
       holds it . b1 = EGlobal_0(b1,a2);
end;

:: MODELC_1:def 49
theorem
for b1 being non empty set
for b2 being total Relation of b1,b1
for b3 being Function-like quasi_total Relation of ModelSP b1,ModelSP b1 holds
      b3 = EGlobal_ b2
   iff
      for b4 being set
            st b4 in ModelSP b1
         holds b3 . b4 = EGlobal_0(b4,b2);

:: MODELC_1:funcnot 43 => MODELC_1:func 42
definition
  let a1 be non empty set;
  let a2, a3 be set;
  func And_0(A2,A3,A1) -> Element of ModelSP a1 means
    for b1 being set
          st b1 in a1
       holds    (Castboolean ((Fid(a2,a1)) . b1)) '&' Castboolean ((Fid(a3,a1)) . b1) = TRUE
       iff
          (Fid(it,a1)) . b1 = TRUE;
end;

:: MODELC_1:def 50
theorem
for b1 being non empty set
for b2, b3 being set
for b4 being Element of ModelSP b1 holds
      b4 = And_0(b2,b3,b1)
   iff
      for b5 being set
            st b5 in b1
         holds    (Castboolean ((Fid(b2,b1)) . b5)) '&' Castboolean ((Fid(b3,b1)) . b5) = TRUE
         iff
            (Fid(b4,b1)) . b5 = TRUE;

:: MODELC_1:funcnot 44 => MODELC_1:func 43
definition
  let a1 be non empty set;
  func And_ A1 -> Function-like quasi_total Relation of [:ModelSP a1,ModelSP a1:],ModelSP a1 means
    for b1, b2 being set
          st b1 in ModelSP a1 & b2 in ModelSP a1
       holds it .(b1,b2) = And_0(b1,b2,a1);
end;

:: MODELC_1:def 51
theorem
for b1 being non empty set
for b2 being Function-like quasi_total Relation of [:ModelSP b1,ModelSP b1:],ModelSP b1 holds
      b2 = And_ b1
   iff
      for b3, b4 being set
            st b3 in ModelSP b1 & b4 in ModelSP b1
         holds b2 .(b3,b4) = And_0(b3,b4,b1);

:: MODELC_1:funcnot 45 => MODELC_1:func 44
definition
  let a1 be non empty set;
  let a2 be total Relation of a1,a1;
  let a3, a4 be Function-like quasi_total Relation of a1,BOOLEAN;
  let a5 be set;
  func EUntill_univ(A5,A3,A4,A2) -> Element of BOOLEAN equals
    TRUE
    if a5 in a1 &
     (ex b1 being inf_path of a2 st
        b1 . 0 = a5 &
         (ex b2 being Element of NAT st
            (for b3 being Element of NAT
                   st b3 < b2
                holds a3 . (b1 . b3) = TRUE) &
             a4 . (b1 . b2) = TRUE))
    otherwise FALSE;
end;

:: MODELC_1:def 52
theorem
for b1 being non empty set
for b2 being total Relation of b1,b1
for b3, b4 being Function-like quasi_total Relation of b1,BOOLEAN
for b5 being set holds
   (b5 in b1 &
     (ex b6 being inf_path of b2 st
        b6 . 0 = b5 &
         (ex b7 being Element of NAT st
            (for b8 being Element of NAT
                   st b8 < b7
                holds b3 . (b6 . b8) = TRUE) &
             b4 . (b6 . b7) = TRUE)) implies EUntill_univ(b5,b3,b4,b2) = TRUE) &
    (b5 in b1 &
     (ex b6 being inf_path of b2 st
        b6 . 0 = b5 &
         (ex b7 being Element of NAT st
            (for b8 being Element of NAT
                   st b8 < b7
                holds b3 . (b6 . b8) = TRUE) &
             b4 . (b6 . b7) = TRUE)) or EUntill_univ(b5,b3,b4,b2) = FALSE);

:: MODELC_1:funcnot 46 => MODELC_1:func 45
definition
  let a1 be non empty set;
  let a2 be total Relation of a1,a1;
  let a3, a4 be set;
  func EUntill_0(A3,A4,A2) -> Element of ModelSP a1 means
    for b1 being set
          st b1 in a1
       holds    EUntill_univ(b1,Fid(a3,a1),Fid(a4,a1),a2) = TRUE
       iff
          (Fid(it,a1)) . b1 = TRUE;
end;

:: MODELC_1:def 53
theorem
for b1 being non empty set
for b2 being total Relation of b1,b1
for b3, b4 being set
for b5 being Element of ModelSP b1 holds
      b5 = EUntill_0(b3,b4,b2)
   iff
      for b6 being set
            st b6 in b1
         holds    EUntill_univ(b6,Fid(b3,b1),Fid(b4,b1),b2) = TRUE
         iff
            (Fid(b5,b1)) . b6 = TRUE;

:: MODELC_1:funcnot 47 => MODELC_1:func 46
definition
  let a1 be non empty set;
  let a2 be total Relation of a1,a1;
  func EUntill_ A2 -> Function-like quasi_total Relation of [:ModelSP a1,ModelSP a1:],ModelSP a1 means
    for b1, b2 being set
          st b1 in ModelSP a1 & b2 in ModelSP a1
       holds it .(b1,b2) = EUntill_0(b1,b2,a2);
end;

:: MODELC_1:def 54
theorem
for b1 being non empty set
for b2 being total Relation of b1,b1
for b3 being Function-like quasi_total Relation of [:ModelSP b1,ModelSP b1:],ModelSP b1 holds
      b3 = EUntill_ b2
   iff
      for b4, b5 being set
            st b4 in ModelSP b1 & b5 in ModelSP b1
         holds b3 .(b4,b5) = EUntill_0(b4,b5,b2);

:: MODELC_1:funcnot 48 => MODELC_1:func 47
definition
  let a1 be non empty set;
  let a2 be non empty Element of bool ModelSP a1;
  let a3 be set;
  func F_LABEL(A3,A2) -> Element of bool a2 means
    for b1 being set holds
          b1 in it
       iff
          b1 in a2 &
           (ex b2 being Function-like quasi_total Relation of a1,BOOLEAN st
              b2 = b1 & b2 . a3 = TRUE);
end;

:: MODELC_1:def 55
theorem
for b1 being non empty set
for b2 being non empty Element of bool ModelSP b1
for b3 being set
for b4 being Element of bool b2 holds
      b4 = F_LABEL(b3,b2)
   iff
      for b5 being set holds
            b5 in b4
         iff
            b5 in b2 &
             (ex b6 being Function-like quasi_total Relation of b1,BOOLEAN st
                b6 = b5 & b6 . b3 = TRUE);

:: MODELC_1:funcnot 49 => MODELC_1:func 48
definition
  let a1 be non empty set;
  let a2 be non empty Element of bool ModelSP a1;
  func Label_ A2 -> Function-like quasi_total Relation of a1,bool a2 means
    for b1 being set
          st b1 in a1
       holds it . b1 = F_LABEL(b1,a2);
end;

:: MODELC_1:def 56
theorem
for b1 being non empty set
for b2 being non empty Element of bool ModelSP b1
for b3 being Function-like quasi_total Relation of b1,bool b2 holds
      b3 = Label_ b2
   iff
      for b4 being set
            st b4 in b1
         holds b3 . b4 = F_LABEL(b4,b2);

:: MODELC_1:funcnot 50 => MODELC_1:func 49
definition
  let a1 be non empty set;
  let a2 be Element of bool a1;
  let a3 be total Relation of a1,a1;
  let a4 be non empty Element of bool ModelSP a1;
  func KModel(A3,A2,A4) -> KripkeStr over a4 equals
    KripkeStr(#a1,a2,a3,Label_ a4#);
end;

:: MODELC_1:def 57
theorem
for b1 being non empty set
for b2 being Element of bool b1
for b3 being total Relation of b1,b1
for b4 being non empty Element of bool ModelSP b1 holds
   KModel(b3,b2,b4) = KripkeStr(#b1,b2,b3,Label_ b4#);

:: MODELC_1:funcreg 8
registration
  let a1 be non empty set;
  let a2 be Element of bool a1;
  let a3 be total Relation of a1,a1;
  let a4 be non empty Element of bool ModelSP a1;
  cluster the Worlds of KModel(a3,a2,a4) -> non empty;
end;

:: MODELC_1:funcreg 9
registration
  let a1 be non empty set;
  let a2 be Element of bool a1;
  let a3 be total Relation of a1,a1;
  let a4 be non empty Element of bool ModelSP a1;
  cluster ModelSP the Worlds of KModel(a3,a2,a4) -> non empty;
end;

:: MODELC_1:funcnot 51 => MODELC_1:func 50
definition
  let a1 be non empty set;
  let a2 be total Relation of a1,a1;
  let a3 be non empty Element of bool ModelSP a1;
  func CTLModel(A2,A3) -> CTLModelStr equals
    CTLModelStr(#ModelSP a1,a3,And_ a1,Not_ a1,EneXt_ a2,EGlobal_ a2,EUntill_ a2#);
end;

:: MODELC_1:def 58
theorem
for b1 being non empty set
for b2 being total Relation of b1,b1
for b3 being non empty Element of bool ModelSP b1 holds
   CTLModel(b2,b3) = CTLModelStr(#ModelSP b1,b3,And_ b1,Not_ b1,EneXt_ b2,EGlobal_ b2,EUntill_ b2#);

:: MODELC_1:prednot 3 => MODELC_1:pred 3
definition
  let a1 be non empty set;
  let a2 be total Relation of a1,a1;
  let a3 be non empty Element of bool ModelSP a1;
  let a4 be Element of a1;
  let a5 be Element of the Assignations of CTLModel(a2,a3);
  pred A4 |= A5 means
    (Fid(a5,a1)) . a4 = TRUE;
end;

:: MODELC_1:dfs 59
definiens
  let a1 be non empty set;
  let a2 be total Relation of a1,a1;
  let a3 be non empty Element of bool ModelSP a1;
  let a4 be Element of a1;
  let a5 be Element of the Assignations of CTLModel(a2,a3);
To prove
     a4 |= a5
it is sufficient to prove
  thus (Fid(a5,a1)) . a4 = TRUE;

:: MODELC_1:def 59
theorem
for b1 being non empty set
for b2 being total Relation of b1,b1
for b3 being non empty Element of bool ModelSP b1
for b4 being Element of b1
for b5 being Element of the Assignations of CTLModel(b2,b3) holds
      b4 |= b5
   iff
      (Fid(b5,b1)) . b4 = TRUE;

:: MODELC_1:prednot 4 => not MODELC_1:pred 3
notation
  let a1 be non empty set;
  let a2 be total Relation of a1,a1;
  let a3 be non empty Element of bool ModelSP a1;
  let a4 be Element of a1;
  let a5 be Element of the Assignations of CTLModel(a2,a3);
  antonym a4 |/= a5 for a4 |= a5;
end;

:: MODELC_1:th 11
theorem
for b1 being non empty set
for b2 being total Relation of b1,b1
for b3 being Element of b1
for b4 being non empty Element of bool ModelSP b1
for b5 being Element of the Assignations of CTLModel(b2,b4)
      st b5 in b4
   holds    b3 |= b5
   iff
      b5 in (Label_ b4) . b3;

:: MODELC_1:th 12
theorem
for b1 being non empty set
for b2 being total Relation of b1,b1
for b3 being Element of b1
for b4 being non empty Element of bool ModelSP b1
for b5 being Element of the Assignations of CTLModel(b2,b4) holds
      b3 |= 'not' b5
   iff
      b3 |/= b5;

:: MODELC_1:th 13
theorem
for b1 being non empty set
for b2 being total Relation of b1,b1
for b3 being Element of b1
for b4 being non empty Element of bool ModelSP b1
for b5, b6 being Element of the Assignations of CTLModel(b2,b4) holds
   b3 |= b5 '&' b6
iff
   b3 |= b5 & b3 |= b6;

:: MODELC_1:th 14
theorem
for b1 being non empty set
for b2 being total Relation of b1,b1
for b3 being Element of b1
for b4 being non empty Element of bool ModelSP b1
for b5 being Element of the Assignations of CTLModel(b2,b4) holds
      b3 |= EX b5
   iff
      ex b6 being inf_path of b2 st
         b6 . 0 = b3 & b6 . 1 |= b5;

:: MODELC_1:th 15
theorem
for b1 being non empty set
for b2 being total Relation of b1,b1
for b3 being Element of b1
for b4 being non empty Element of bool ModelSP b1
for b5 being Element of the Assignations of CTLModel(b2,b4) holds
      b3 |= EG b5
   iff
      ex b6 being inf_path of b2 st
         b6 . 0 = b3 &
          (for b7 being Element of NAT holds
             b6 . b7 |= b5);

:: MODELC_1:th 16
theorem
for b1 being non empty set
for b2 being total Relation of b1,b1
for b3 being Element of b1
for b4 being non empty Element of bool ModelSP b1
for b5, b6 being Element of the Assignations of CTLModel(b2,b4) holds
   b3 |= b5 EU b6
iff
   ex b7 being inf_path of b2 st
      b7 . 0 = b3 &
       (ex b8 being Element of NAT st
          (for b9 being Element of NAT
                 st b9 < b8
              holds b7 . b9 |= b5) &
           b7 . b8 |= b6);

:: MODELC_1:th 17
theorem
for b1 being non empty set
for b2 being total Relation of b1,b1
for b3 being Element of b1
for b4 being non empty Element of bool ModelSP b1
for b5, b6 being Element of the Assignations of CTLModel(b2,b4) holds
   b3 |= b5 'or' b6
iff
   (b3 |= b5 or b3 |= b6);

:: MODELC_1:prednot 5 => MODELC_1:pred 4
definition
  let a1 be non empty set;
  let a2 be total Relation of a1,a1;
  let a3 be non empty Element of bool ModelSP a1;
  let a4 be Function-like quasi_total Relation of atomic_WFF,the BasicAssign of CTLModel(a2,a3);
  let a5 be Element of a1;
  let a6 be CTL-formula-like FinSequence of NAT;
  pred A5,A4 |= A6 means
    a5 |= Evaluate(a6,a4);
end;

:: MODELC_1:dfs 60
definiens
  let a1 be non empty set;
  let a2 be total Relation of a1,a1;
  let a3 be non empty Element of bool ModelSP a1;
  let a4 be Function-like quasi_total Relation of atomic_WFF,the BasicAssign of CTLModel(a2,a3);
  let a5 be Element of a1;
  let a6 be CTL-formula-like FinSequence of NAT;
To prove
     a5,a4 |= a6
it is sufficient to prove
  thus a5 |= Evaluate(a6,a4);

:: MODELC_1:def 60
theorem
for b1 being non empty set
for b2 being total Relation of b1,b1
for b3 being non empty Element of bool ModelSP b1
for b4 being Function-like quasi_total Relation of atomic_WFF,the BasicAssign of CTLModel(b2,b3)
for b5 being Element of b1
for b6 being CTL-formula-like FinSequence of NAT holds
      b5,b4 |= b6
   iff
      b5 |= Evaluate(b6,b4);

:: MODELC_1:prednot 6 => not MODELC_1:pred 4
notation
  let a1 be non empty set;
  let a2 be total Relation of a1,a1;
  let a3 be non empty Element of bool ModelSP a1;
  let a4 be Function-like quasi_total Relation of atomic_WFF,the BasicAssign of CTLModel(a2,a3);
  let a5 be Element of a1;
  let a6 be CTL-formula-like FinSequence of NAT;
  antonym a5,a4 |/= a6 for a5,a4 |= a6;
end;

:: MODELC_1:th 18
theorem
for b1 being CTL-formula-like FinSequence of NAT
for b2 being non empty set
for b3 being total Relation of b2,b2
for b4 being Element of b2
for b5 being non empty Element of bool ModelSP b2
for b6 being Function-like quasi_total Relation of atomic_WFF,the BasicAssign of CTLModel(b3,b5)
      st b1 is atomic
   holds    b4,b6 |= b1
   iff
      b6 . b1 in (Label_ b5) . b4;

:: MODELC_1:th 19
theorem
for b1 being CTL-formula-like FinSequence of NAT
for b2 being non empty set
for b3 being total Relation of b2,b2
for b4 being Element of b2
for b5 being non empty Element of bool ModelSP b2
for b6 being Function-like quasi_total Relation of atomic_WFF,the BasicAssign of CTLModel(b3,b5) holds
      b4,b6 |= 'not' b1
   iff
      b4,b6 |/= b1;

:: MODELC_1:th 20
theorem
for b1, b2 being CTL-formula-like FinSequence of NAT
for b3 being non empty set
for b4 being total Relation of b3,b3
for b5 being Element of b3
for b6 being non empty Element of bool ModelSP b3
for b7 being Function-like quasi_total Relation of atomic_WFF,the BasicAssign of CTLModel(b4,b6) holds
      b5,b7 |= b1 '&' b2
   iff
      b5,b7 |= b1 & b5,b7 |= b2;

:: MODELC_1:th 21
theorem
for b1, b2 being CTL-formula-like FinSequence of NAT
for b3 being non empty set
for b4 being total Relation of b3,b3
for b5 being Element of b3
for b6 being non empty Element of bool ModelSP b3
for b7 being Function-like quasi_total Relation of atomic_WFF,the BasicAssign of CTLModel(b4,b6) holds
      b5,b7 |= b1 'or' b2
   iff
      (b5,b7 |= b1 or b5,b7 |= b2);

:: MODELC_1:th 22
theorem
for b1 being CTL-formula-like FinSequence of NAT
for b2 being non empty set
for b3 being total Relation of b2,b2
for b4 being Element of b2
for b5 being non empty Element of bool ModelSP b2
for b6 being Function-like quasi_total Relation of atomic_WFF,the BasicAssign of CTLModel(b3,b5) holds
      b4,b6 |= EX b1
   iff
      ex b7 being inf_path of b3 st
         b7 . 0 = b4 & b7 . 1,b6 |= b1;

:: MODELC_1:th 23
theorem
for b1 being CTL-formula-like FinSequence of NAT
for b2 being non empty set
for b3 being total Relation of b2,b2
for b4 being Element of b2
for b5 being non empty Element of bool ModelSP b2
for b6 being Function-like quasi_total Relation of atomic_WFF,the BasicAssign of CTLModel(b3,b5) holds
      b4,b6 |= EG b1
   iff
      ex b7 being inf_path of b3 st
         b7 . 0 = b4 &
          (for b8 being Element of NAT holds
             b7 . b8,b6 |= b1);

:: MODELC_1:th 24
theorem
for b1, b2 being CTL-formula-like FinSequence of NAT
for b3 being non empty set
for b4 being total Relation of b3,b3
for b5 being Element of b3
for b6 being non empty Element of bool ModelSP b3
for b7 being Function-like quasi_total Relation of atomic_WFF,the BasicAssign of CTLModel(b4,b6) holds
      b5,b7 |= b1 EU b2
   iff
      ex b8 being inf_path of b4 st
         b8 . 0 = b5 &
          (ex b9 being Element of NAT st
             (for b10 being Element of NAT
                    st b10 < b9
                 holds b8 . b10,b7 |= b1) &
              b8 . b9,b7 |= b2);

:: MODELC_1:th 25
theorem
for b1 being non empty set
for b2 being total Relation of b1,b1
for b3 being Element of b1 holds
   ex b4 being inf_path of b2 st
      b4 . 0 = b3;

:: MODELC_1:th 26
theorem
for b1 being non empty set
for b2 being Relation of b1,b1 holds
      b2 is total(b1, b1)
   iff
      for b3 being set
            st b3 in b1
         holds ex b4 being set st
            b4 in b1 & [b3,b4] in b2;

:: MODELC_1:funcnot 52 => MODELC_1:func 51
definition
  let a1 be non empty set;
  let a2 be total Relation of a1,a1;
  let a3 be Element of a1;
  let a4 be inf_path of a2;
  let a5 be set;
  func PrePath(A5,A3,A4) -> Element of a1 equals
    a3
    if a5 = 0
    otherwise a4 . k_nat ((k_nat a5) - 1);
end;

:: MODELC_1:def 61
theorem
for b1 being non empty set
for b2 being total Relation of b1,b1
for b3 being Element of b1
for b4 being inf_path of b2
for b5 being set holds
   (b5 = 0 implies PrePath(b5,b3,b4) = b3) &
    (b5 = 0 or PrePath(b5,b3,b4) = b4 . k_nat ((k_nat b5) - 1));

:: MODELC_1:th 27
theorem
for b1 being non empty set
for b2 being total Relation of b1,b1
for b3, b4 being Element of b1
      st [b3,b4] in b2
   holds ex b5 being inf_path of b2 st
      b5 . 0 = b3 & b5 . 1 = b4;

:: MODELC_1:th 28
theorem
for b1 being non empty set
for b2 being total Relation of b1,b1
for b3 being Element of b1
for b4 being non empty Element of bool ModelSP b1
for b5 being Element of the Assignations of CTLModel(b2,b4) holds
      b3 |= EX b5
   iff
      ex b6 being Element of b1 st
         [b3,b6] in b2 & b6 |= b5;

:: MODELC_1:funcnot 53 => MODELC_1:func 52
definition
  let a1 be non empty set;
  let a2 be total Relation of a1,a1;
  let a3 be Element of bool a1;
  func Pred(A3,A2) -> Element of bool a1 equals
    {b1 where b1 is Element of a1: ex b2 being Element of a1 st
       b2 in a3 & [b1,b2] in a2};
end;

:: MODELC_1:def 62
theorem
for b1 being non empty set
for b2 being total Relation of b1,b1
for b3 being Element of bool b1 holds
   Pred(b3,b2) = {b4 where b4 is Element of b1: ex b5 being Element of b1 st
      b5 in b3 & [b4,b5] in b2};

:: MODELC_1:funcnot 54 => MODELC_1:func 53
definition
  let a1 be non empty set;
  let a2 be total Relation of a1,a1;
  let a3 be non empty Element of bool ModelSP a1;
  let a4 be Element of the Assignations of CTLModel(a2,a3);
  func SIGMA A4 -> Element of bool a1 equals
    {b1 where b1 is Element of a1: b1 |= a4};
end;

:: MODELC_1:def 63
theorem
for b1 being non empty set
for b2 being total Relation of b1,b1
for b3 being non empty Element of bool ModelSP b1
for b4 being Element of the Assignations of CTLModel(b2,b3) holds
   SIGMA b4 = {b5 where b5 is Element of b1: b5 |= b4};

:: MODELC_1:th 29
theorem
for b1 being non empty set
for b2 being total Relation of b1,b1
for b3 being non empty Element of bool ModelSP b1
for b4, b5 being Element of the Assignations of CTLModel(b2,b3)
      st SIGMA b4 = SIGMA b5
   holds b4 = b5;

:: MODELC_1:funcnot 55 => MODELC_1:func 54
definition
  let a1 be non empty set;
  let a2 be total Relation of a1,a1;
  let a3 be non empty Element of bool ModelSP a1;
  let a4 be Element of bool a1;
  func Tau(A4,A2,A3) -> Element of the Assignations of CTLModel(a2,a3) means
    for b1 being set
          st b1 in a1
       holds (Fid(it,a1)) . b1 = (chi(a4,a1)) . b1;
end;

:: MODELC_1:def 64
theorem
for b1 being non empty set
for b2 being total Relation of b1,b1
for b3 being non empty Element of bool ModelSP b1
for b4 being Element of bool b1
for b5 being Element of the Assignations of CTLModel(b2,b3) holds
      b5 = Tau(b4,b2,b3)
   iff
      for b6 being set
            st b6 in b1
         holds (Fid(b5,b1)) . b6 = (chi(b4,b1)) . b6;

:: MODELC_1:th 30
theorem
for b1 being non empty set
for b2 being total Relation of b1,b1
for b3 being non empty Element of bool ModelSP b1
for b4, b5 being Element of bool b1
      st Tau(b4,b2,b3) = Tau(b5,b2,b3)
   holds b4 = b5;

:: MODELC_1:th 31
theorem
for b1 being non empty set
for b2 being total Relation of b1,b1
for b3 being non empty Element of bool ModelSP b1
for b4 being Element of the Assignations of CTLModel(b2,b3) holds
   Tau(SIGMA b4,b2,b3) = b4;

:: MODELC_1:th 32
theorem
for b1 being non empty set
for b2 being total Relation of b1,b1
for b3 being non empty Element of bool ModelSP b1
for b4 being Element of bool b1 holds
   SIGMA Tau(b4,b2,b3) = b4;

:: MODELC_1:th 33
theorem
for b1 being non empty set
for b2 being total Relation of b1,b1
for b3 being non empty Element of bool ModelSP b1
for b4, b5 being Element of the Assignations of CTLModel(b2,b3) holds
SIGMA 'not' b4 = b1 \ SIGMA b4 &
 SIGMA (b4 '&' b5) = (SIGMA b4) /\ SIGMA b5 &
 SIGMA (b4 'or' b5) = (SIGMA b4) \/ SIGMA b5;

:: MODELC_1:th 34
theorem
for b1 being non empty set
for b2 being total Relation of b1,b1
for b3 being non empty Element of bool ModelSP b1
for b4, b5 being Element of bool b1
   st b4 c= b5
for b6 being Element of b1
      st b6 |= Tau(b4,b2,b3)
   holds b6 |= Tau(b5,b2,b3);

:: MODELC_1:th 35
theorem
for b1 being non empty set
for b2 being total Relation of b1,b1
for b3 being non empty Element of bool ModelSP b1
for b4, b5 being Element of the Assignations of CTLModel(b2,b3)
      st for b6 being Element of b1
              st b6 |= b4
           holds b6 |= b5
   holds SIGMA b4 c= SIGMA b5;

:: MODELC_1:funcnot 56 => MODELC_1:func 55
definition
  let a1 be non empty set;
  let a2 be total Relation of a1,a1;
  let a3 be non empty Element of bool ModelSP a1;
  let a4, a5 be Element of the Assignations of CTLModel(a2,a3);
  func Fax(A4,A5) -> Element of the Assignations of CTLModel(a2,a3) equals
    a4 '&' EX a5;
end;

:: MODELC_1:def 65
theorem
for b1 being non empty set
for b2 being total Relation of b1,b1
for b3 being non empty Element of bool ModelSP b1
for b4, b5 being Element of the Assignations of CTLModel(b2,b3) holds
Fax(b4,b5) = b4 '&' EX b5;

:: MODELC_1:th 36
theorem
for b1 being non empty set
for b2 being total Relation of b1,b1
for b3 being non empty Element of bool ModelSP b1
for b4, b5, b6 being Element of the Assignations of CTLModel(b2,b3)
   st for b7 being Element of b1
           st b7 |= b5
        holds b7 |= b6
for b7 being Element of b1
      st b7 |= Fax(b4,b5)
   holds b7 |= Fax(b4,b6);

:: MODELC_1:funcnot 57 => MODELC_1:func 56
definition
  let a1 be non empty set;
  let a2 be total Relation of a1,a1;
  let a3 be non empty Element of bool ModelSP a1;
  let a4 be Element of the Assignations of CTLModel(a2,a3);
  let a5 be Element of bool a1;
  func SigFaxTau(A4,A5,A2,A3) -> Element of bool a1 equals
    SIGMA Fax(a4,Tau(a5,a2,a3));
end;

:: MODELC_1:def 66
theorem
for b1 being non empty set
for b2 being total Relation of b1,b1
for b3 being non empty Element of bool ModelSP b1
for b4 being Element of the Assignations of CTLModel(b2,b3)
for b5 being Element of bool b1 holds
   SigFaxTau(b4,b5,b2,b3) = SIGMA Fax(b4,Tau(b5,b2,b3));

:: MODELC_1:th 37
theorem
for b1 being non empty set
for b2 being total Relation of b1,b1
for b3 being non empty Element of bool ModelSP b1
for b4 being Element of the Assignations of CTLModel(b2,b3)
for b5, b6 being Element of bool b1
      st b5 c= b6
   holds SigFaxTau(b4,b5,b2,b3) c= SigFaxTau(b4,b6,b2,b3);

:: MODELC_1:funcnot 58 => MODELC_1:func 57
definition
  let a1 be non empty set;
  let a2 be total Relation of a1,a1;
  let a3 be inf_path of a2;
  let a4 be Element of NAT;
  func PathShift(A3,A4) -> inf_path of a2 means
    for b1 being Element of NAT holds
       it . b1 = a3 . (b1 + a4);
end;

:: MODELC_1:def 67
theorem
for b1 being non empty set
for b2 being total Relation of b1,b1
for b3 being inf_path of b2
for b4 being Element of NAT
for b5 being inf_path of b2 holds
      b5 = PathShift(b3,b4)
   iff
      for b6 being Element of NAT holds
         b5 . b6 = b3 . (b6 + b4);

:: MODELC_1:funcnot 59 => MODELC_1:func 58
definition
  let a1 be non empty set;
  let a2 be total Relation of a1,a1;
  let a3, a4 be inf_path of a2;
  let a5, a6 be Element of NAT;
  func PathChange(A3,A4,A6,A5) -> set equals
    a3 . a5
    if a5 < a6
    otherwise a4 . (a5 - a6);
end;

:: MODELC_1:def 68
theorem
for b1 being non empty set
for b2 being total Relation of b1,b1
for b3, b4 being inf_path of b2
for b5, b6 being Element of NAT holds
(b6 <= b5 or PathChange(b3,b4,b6,b5) = b3 . b5) &
 (b6 <= b5 implies PathChange(b3,b4,b6,b5) = b4 . (b5 - b6));

:: MODELC_1:funcnot 60 => MODELC_1:func 59
definition
  let a1 be non empty set;
  let a2 be total Relation of a1,a1;
  let a3, a4 be inf_path of a2;
  let a5 be Element of NAT;
  func PathConc(A3,A4,A5) -> Function-like quasi_total Relation of NAT,a1 means
    for b1 being Element of NAT holds
       it . b1 = PathChange(a3,a4,a5,b1);
end;

:: MODELC_1:def 69
theorem
for b1 being non empty set
for b2 being total Relation of b1,b1
for b3, b4 being inf_path of b2
for b5 being Element of NAT
for b6 being Function-like quasi_total Relation of NAT,b1 holds
      b6 = PathConc(b3,b4,b5)
   iff
      for b7 being Element of NAT holds
         b6 . b7 = PathChange(b3,b4,b5,b7);

:: MODELC_1:th 38
theorem
for b1 being non empty set
for b2 being total Relation of b1,b1
for b3, b4 being inf_path of b2
for b5 being Element of NAT
      st b3 . b5 = b4 . 0
   holds PathConc(b3,b4,b5) is inf_path of b2;

:: MODELC_1:th 39
theorem
for b1 being non empty set
for b2 being total Relation of b1,b1
for b3 being non empty Element of bool ModelSP b1
for b4 being Element of the Assignations of CTLModel(b2,b3)
for b5 being Element of b1 holds
      b5 |= EG b4
   iff
      b5 |= Fax(b4,EG b4);

:: MODELC_1:th 40
theorem
for b1 being non empty set
for b2 being total Relation of b1,b1
for b3 being non empty Element of bool ModelSP b1
for b4 being Element of the Assignations of CTLModel(b2,b3)
for b5 being Element of b1
      st b5 |= b4 &
         (for b6 being Element of b1
               st b6 |= b4
            holds b6 |= EX b4)
   holds ex b6 being inf_path of b2 st
      b6 . 0 = b5 &
       (for b7 being Element of NAT holds
          b6 . b7 |= b4);

:: MODELC_1:th 41
theorem
for b1 being non empty set
for b2 being total Relation of b1,b1
for b3 being non empty Element of bool ModelSP b1
for b4, b5 being Element of the Assignations of CTLModel(b2,b3)
   st for b6 being Element of b1 holds
           b6 |= b5
        iff
           b6 |= Fax(b4,b5)
for b6 being Element of b1
      st b6 |= b5
   holds b6 |= EG b4;

:: MODELC_1:funcnot 61 => MODELC_1:func 60
definition
  let a1 be non empty set;
  let a2 be total Relation of a1,a1;
  let a3 be non empty Element of bool ModelSP a1;
  let a4 be Element of the Assignations of CTLModel(a2,a3);
  func TransEG A4 -> Function-like quasi_total c=-monotone Relation of bool a1,bool a1 means
    for b1 being Element of bool a1 holds
       it . b1 = SigFaxTau(a4,b1,a2,a3);
end;

:: MODELC_1:def 70
theorem
for b1 being non empty set
for b2 being total Relation of b1,b1
for b3 being non empty Element of bool ModelSP b1
for b4 being Element of the Assignations of CTLModel(b2,b3)
for b5 being Function-like quasi_total c=-monotone Relation of bool b1,bool b1 holds
      b5 = TransEG b4
   iff
      for b6 being Element of bool b1 holds
         b5 . b6 = SigFaxTau(b4,b6,b2,b3);

:: MODELC_1:th 42
theorem
for b1 being non empty set
for b2 being total Relation of b1,b1
for b3 being non empty Element of bool ModelSP b1
for b4, b5 being Element of the Assignations of CTLModel(b2,b3) holds
   for b6 being Element of b1 holds
         b6 |= b5
      iff
         b6 |= Fax(b4,b5)
iff
   SIGMA b5 is_a_fixpoint_of TransEG b4;

:: MODELC_1:th 43
theorem
for b1 being non empty set
for b2 being total Relation of b1,b1
for b3 being non empty Element of bool ModelSP b1
for b4 being Element of the Assignations of CTLModel(b2,b3) holds
   SIGMA EG b4 = gfp(b1,TransEG b4);

:: MODELC_1:funcnot 62 => MODELC_1:func 61
definition
  let a1 be non empty set;
  let a2 be total Relation of a1,a1;
  let a3 be non empty Element of bool ModelSP a1;
  let a4, a5, a6 be Element of the Assignations of CTLModel(a2,a3);
  func Foax(A5,A4,A6) -> Element of the Assignations of CTLModel(a2,a3) equals
    a5 'or' Fax(a4,a6);
end;

:: MODELC_1:def 71
theorem
for b1 being non empty set
for b2 being total Relation of b1,b1
for b3 being non empty Element of bool ModelSP b1
for b4, b5, b6 being Element of the Assignations of CTLModel(b2,b3) holds
Foax(b5,b4,b6) = b5 'or' Fax(b4,b6);

:: MODELC_1:th 44
theorem
for b1 being non empty set
for b2 being total Relation of b1,b1
for b3 being non empty Element of bool ModelSP b1
for b4, b5, b6, b7 being Element of the Assignations of CTLModel(b2,b3)
   st for b8 being Element of b1
           st b8 |= b6
        holds b8 |= b7
for b8 being Element of b1
      st b8 |= Foax(b5,b4,b6)
   holds b8 |= Foax(b5,b4,b7);

:: MODELC_1:funcnot 63 => MODELC_1:func 62
definition
  let a1 be non empty set;
  let a2 be total Relation of a1,a1;
  let a3 be non empty Element of bool ModelSP a1;
  let a4, a5 be Element of the Assignations of CTLModel(a2,a3);
  let a6 be Element of bool a1;
  func SigFoaxTau(A5,A4,A6,A2,A3) -> Element of bool a1 equals
    SIGMA Foax(a5,a4,Tau(a6,a2,a3));
end;

:: MODELC_1:def 72
theorem
for b1 being non empty set
for b2 being total Relation of b1,b1
for b3 being non empty Element of bool ModelSP b1
for b4, b5 being Element of the Assignations of CTLModel(b2,b3)
for b6 being Element of bool b1 holds
   SigFoaxTau(b5,b4,b6,b2,b3) = SIGMA Foax(b5,b4,Tau(b6,b2,b3));

:: MODELC_1:th 45
theorem
for b1 being non empty set
for b2 being total Relation of b1,b1
for b3 being non empty Element of bool ModelSP b1
for b4, b5 being Element of the Assignations of CTLModel(b2,b3)
for b6, b7 being Element of bool b1
      st b6 c= b7
   holds SigFoaxTau(b5,b4,b6,b2,b3) c= SigFoaxTau(b5,b4,b7,b2,b3);

:: MODELC_1:th 46
theorem
for b1 being non empty set
for b2 being total Relation of b1,b1
for b3 being non empty Element of bool ModelSP b1
for b4, b5 being Element of the Assignations of CTLModel(b2,b3)
for b6 being Element of b1 holds
      b6 |= b4 EU b5
   iff
      b6 |= Foax(b5,b4,b4 EU b5);

:: MODELC_1:th 47
theorem
for b1 being non empty set
for b2 being total Relation of b1,b1
for b3 being non empty Element of bool ModelSP b1
for b4, b5, b6 being Element of the Assignations of CTLModel(b2,b3)
   st for b7 being Element of b1 holds
           b7 |= b6
        iff
           b7 |= Foax(b5,b4,b6)
for b7 being Element of b1
      st b7 |= b4 EU b5
   holds b7 |= b6;

:: MODELC_1:funcnot 64 => MODELC_1:func 63
definition
  let a1 be non empty set;
  let a2 be total Relation of a1,a1;
  let a3 be non empty Element of bool ModelSP a1;
  let a4, a5 be Element of the Assignations of CTLModel(a2,a3);
  func TransEU(A4,A5) -> Function-like quasi_total c=-monotone Relation of bool a1,bool a1 means
    for b1 being Element of bool a1 holds
       it . b1 = SigFoaxTau(a5,a4,b1,a2,a3);
end;

:: MODELC_1:def 73
theorem
for b1 being non empty set
for b2 being total Relation of b1,b1
for b3 being non empty Element of bool ModelSP b1
for b4, b5 being Element of the Assignations of CTLModel(b2,b3)
for b6 being Function-like quasi_total c=-monotone Relation of bool b1,bool b1 holds
      b6 = TransEU(b4,b5)
   iff
      for b7 being Element of bool b1 holds
         b6 . b7 = SigFoaxTau(b5,b4,b7,b2,b3);

:: MODELC_1:th 48
theorem
for b1 being non empty set
for b2 being total Relation of b1,b1
for b3 being non empty Element of bool ModelSP b1
for b4, b5, b6 being Element of the Assignations of CTLModel(b2,b3) holds
   for b7 being Element of b1 holds
         b7 |= b6
      iff
         b7 |= Foax(b5,b4,b6)
iff
   SIGMA b6 is_a_fixpoint_of TransEU(b4,b5);

:: MODELC_1:th 49
theorem
for b1 being non empty set
for b2 being total Relation of b1,b1
for b3 being non empty Element of bool ModelSP b1
for b4, b5 being Element of the Assignations of CTLModel(b2,b3) holds
SIGMA (b4 EU b5) = lfp(b1,TransEU(b4,b5));

:: MODELC_1:th 50
theorem
for b1 being non empty set
for b2 being total Relation of b1,b1
for b3 being non empty Element of bool ModelSP b1
for b4 being Element of the Assignations of CTLModel(b2,b3) holds
   SIGMA EX b4 = Pred(SIGMA b4,b2);

:: MODELC_1:th 51
theorem
for b1 being non empty set
for b2 being total Relation of b1,b1
for b3 being non empty Element of bool ModelSP b1
for b4 being Element of the Assignations of CTLModel(b2,b3)
for b5 being Element of bool b1 holds
   (TransEG b4) . b5 = (SIGMA b4) /\ Pred(b5,b2);

:: MODELC_1:th 52
theorem
for b1 being non empty set
for b2 being total Relation of b1,b1
for b3 being non empty Element of bool ModelSP b1
for b4, b5 being Element of the Assignations of CTLModel(b2,b3)
for b6 being Element of bool b1 holds
   (TransEU(b4,b5)) . b6 = (SIGMA b5) \/ ((SIGMA b4) /\ Pred(b6,b2));