reserve k,n,n1,m,m1,m0,h,i,j for Nat,
  a,x,y,X,X1,X2,X3,X4,Y for set;
reserve L,L1,L2 for FinSequence;
reserve F,F1,G,G1,H for LTL-formula;
reserve W,W1,W2 for Subset of Subformulae H;
reserve v for LTL-formula;
reserve N,N1,N2,N10,N20,M for strict LTLnode over v;
reserve w for Element of Inf_seq(AtomicFamily);
reserve R1,R2 for Real_Sequence;
reserve s,s0,s1,s2 for elementary strict LTLnode over v;
reserve q for sequence of LTLStates(v);
reserve U for Choice_Function of BOOL Subformulae v;
reserve v for neg-inner-most LTL-formula;
reserve U for Choice_Function of BOOL Subformulae v;
reserve N,N1,N2,M1 for strict LTLnode over v;
reserve s,s1 for elementary strict LTLnode over v;

theorem Th68:
  w is-accepted-by BAutomaton(v) implies w |= v
proof
  deffunc Gzai(Nat) = CastSeq(w,AtomicFamily).$1;
  assume w is-accepted-by BAutomaton(v);
  then consider run being sequence of LTLStates(v) such that
A1: run.0 in InitS_LTL(v) and
A2: for i holds [[run.i,Gzai(i)],run.(i+1)] in Tran_LTL(v) and
A3: for FSet be set st FSet in FinalS_LTL(v) holds {k where k is Element
  of NAT:run.k in FSet} is infinite set;
  deffunc Run(Nat) = CastNode(run.$1,v);
  set Run01=Run(0+1);
  set Run00=Run(0);
A4: for i holds Run(i+1) is_next_of Run(i) & Gzai(i) in Label_(Run(i+1))
  proof
    let i;
    set z= [[run.i,Gzai(i)],run.(i+1)];
    z in Tran_LTL(v) by A2;
    then consider
    y being Element of [:LTLStates(v),AtomicFamily,LTLStates(v):]
    such that
A5: z = y and
A6: ex s,s1,x st y=[[s,x],s1] & s1 is_next_of s & x in Label_(s1);
    consider s,s1,x such that
A7: y=[[s,x],s1] and
A8: s1 is_next_of s & x in Label_(s1) by A6;
A9: Run(i+1) = CastNode(s1,v) by A5,A7,XTUPLE_0:1
      .= s1 by Def16;
A10: [s,x] = [run.i,Gzai(i)] by A5,A7,XTUPLE_0:1;
    then Run(i) = CastNode(s,v) by XTUPLE_0:1
      .= s by Def16;
    hence thesis by A8,A10,A9,XTUPLE_0:1;
  end;
  then
A11: Run01 is_next_of Run00;
  defpred P[Nat] means for i,F st F is_subformula_of v & len(F)<=$1 & F in the
  LTLold of Run(i+1) holds Shift(w,i) |= F;
A12: for i holds Run(i) = run.i
  proof
    let i;
    reconsider i as Element of NAT by ORDINAL1:def 12;
    run.i in LTLStates(v);
    then
    ex x being Element of LTLNodes(v) st run.i =x & x is elementary strict
    LTLnode over v;
    hence thesis by Def16;
  end;
A13: for FSet be set st FSet in FinalS_LTL(v) holds {k where k is Element of
  NAT:Run(k) in FSet} is infinite
  proof
    let FSet be set;
    set X = {k where k is Element of NAT:run.k in FSet};
    set Y = {k where k is Element of NAT:Run(k) in FSet};
A14: X c= Y
    proof
      let x be object;
      assume x in X;
      then consider k being Element of NAT such that
A15:  x=k and
A16:  run.k in FSet;
      Run(k) in FSet by A12,A16;
      hence thesis by A15;
    end;
    assume FSet in FinalS_LTL(v);
    hence thesis by A3,A14;
  end;
A17: for n st P[n] holds P[n + 1]
  proof
    let n;
    assume
A18: P[n];
A19: for i,F st F is_subformula_of v & len(F) = n+1 & F in the LTLold of
    Run(i+1) holds Shift(w,i) |= F
    proof
      let i,F;
      assume that
A20:  F is_subformula_of v and
A21:  len(F)= n+1 and
A22:  F in the LTLold of Run(i+1);
      set zeta = Shift(w,i);
      now
        per cases by A20,Th63,Th65;
        suppose
A23:      F is Sub_atomic;
          set Gi9=CastSeq(w,AtomicFamily)^\i;
          set Gi=Gzai(i);
          CastSeq(zeta,AtomicFamily) = Gi9 by MODELC_2:81;
          then
A24:      CastSeq(zeta,AtomicFamily).0 = CastSeq(w,AtomicFamily).(0+i) by
NAT_1:def 3
            .= Gi;
          Gi in Label_(Run(i+1)) by A4;
          then consider X being Subset of atomic_LTL such that
A25:      Gi = X and
A26:      atomic_LTL(Run(i+1)) c= X and
A27:      Neg_atomic_LTL(Run(i+1)) misses X;
A28:      Neg_atomic_LTL(Run(i+1)) /\ X ={} by A27,XBOOLE_0:def 7;
          now
            per cases by A23,Th64;
            suppose
A29:          F is atomic;
              then F in atomic_LTL(Run(i+1)) by A22;
              hence thesis by A25,A26,A24,A29,MODELC_2:63;
            end;
            suppose
A30:          F is negative & the_argument_of F is atomic;
              set Fa= the_argument_of F;
A31:          F = 'not' Fa by A30,MODELC_2:4;
              then zeta |= F iff zeta |/= Fa by MODELC_2:64;
              then
A32:          zeta |= F iff not Fa in Gi by A24,A30,MODELC_2:63;
              Fa in Neg_atomic_LTL(Run(i+1)) by A22,A30,A31;
              hence thesis by A25,A28,A32,XBOOLE_0:def 4;
            end;
          end;
          hence thesis;
        end;
        suppose
A33:      F is conjunctive or F is disjunctive;
          set h1 = the_left_argument_of F;
          len(h1) < n+1 by A21,A33,MODELC_2:11;
          then
A34:      len(h1) <= n by NAT_1:13;
          set Runi1 = Run(i+1);
          set Runi = Run(i);
A35:      Runi1 is_next_of Runi by A4;
          set h2 = the_right_argument_of F;
          len(h2) < n+1 by A21,A33,MODELC_2:11;
          then
A36:      len(h2) <= n by NAT_1:13;
          reconsider Runi1 as elementary strict LTLnode over v by A35;
          reconsider Runi as elementary strict LTLnode over v by A35;
A37:      Runi1 is_next_of Runi & F in the LTLold of Runi1 implies (F is
conjunctive implies h1 in the LTLold of Runi1 & h2 in the LTLold of Runi1) & (F
is disjunctive implies h1 in the LTLold of Runi1 or h2 in the LTLold of Runi1)
          by Th41;
A38:      h1 is_subformula_of F & h2 is_subformula_of F by A33,MODELC_2:31;
          zeta |= F
          proof
            now
              per cases by A33;
              suppose
A39:            F is conjunctive;
                then
                zeta |= h1 & zeta |= h2 by A4,A18,A20,A22,A38,A34,A36,A37,
MODELC_2:35;
                then zeta |= h1 '&' h2 by MODELC_2:65;
                hence thesis by A39,MODELC_2:6;
              end;
              suppose
A40:            F is disjunctive;
                then zeta |= h1 or zeta |= h2 by A4,A18,A20,A22,A38,A34,A36,A37
,MODELC_2:35;
                then zeta |= h1 'or' h2 by MODELC_2:66;
                hence thesis by A40,MODELC_2:7;
              end;
            end;
            hence thesis;
          end;
          hence thesis;
        end;
        suppose
A41:      F is next;
          set i1=i+1;
          set Runi1 = Run(i1);
          set Runi2 = Run(i1+1);
          Runi2 is_next_of Runi1 by A4;
          then reconsider Runi2 as elementary strict LTLnode over v;
          set Runi =Run(i);
A42:      Runi1 is_next_of Runi by A4;
          set h = the_argument_of F;
A43:      h is_subformula_of F by A41,MODELC_2:30;
          len(h) < n+1 by A21,A41,MODELC_2:10;
          then
A44:      len(h) <= n by NAT_1:13;
          reconsider Runi1 as elementary strict LTLnode over v by A42;
          reconsider Runi as elementary strict LTLnode over v by A42;
A45:      Runi1 is_next_of Runi & F in the LTLold of Runi1 implies (F is
          next implies h in the LTLnext of Runi1) by Th41;
          the LTLnext of Runi1 c= the LTLold of Runi2 by A4,Th37;
          then Shift(w,i1) |= h by A4,A18,A20,A22,A41,A43,A44,A45,MODELC_2:35;
          then Shift(zeta,1) |= h by MODELC_2:80;
          then zeta |= 'X' h by MODELC_2:67;
          hence thesis by A41,MODELC_2:5;
        end;
        suppose
A46:      F is Until;
          set Fin = FinalS_LTL(F,v);
          deffunc Fun(set) = run.(CastNat($1)+i);
          set FRun = {k where k is Element of NAT:Run(k) in Fin};
A47:      for x st x in NAT holds Fun(x) in LTLStates(v);
          consider runQ being sequence of LTLStates(v) such that
A48:      for x st x in NAT holds runQ.x = Fun(x) from FUNCT_2:sch 11(
          A47);
          reconsider runQ as sequence of LTLStates(v);
          deffunc RunQ(Nat) = CastNode(runQ.$1,v);
A49:      for m holds RunQ(m) = Run(m+i)
          proof
            let m;
            reconsider m as Element of NAT by ORDINAL1:def 12;
            RunQ(m) = CastNode(Fun(m),v) by A48
              .= Run(m+i) by MODELC_2:def 1;
            hence thesis;
          end;
A50:      for m holds RunQ(m+1) is_next_of RunQ(m)
          proof
            let m;
            set m1 = m+i;
A51:        RunQ(m+1) = Run((m+1)+i) by A49
              .= Run(m1+1);
            RunQ(m) = Run(m1) by A49;
            hence thesis by A4,A51;
          end;
          set FRunQ = {k where k is Element of NAT:RunQ(k) in Fin};
A52:      Fin in FinalS_LTL(v) by A20,A46;
A53:      FRunQ is infinite
          proof
            set FRun2 = {k where k is Element of NAT:i<k & k in FRun};
            set FRun1 = {k where k is Element of NAT:k<=i & k in FRun};
A54:        FRun1 c= Seg i \/ {0}
            proof
              let x be object;
              assume x in FRun1;
              then consider k being Element of NAT such that
A55:          x = k and
A56:          k<=i and
              k in FRun;
              now
                per cases;
                suppose
                  k = 0;
                  then k in {0} by TARSKI:def 1;
                  hence thesis by A55,XBOOLE_0:def 3;
                end;
                suppose
                  k <> 0;
                  then 0<0+k;
                  then 1<= k by NAT_1:19;
                  then k in Seg i by A56,FINSEQ_1:1;
                  hence thesis by A55,XBOOLE_0:def 3;
                end;
              end;
              hence thesis;
            end;
A57:        FRunQ is finite implies FRun2 is finite
            proof
              deffunc Fun(object) = CastNat($1)+i;
              consider fun being Function such that
A58:          dom fun = FRunQ &
   for x being object st x in FRunQ holds fun.x =
              Fun(x) from FUNCT_1:sch 3;
A59:          x in FRun2 implies CastNat(x)-i in FRunQ
              proof
                assume x in FRun2;
                then consider k being Element of NAT such that
A60:            x = k and
A61:            i< k and
A62:            k in FRun;
                set k2=k-i;
                reconsider k2 as Element of NAT by A61,NAT_1:21;
A63:            RunQ(k2) = Run(k2+i) by A49
                  .= Run(k);
                (ex k1 being Element of NAT st k = k1 & Run(k1) in Fin )
                & CastNat(x)-i = k2 by A60,A62,MODELC_2:def 1;
                hence thesis by A63;
              end;
A64:          for y being object st y in FRun2
      ex x being object st x in dom fun & y = fun.x
              proof
                let y be object such that
A65:            y in FRun2;
                consider k being Element of NAT such that
A66:            y = k and
A67:            i< k and
                k in FRun by A65;
                set x = CastNat(y)-i;
A68:            x in dom fun by A59,A58,A65;
                set k1 = k-i;
                reconsider k1 as Nat by A67,NAT_1:21;
A69:            x = k1 by A66,MODELC_2:def 1;
                fun.x = Fun(x) by A59,A58,A65
                  .= k1 + i by A69,MODELC_2:def 1
                  .= y by A66;
                hence thesis by A68;
              end;
              assume FRunQ is finite;
              then rng fun is finite by A58,FINSET_1:8;
              hence thesis by A64,FINSET_1:1,FUNCT_1:9;
            end;
            FRun c= FRun1 \/ FRun2
            proof
              let x be object;
              assume
A70:          x in FRun;
              then ex k being Element of NAT st x = k & Run(k) in Fin;
              then reconsider x as Element of NAT;
              now
                per cases;
                suppose
                  x<=i;
                  then x in FRun1 by A70;
                  hence x in FRun1 \/ FRun2 by XBOOLE_0:def 3;
                end;
                suppose
                  i < x;
                  then x in FRun2 by A70;
                  hence x in FRun1 \/ FRun2 by XBOOLE_0:def 3;
                end;
              end;
              hence thesis;
            end;
            hence thesis by A13,A52,A57,A54;
          end;
          set h2 = the_right_argument_of F;
          set h1 = the_left_argument_of F;
          len(h1) < n+1 by A21,A46,MODELC_2:11;
          then
A71:      len(h1) <= n by NAT_1:13;
A72:      (for m st m>=1 holds F in the LTLold of RunQ(m) & h1 in the
LTLold of RunQ(m) & not (h2 in the LTLold of RunQ(m))) implies FRunQ is finite
          proof
            assume
A73:        for m st m>=1 holds F in the LTLold of RunQ(m) & h1 in
            the LTLold of RunQ(m) & not h2 in the LTLold of RunQ(m);
            now
              assume not FRunQ c= {0};
              then consider x being object such that
A74:          x in FRunQ and
A75:          not x in {0};
              consider k being Element of NAT such that
A76:          x = k and
A77:          RunQ(k) in Fin by A74;
              k <> 0 by A75,A76,TARSKI:def 1;
              then 0<0+k;
              then
A78:          1 <= k by NAT_1:19;
              set RQk = RunQ(k);
              consider y being Element of LTLStates(v) such that
A79:          RQk = y and
A80:          not F in the LTLold of CastNode(y,v) or h2 in the
              LTLold of CastNode(y,v) by A77;
              reconsider y as strict LTLnode over v by A79;
              CastNode(y,v) = RunQ(k) by A79,Def16;
              hence contradiction by A73,A78,A80;
            end;
            hence thesis;
          end;
          F in the LTLold of RunQ(1) by A22,A49;
          then consider j such that
A81:      j>=1 and
A82:      h2 in the LTLold of RunQ(j) and
A83:      for m st 1<=m & m<j holds F in the LTLold of RunQ(m) & h1
          in the LTLold of RunQ(m) by A46,A50,A53,A72,Th54;
          set j0 = j-1;
          reconsider j0 as Nat by A81,NAT_1:21;
          set j1=j0+i;
          j1+1 = j+i;
          then
A84:      h2 in the LTLold of Run(j1+1) by A49,A82;
A85:      h1 is_subformula_of F by A46,MODELC_2:31;
A86:      for k st k<j0 holds Shift(zeta,k) |= h1
          proof
            let k such that
A87:        k<j0;
            set k1 = k+1;
            set ki=k+i;
            1<=k1 & k+1 < j0+1 by A87,NAT_1:11,XREAL_1:8;
            then h1 in the LTLold of RunQ(k1) by A83;
            then h1 in the LTLold of Run(k1+i) by A49;
            then h1 in the LTLold of Run(ki+1);
            then Shift(w,ki) |= h1 by A18,A20,A85,A71,MODELC_2:35;
            hence thesis by MODELC_2:80;
          end;
          len(h2) < n+1 by A21,A46,MODELC_2:11;
          then
A88:      len(h2) <= n by NAT_1:13;
          h2 is_subformula_of F by A46,MODELC_2:31;
          then Shift(w,j1) |= h2 by A18,A20,A88,A84,MODELC_2:35;
          then
A89:      Shift(zeta,j0) |= h2 by MODELC_2:80;
          F = h1 'U' h2 by A46,MODELC_2:8;
          hence thesis by A89,A86,MODELC_2:68;
        end;
        suppose
A90:      F is Release;
          set h2 = the_right_argument_of F;
A91:      h2 is_subformula_of F by A90,MODELC_2:31;
          set h1 = the_left_argument_of F;
          defpred M[Nat] means (for k st k < $1 holds Shift(zeta,k) |= 'not'
          h1) implies Shift(zeta,$1) |= h2 & F in the LTLold of Run(i+1+$1);
          len(h1) < n+1 by A21,A90,MODELC_2:11;
          then
A92:      len(h1) <= n by NAT_1:13;
          len(h2) < n+1 by A21,A90,MODELC_2:11;
          then
A93:      len(h2) <= n by NAT_1:13;
A94:      h1 is_subformula_of F by A90,MODELC_2:31;
A95:      for j st M[j] holds M[j + 1]
          proof
            let j such that
A96:        M[j];
            M[j+1]
            proof
              set i1= i+j;
              set Run1=Run(i1+1);
              set Run0=Run(i1);
              assume
A97:          for k st k<j+1 holds Shift(zeta,k) |= 'not' h1;
A98:          for k st k<j holds Shift(zeta,k) |= 'not' h1
              proof
A99:            j <= j+1 by NAT_1:11;
                let k;
                assume k<j;
                then k<j+1 by A99,XXREAL_0:2;
                hence thesis by A97;
              end;
A100:         Run1 is_next_of Run0 by A4;
              then reconsider Run0 as elementary strict LTLnode over v;
              set i2=i1+1;
              set Run2=Run(i2+1);
A101:         Run2 is_next_of Run1 by A4;
              then reconsider Run2 as elementary strict LTLnode over v;
              reconsider Run1 as elementary strict LTLnode over v by A100;
              j<j+1 by NAT_1:13;
              then
A102:         Shift(zeta,j) |= 'not' h1 by A97;
A103:         now
                assume h1 in the LTLold of Run1;
                then Shift(w,i1) |= h1 by A18,A20,A94,A92,MODELC_2:35;
                then Shift(Shift(w,i),j) |= h1 by MODELC_2:80;
                hence contradiction by A102,MODELC_2:64;
              end;
A104:         Run1 is_next_of Run0 & F is Release & F in the LTLold of
Run1 & not h1 in the LTLold of Run1 implies h2 in the LTLold of Run1 & F in the
              LTLnext of Run1 by Th39;
              then h2 in the LTLold of Run2 by A4,A90,A96,A101,A98,A103,Th40;
              then
A105:         Shift(w,i+(j+1)) |= h2 by A18,A20,A91,A93,MODELC_2:35;
              F in the LTLold of Run2 by A4,A90,A96,A101,A98,A103,A104,Th40;
              hence thesis by A105,MODELC_2:80;
            end;
            hence thesis;
          end;
A106:     F = h1 'R' h2 by A90,MODELC_2:9;
A107:     (for j holds M[j]) implies zeta |= F
          proof
            assume for j holds M[j];
            then for j holds ((for k st k<j holds Shift(zeta,k) |= 'not' h1)
            implies Shift(zeta,j) |= h2);
            hence thesis by A106,MODELC_2:69;
          end;
A108:     M[0]
          proof
            set Run0=Run(i);
            set Run1=Run(i+1);
A109:       Run1 is_next_of Run0 by A4;
            then reconsider Run1 as elementary strict LTLnode over v;
            reconsider Run0 as elementary strict LTLnode over v by A109;
            assume for k st k < 0 holds Shift(zeta,k) |= 'not' h1;
A110:       Shift(zeta,0) = Shift(w,i) by MODELC_2:79;
            Run1 is_next_of Run0 & F in the LTLold of Run1 implies (F is
            Release implies h2 in the LTLold of Run1) by Th41;
            hence thesis by A4,A18,A20,A22,A90,A91,A93,A110,MODELC_2:35;
          end;
          for j holds M[j] from NAT_1:sch 2(A108,A95);
          hence thesis by A107;
        end;
      end;
      hence thesis;
    end;
    P[n+1]
    proof
      let i,F;
      assume that
A111: F is_subformula_of v and
A112: len(F)<=n+1 and
A113: F in the LTLold of Run(i+1);
      set L=len(F);
      reconsider L as Nat;
      now
        per cases by A112,NAT_1:8;
        suppose
          L<=n;
          hence thesis by A18,A111,A113;
        end;
        suppose
          L = n+1;
          hence thesis by A19,A111,A113;
        end;
      end;
      hence thesis;
    end;
    hence thesis;
  end;
A114: P[0] by MODELC_2:3;
A115: for n holds P[n] from NAT_1:sch 2(A114,A17);
  set n = len v;
A116: v in {v} & len(v)<=n by TARSKI:def 1;
  reconsider Run01 as elementary strict LTLnode over v by A11;
  reconsider Run00 as elementary strict LTLnode over v by A11;
A117: the LTLnext of Run00 c= the LTLold of Run01 by A4,Th37;
  Run(0) = CastNode(init v,v) by A1,TARSKI:def 1
    .= init v by Def16;
  then Shift(w,0) |= v by A117,A115,A116;
  hence thesis by MODELC_2:79;
end;
